In Scala, why does a type annotation must follow for the function parameters ? Why does the compiler not infer the function parameter types?

Question

I have a simple question, why is the Scala compiler not able to infer the function parameter types by itself ?

Answer 1

Some functional programming languages, like Haskell, can infer almost all types, because they can perform global type inference. Scala can’t do this, in part because Scala has to support subtype polymorphism (inheritance), which makes type inference much harder. Here is a summary of the rules for when explicit type annotations are required in Scala.

When Explicit Type Annotations Are Required

In practical terms, you have to provide explicit type annotations for the following situations:

• A mutable var or immutable val declaration where you don’t assign a value, (e.g., abstract declarations in a class like val book: String, var count: Int

• All method parameters (e.g., def deposit(amount: Money) = {…}).

• Method return types in the following cases:

  1)When you explicitly call return in a method (even at the end).

  2)When a method is recursive.

  3)When two or more methods are overloaded (have the same name) and one of them calls another; the calling method needs a return type annotation.

  4)When the inferred return type would be more general than you intended, e.g., Any.

Source Programming Scala, 2nd Edition - O'Reilly Media

Answer 2

I have a simple question, why is the Scala compiler not able to infer the function parameter types by itself ?

Scala has local type inference. If you look at the method, and look at what information is there locally, it should be easy to see, that there simply is no information about what the types could possibly be.

Say, you have the following method:

def foo(a) = a + a

How is Scala going to figure out what type a is? It can only figure that out from looking at how the method is called, but that is non-local information!

And even worse: since Scala supports dynamic code loading, it is possible that the calling code doesn't even exist yet at compile time.