Escala | Inferencia de tipo

Scala Type Inference hace que sea opcional especificar el tipo de variable siempre que se maneje la falta de coincidencia de tipos. Con capacidades de inferencia de tipos, podemos pasar menos tiempo escribiendo cosas que el compilador ya sabe. El compilador de Scala a menudo puede inferir el tipo de una expresión para que no tengamos que declararla explícitamente.
Primero echemos un vistazo a la sintaxis de cómo se declaran las variables inmutables en Scala.

val variable_name : Scala_data_type = value

Ejemplo:

// Scala program of type interference
object Geeks 
{ 
    
    // Main method 
    def main(args: Array[String]) 
    { 
        // prints a double value
        val a : Double = 7.893
        println(a)  
        println(a.getClass)
          
    } 
} 

Producción :

7.893
double

En el ejemplo anterior, el método getClass se usa para imprimir el tipo de variable en la consola. Para el ejemplo anterior, el tipo de variable ‘a’ es doble.

Sin embargo, a través de la inferencia de tipos, Scala detecta automáticamente el tipo de la variable sin que el usuario lo haya especificado explícitamente.
Ejemplo :

// Scala program of type interference
object Geeks { 
  
    // Main method 
    def main(args: Array[String]) 
    { 
        // type inference
        println("Scala Data Types")
        val number = 5
        val big_number = 100000000L
        val small_number = 1
        val double_number = 2.50
        val float_number = 2.50f
        val string_of_characters = "This is a string of characters"
        val byte = 0xc
        val character = 'D'
        val empty = ()
          
        println(number)
        println(big_number)
        println(small_number)
        println(double_number)
        println(float_number)
        println(string_of_characters)
        println(byte)
        println(character)
        println(empty)
          
    } 
} 

Producción :

Scala Data Types
5
100000000
1
2.5
2.5
This is a string of characters
12
D
()

Tenga en cuenta que no se especifica explícitamente ningún tipo de datos para las variables anteriores.

Inferencia de tipos en Scala para funciones
Ahora veremos cómo funciona la inferencia de tipos para funciones en Scala.
Primero echemos un vistazo a cómo se declaran las funciones en Scala.
Sintaxis:

 def function_name ([parameter_list]) : [return_type] = {
   
  // function body

}

Ejemplo :

// Scala program of multiply two numbers
object Geeks 
{ 
  
    // Main method 
    def main(args: Array[String])
    { 
          
        // Calling the function 
        println("Product of the two numbers is: " + Prod(5, 3)); 
    } 
      
      
    // declaration and definition of Product function 
    def Prod(x:Int, y:Int) : Int =
    { 
        return x*y 
    } 
} 

Producción :

Product of the two numbers is: 15

En el ejemplo anterior, como podemos a partir de la declaración de que el tipo de retorno especificado es Int. Con la inferencia de tipos de Scala, Scala detecta automáticamente el tipo de función sin que el usuario lo especifique explícitamente.
Ejemplo :

// Scala program of type interference
object Geeks 
{ 
  
    def factorial(n: Int)= { 
          
        var f = 1
        for(i <- 1 to n) 
        { 
            f = f * i; 
        } 
          
        f 
    } 
  
    // Driver Code 
    def main(args: Array[String]) 
    { 
        println(factorial(5)) 
    }
  
}

Producción :

120

def factorial(n: Int)= 

En el ejemplo anterior, se omiten los dos puntos y el tipo de devolución.

Además, en el ejemplo anterior, hemos omitido la declaración «return f» a «f» ya que no hemos especificado el tipo de devolución.
Si en lugar de «f», se colocó «return f», el compilador muestra el siguiente error.

prog.scala:11: error: method factorial has return statement; needs result type
        return f
        ^

Esto muestra el poder de la inferencia de tipos de Scala, pero para los métodos recursivos, el compilador no puede inferir un tipo de resultado. La función factorial anterior también se puede implementar de forma recursiva.
La siguiente es una definición recursiva de la función factorial sin inferencia de tipo.
Ejemplo :

// Scala program of using recursion
object Geeks { 
  
    // factorial function
    def factorial(n: Int): Int =
    { 
        if (n == 0) 
            return 1
        else
            return n * factorial(n-1) 
    } 
  
    // Driver Code 
    def main(args: Array[String]) 
    { 
        println(factorial(5)) 
    } 
  
}

Producción :

120

Ejemplo: con inferencia de tipo Scala

// Scala program of type interference
object Geeks 
{ 
      
    // Defining function with type interfrence
    def factorial(n: Int) =
    { 
        if (n == 0) 
            1
        else
            n * factorial(n-1) 
    } 
  
    // Driver Code 
    def main(args: Array[String]) 
    { 
        println(factorial(5)) 
    } 
  
}

Producción:

Compile Errors :
prog.scala:8: error: recursive method factorial needs result type
            n * factorial(n-1)
                ^