在Scala REPL中键入信息

Question

If I'm using the F# interpreter, I can define a simple function like this:

> // Function to check if x is an integer multiple of y
> let multipleOf x y = (x % y = 0);;

val multipleOf : x:int -> y:int -> bool

If I know a function exists in the F# interpreter session but I'm unsure of its precise type, I can ask the interpreter to give me its type simply by typing the function's name:

> // I can't remember the type of the function multipleOf!
> multipleOf;;

val it : (int -> int -> bool) = <fun:it@12-1>

Clearly, this tells me that the function multipleOf is of type int->int->bool . I find this incredibly useful as a tool to jog my memory when working in the F# interpreter.

However, I can't seem to find similar functionality in Scala's REPL. I can define an equivalent function in Scala easily enough of course:

def multipleOf(x: Int, y: Int) = x % y == 0

But if I'm ten minutes on in my Scala REPL session and can't remember the type of the function, typing multipleOf gives no information about the type (in fact, it gives an error). Similarly, :type multipleOf tells me nothing useful.

Answer 1

scala> val f = (i: Int, j: Int) => i % j == 0
f: (Int, Int) => Boolean = <function2>

scala> f
res2: (Int, Int) => Boolean = <function2>

scala> def multipleOf(x: Int, y: Int) = x % y == 0
multipleOf: (x: Int, y: Int)Boolean

scala> :type multipleOf(_, _)
(Int, Int) => Boolean

Answer 2

Yuck! This is one of those occasions where the solution to a question occurs to you just as you're about to submit the question to StackOverflow. Hopefully someone will find it useful if I answer it here myself.

It turns out that Scala will play ball on providing type information for functions as long as you tell it to evaluate the function as a partially evaluated function! In other words, the following does the trick:

scala> multipleOf _
res0: (Int, Int) => Boolean = <function2>

In other words, the REPL gives you information about the type of a function only if you reevaluate the function as a partially evaluated version of itself. This seems significantly less than optimal. ;-)

Perhaps somebody can mention in the comments why it's sane for Scala to approach things this way?