Escala | Cierres

Los cierres de Scala son funciones que utilizan una o más variables libres y el valor de retorno de esta función depende de estas variables. Las variables libres se definen fuera de la función de cierre y no se incluyen como parámetro de esta función. Entonces, la diferencia entre una función de cierre y una función normal es la variable libre. Una variable libre es cualquier tipo de variable que no está definida dentro de la función y no se pasa como parámetro de la función. Una variable libre no está vinculada a una función con un valor válido. La función no contiene ningún valor para la variable libre.
Ejemplo:
Si definimos una función como se muestra a continuación:

def example(a:double) = a*p / 100

Ahora, al ejecutar el código anterior, obtendremos un error que comienza como no encontrado p. Así que ahora damos un valor a p fuera de la función.

// defined the value of p as 10
val p = 10
  
// define this closure.
def example(a:double) = a*p / 100

Ahora la función anterior está lista para ejecutarse ya que la variable libre tiene un valor. Ahora si ejecutamos las funciones como:

Calling the function: example(10000)
Input: p = 10
Output: double = 1000.0

Ahora, ¿qué sucede si cambia el valor de la variable libre? ¿Cómo cambia el valor de la función de cierre?
Básicamente, lo que hace la función de cierre es tomar el estado más reciente de la variable libre y cambiar el valor de la función de cierre en consecuencia.

Input: p = 10
Output: double = 1000.0

Input: p = 20
Output: double = 2000.0

Una función de cierre se puede clasificar además en funciones puras e impuras , según el tipo de variable libre. Si le damos a la variable libre un tipo var , entonces la variable tiende a cambiar el valor en cualquier momento a lo largo de todo el código y, por lo tanto, puede resultar en el cambio del valor de la función de cierre. Así, este cierre es una función impura. Por otro lado, si declaramos la variable libre del tipo val , entonces el valor de la variable permanece constante y, por lo tanto, la función de cierre es pura.

Ejemplo:

// Addition of two numbers with 
// Scala closure
  
// Creating object
object GFG
{
    // Main method
    def main(args: Array[String])
    {
        println( "Final_Sum(1) value = " + sum(1))
        println( "Final_Sum(2) value = " + sum(2))
        println( "Final_Sum(3) value = " + sum(3))
    }
          
    var a = 4
      
    // define closure function
    val sum = (b:Int) => b + a
}

Final_Sum(1) value = 5
Final_Sum(2) value = 6
Final_Sum(3) value = 7

Aquí, en la función de programa anterior, la suma es una función de cierre. var a = 4 es un cierre impuro. el valor de a es el mismo y los valores de b son diferentes.
Ejemplo:

// Scala closure program to print a string
  
// Creating object
object GFG
{
    // Main method
    def main(args: Array[String])
    {
      
        var employee = 50
      
        // define closure function
        val gfg = (name: String) => println(s"Company name is $name"+
                       s" and total no. of employees are $employee")
          
        gfg("geeksforgeeks")
    }
}

Company name is geeksforgeeks and total no. of employees are 50.

Aquí, en el ejemplo anterior, gfg es un cierre. var empleado es una variable mutable que se puede cambiar.