“推断函数中使用的类型是文字”吗？

Question

There's an example in "Scala in Depth" where the author is explaining how scala can do some level of inference on the arguments passed into the methods. As an example the following is shown:

def myMethod(functionLiteral: A => B):Unit
myMethod({ arg:A => new B})
myMethod({ arg => new B})

Just to figure out what the author is talking about, I do the following in the REPL:

def myMethod(functionLiteral: Boolean => Boolean):Unit = {}
myMethod({a:Boolean => true})
myMethod({a => true})

The only revelatory thing that happens here is that the compiler doesn't throw an error.

Is the author trying to say that the function argument a is inferred to be a Boolean by the compiler?

Answer 1

Yes the author is saying that dont need to specify that a is a Boolean in myMethod({a => true}) because the type is Boolean => Boolean

== Original answer which makes the first bit compile but misses the point a bit ==

It needed to Be typed with [A,B] .

def myMethod[A,B](functionLiteral: A => B): Unit = {}
myMethod((arg:String) => arg.length)
myMethod((arg:Int) => (1 to arg).map(_ *2))

I modified it to return the function so you can see the types in the repl.

scala> def myMethod[A,B](functionLiteral: A => B): A => B = functionLiteral
myMethod: [A, B](functionLiteral: (A) => B)(A) => B

scala> myMethod((arg:String) => arg.length)
res11: (String) => Int = <function1>

scala> res11("hello world!")
res12: Int = 12

scala> myMethod((arg:Int) => (1 to arg).map(_ *2))
res13: (Int) => scala.collection.immutable.IndexedSeq[Int] = <function1>

scala> res13(4)
res14: scala.collection.immutable.IndexedSeq[Int] = Vector(2, 4, 6, 8)

Answer 2

Is the author trying to say that the function argument a is inferred to be a Boolean by the compiler?

Absolutely. Given the following method:

def myMethod(functionLiteral: Boolean => Boolean):Unit = {}

The compiler knows that the parameter to myMethod is a function that takes a boolean parameter, so it does not need you to specify it. In other words, in the following a is unambiguously a boolean parameter:

myMethod{a => true}

Now, it is worth noting that this does not work anymore when mixed with overloading:

def myMethod(functionLiteral: Boolean => Boolean):Unit = {}
def myMethod(functionLiteral: Int => Boolean):Unit = {}
myMethod{a => true} // error: missing parameter type

The reason is that it cannot unambiguously tell if a is of type Boolean or Int .