Typed Function and Currying in Scala

Question

In Scala let's say I have a function like this:

def foo[R](x: String, y: () => R): R

so I can do:

val some: Int = foo("bar", { () => 13 })

Is there a way to change this to use function currying without "losing" the type of the second argument?

def foo[R](x: String)(y: () => R): R
val bar = foo("bar") <-- this is now of type (() => Nothing)
val some: Int = bar(() => 13) <-- doesn't work

Answer 1

Functions can't have type parameters, you have to use a custom class like this:

def foo(x: String) = new {
  def apply[R](y: () => R): R = y()
}

val bar = foo("bar")
val some: Int = bar(() => 13)
// Int = 13

To avoid structural typing you could create custom class explicitly:

def foo(x: String) = new MyClass...

Answer 2

A variation on senia's answer, to avoid structural typing:

case class foo(x: String) extends AnyVal {
  def apply[R](y: () => R): R = y()
}

val bar = foo("bar")
val some: Int = bar(() => 13)
// Int = 13

Answer 3

Not really a solution to your problem but just to point out that you can still use the second version of your function if you supply the type explicitly:

scala> def foo[R](x: String)(y: () => R): R = y()
foo: [R](x: String)(y: () => R)R

scala> val bar = foo[Int]("bar") _
bar: (() => Int) => Int = <function1>

scala> bar(() => 12)
res1: Int = 12