función pura en scala

En cualquier lenguaje de programación, hay dos tipos de funciones: 

1. FUNCIONES PURAS

2. FUNCIONES IMPURAS
Hay una diferencia básica entre las dos, es que la función pura no cambia la variable que se pasa y una función impura sí. Por ejemplo, existe una función que aumenta la entrada en 10. Entonces, hay dos posibilidades, la primera es que podría devolver directamente x + 10 y, por lo tanto, x no cambia, mientras que en otro caso podría ir con la declaración como x = x + 10 y luego devuelve x, cambiando así el valor de x. Entonces, la primera función es pura mientras que la otra es impura .
 

función pura en scala

Una función se llama función pura si siempre devuelve el mismo resultado para los mismos valores de argumento y no tiene efectos secundarios como modificar un argumento (o variable global) o generar algo. 
Son aquellas funciones que no leen ningún otro valor excepto los dados como entrada y siguen su algoritmo interno para producir la salida. Una función pura no tiene efectos secundarios , es decir, no cambia el valor de la variable implícitamente y, por lo tanto, no termina alterando los valores de la entrada. 
Estos métodos de Scala String también son funciones puras: 
 

• esta vacio
• longitud
• substring

Se puede hacer una función pura como se muestra en el siguiente código de programa: 
Ejemplo 1: 
 

// Pure function In Scala
object GFG
{
    // Driver code
    def main(args: Array[String])
    {
        def square(a:Int) = {
            var b:Int = a * a;
            println("Square of the number is " + b);
            println("Number is " + a);
        }
        square(4);
    }
}

Producción: 
 

Square of the number is 16
Number is 4

Ahora, sabemos que esta función no cambia la variable implícitamente, así que sumamos el resultado de dos funciones diferentes de diferentes maneras, como se muestra: 
Ejemplo 2: 
 

// Scala Pure Function
object GFG
{
    // Driver code
    def main(args: Array[String])
    {
        // Function 1
        def add(a:Int, b:Int):Int = {
            var c:Int = a + b;
            return c;
        }
         
        // Function 2
        def multiply(a:Int, b:Int):Int = {
            var c:Int = a * b;
            return c;
        }
         
        // Calculating same value but changing
        // the position of the functions
        println("Output in case 1 :" +
                add(1, 2) * multiply(3, 4));
        println("Output in case 2 :" +
                multiply(4, 3) * add(2, 1));
    }
}

Producción: 
 

Output in case 1 :36
Output in case 2 :36

Ahora, como la salida de ambos casos es la misma, se prueba que la entrada en la función pura en Scala no cambia implícitamente.
A continuación se muestran los beneficios del uso de funciones puras: 
 

1. No causan ningún cambio implícito en la entrada.
2. Son más fáciles de probar.
3. Se pueden depurar fácilmente.