Scala type parameters by declaring the type inside the function

I'm just starting to learn Scala, coming from a Java background. I have been trying to understand type parameters in functions and inference of types. This is a standard example in the Scala docs:

class Decorator(left: String, right: String) {
  def layout[A](x: A) = left + x.toString() + right
}

object FunTest extends Application {
  def apply(f: Int => String, v: Int) = f(v)
  val decorator = new Decorator("[", "]")
  println(apply(decorator.layout, 7))
}

If I try to apply a type parameter to the apply function and keep v a strong type, a type mismatch occurs. Why doesn't the type get inferred here?

def apply[B](f: B => String, v: String) = f(v) //Type mismatch
def apply[B](f: B => String, v: B) = f(v)      //Works fine

Thanks

Solution

Let's take a look at apply without it's body:

 def apply[B](f: B => String, v: String)

That reads "apply is a function (method) parameterized on a type B, that takes a function from B to String, and a String".

Think of B as a type variable; it will need to be instantiated at some point. That point is not the declaration of apply. It is when apply is, well, applied to ;-)

By this contract, usage like this must be allowed:

 def g(i: Int): String = "i is " + i

 apply(g, "foo")  // Here the type variable `B` is "instantiated" to the type Int,

But given that you have a body like f(v), just substituting, we see the contradiction:

Substitute

 f(v)

With

 g("foo") // can't compile; g takes a B, which is an Int