Let’s take a function definition and slim it down using type inference in our advantage:
def f: (Int => Int) = (x:Int) => x + 1 def f: (Int => Int) = x => x + 1 def f: (Int => Int) = _ + 1 def f = (x:Int) => x + 1
Let’s take a function definition and slim it down using type inference in our advantage:
def f: (Int => Int) = (x:Int) => x + 1 def f: (Int => Int) = x => x + 1 def f: (Int => Int) = _ + 1 def f = (x:Int) => x + 1
Scala is a statically typed JVM language which means that the variable types are defined at compile time. This is the case also for Java and C++ although the advanced type inference system in Scala let the language behave and ‘feel’ like a dynamic language although the compiler is still doing all the hard work of figuring out the variable type.
Consider the following examples in Java and Scala that produce identical compile code in the bytecode level.
Java code:
class TestTypeInferenceJava { public static void main(String[] args){ int x=10; } }
which after desassembling:
javap -c TestTypeInferenceJava
produces the following bytecode:
Compiled from "TestTypeInferenceJava.java" class TestTypeInferenceJava extends java.lang.Object{ TestTypeInferenceJava(); Code: 0: aload_0 1: invokespecial #1; //Method java/lang/Object."<init>":()V 4: return public static void main(java.lang.String[]); Code: 0: bipush 10 2: istore_1 3: return }
Note the bipush opcode that pushes the integer into the stack as well as the istore_1 that stores the integer into the stack as a local variable.
The equivalent Scala code is:
class TestTypeInference { def main(args: Array[String]): Unit = { var x=10 } }
that disassembles into:
public class TestTypeInference extends java.lang.Object implements scala.ScalaObject{ public void main(java.lang.String[]); Code: 0: bipush 10 2: istore_2 3: return public TestTypeInference(); Code: 0: aload_0 1: invokespecial #19; //Method java/lang/Object."<init>":()V 4: return }
Note the type inference of the integer variable (bipush and istore_1) as well as the identically produced bytecode (only discrepancy is the difference in the index of the corresponding local variable).