Scala: does variable type inference affect performance?

Question

In Scala, you can declare a variable by specifying a type, for example: (method 1)

var x : String = "Hello World" 

or you can let Scala automatically determine the type of the variable (method 2)

 var x = "Hello World" 

Why are you using method 1? Does it have a performance advantage?
And once a variable is declared, will it behave exactly the same in all situations if it is declared by method 1 or method 2?

Answer 1

Type inference is performed at compile time - essentially, the compiler calculates what you mean by filling in the blanks and then compiling the resulting code.

This means that there can be no run-time costs for input output. However, the time cost of compilation can be prohibitive and requires explicit annotation of some of your expressions.

Answer 2

You will not have a difference in performance using these two options. They will both be compiled with the same code.

Answer 3

Other answers suggest that the compiler suggested that you think it made a conclusion.

It is easy to demonstrate that the type specification in the definition sets the expected type for the RHS definition and inference of the type of manual.

For example, in this method that creates a collection of something, A is output as Nothing , which may not be what you wanted:

 scala> def build[A, B, C <: Iterable[B]](bs: B*)(implicit cbf: CanBuildFrom[A, B, C]): C = { | val b = cbf(); println(b.getClass); b ++= bs; b.result } build: [A, B, C <: Iterable[B]](bs: B*)(implicit cbf: scala.collection.generic.CanBuildFrom[A,B,C])C scala> val xs = build(1,2,3) class scala.collection.immutable.VectorBuilder xs: scala.collection.immutable.IndexedSeq[Int] = Vector(1, 2, 3) scala> val xs: List[Int] = build(1,2,3) class scala.collection.mutable.ListBuffer xs: List[Int] = List(1, 2, 3) scala> val xs: Seq[Int] = build(1,2,3) class scala.collection.immutable.VectorBuilder xs: Seq[Int] = Vector(1, 2, 3) 

Obviously, for runtime performance, it is important whether you have a list or a vector.

This is a chrome example, but in many expressions you won’t notice the type of intermediate collection unless it causes a performance problem.

Examples of conversations:

https://groups.google.com/forum/#!msg/scala-language/mQ-bIXbC1zs/wgSD4Up5gYMJ

http://grokbase.com/p/gg/scala-user/137mgpjg98/another-funny-quirk

Why does Seq.newBuilder return a ListBuffer?

https://groups.google.com/forum/#!topic/scala-user/1SjYq_qFuKk

Answer 4

In the simple example you specified, there is no difference in the generated bytecode, and therefore, there is no difference in performance. It would also not create a noticeable difference in compilation speed.

In more complex code (probably involving implicits), you may encounter situations where compilation type performance will improve markedly by specifying some types. However, I would completely ignore this until you come across it - specify types or not for other, better reasons.

According to your question, there is one very important case when it is recommended to specify the type in order to ensure good performance at runtime. Consider this code:

 val x = new AnyRef { def sayHi() = println("Howdy!") } x.sayHi 

This code uses reflection to invoke sayHi, and that is a huge performance hit. Recent versions of Scala will warn you about this code for this reason, if you did not enable the language function for it:

 warning: reflective access of structural type member method sayHi should be enabled by making the implicit value scala.language.reflectiveCalls visible. This can be achieved by adding the import clause 'import scala.language.reflectiveCalls' or by setting the compiler option -language:reflectiveCalls. See the Scala docs for value scala.language.reflectiveCalls for a discussion why the feature should be explicitly enabled. 

Then you can change the code to this one that does not use reflection:

 trait Talkative extends AnyRef { def sayHi(): Unit } val x = new Talkative { def sayHi() = println("Howdy!") } x.sayHi 

For this reason, you usually want to specify the type of a variable when you define classes this way; Thus, if you inadvertently add a method that requires reflection to be called, you will get a compilation error - the method will not be defined for the type of the variable. Thus, although it is not that type specifying makes the code run faster, in this case, if the code is slow, type specifying makes compilation impossible.

 val x: AnyRef = new AnyRef { def sayHi() = println("Howdy!") } x.sayHi // ERROR: sayHi is not defined on AnyRef 

There are, of course, other reasons why you might need to specify a type. They are necessary for the formal parameters of methods / functions and for return types of recursive or overloaded methods.

In addition, you should always specify return types for methods in the public API (unless they are simply trivially obvious), or you can use different method signatures than you planned, and then risk compromising existing clients of your API when you correct the signature.

Of course, you can intentionally expand the type so that you can later assign other types of objects, for example,

 var shape: Shape = new Circle(1.0) shape = new Square(1.0) 

But in these cases, the impact of performance is not affected.

It is also possible that specifying the type will lead to the conversion, and of course, this will have a performance impact that affects the conversion.