Escala | Funciones parcialmente aplicadas

Las funciones aplicadas parcialmente son las funciones que no se aplican a todos los argumentos definidos por la función establecida, es decir, al invocar una función, podemos proporcionar algunos de los argumentos y los argumentos de la izquierda se proporcionan cuando es necesario. llamamos a una función, podemos pasarle menos argumentos y cuando pasamos menos argumentos, no arroja una excepción. estos argumentos que no se pasan a la función, usamos guión (_) como marcador de posición.
Algunos puntos importantes:

• Las funciones aplicadas parcialmente son útiles para minimizar una función que acepta muchos argumentos a una función que acepta solo algunos argumentos.
• Puede reemplazar cualquier número de argumentos definidos por una función.
• Es más fácil para los usuarios utilizar este método.

Sintaxis:

val multiply = (a: Int, b: Int, c: Int) => a * b * c

// less arguments passed
val f = multiply(1, 2, _: Int)

Como podemos ver en la sintaxis anterior, definimos una función normal de multiplicación que tiene tres argumentos, pasamos menos argumentos (dos). podemos ver que no lanza una excepción que es una función parcialmente aplicada.
Ejemplo:

// Scala program of Partially
// applied functions
  
// Creating object
object Applied
{
  
    // Main method
    def main(args: Array[String])
    {
  
        // Creating a Partially applied
        // function
        def Book(discount: Double, costprice: Double) 
        : Double =
        {
  
            (1 - discount/100) * costprice
  
        }
  
        // Applying only one argument
        val discountedPrice = Book(25, _: Double)
  
        // Displays discounted price
        // of the book
        println(discountedPrice(400))
  
    }
}

300.0

Aquí, el descuento se pasa en el argumento y la parte del precio de costo se deja vacía, que se puede pasar más tarde cuando sea necesario, por lo que el precio con descuento se puede calcular cualquier número de veces.

Algunos ejemplos más de funciones parcialmente aplicadas:

1. Se puede obtener una función aplicada parcialmente incluso cuando no se aplica a ninguno de los argumentos definidos.
   Ejemplo:

   // Scala program of Partially // applied functions    // Creating object object Applied {        // Main method     def main(args: Array[String])     {            // Creating a Partially applied         // function         def Mul(x: Double, y: Double)         : Double =         {             x * y         }            // Not applying any argument         val r = Mul _            // Displays Multiplication         println(r(9, 8))     } }

   Producción:

   72.0
   

2. Las funciones aplicadas parcialmente se pueden utilizar para reemplazar cualquier número de parámetros.
   Ejemplo:

   // Scala program of Partially // applied functions    // Creating object object Applied {        // Main method     def main(args: Array[String])     {            // Creating a Partially applied         // function         def Mul(x: Double, y: Double, z: Double)         : Double =         {             x * y * z         }            // applying some arguments         val r = Mul(7, 8, _ : Double)            // Displays Multiplication         println(r(10))     } }

   Producción:

   560.0
   

3. El enfoque Currying se puede utilizar en funciones aplicadas parcialmente para transmitir una función con múltiples argumentos a múltiples funciones, donde cada función toma solo un argumento.
   Ejemplo:

   // Scala program of Partially // applied functions using // Currying approach    // Creating object object curr {        // Main method     def main(args: Array[String])     {            // Creating a Partially applied         // function         def div(x: Double, y: Double)          : Double =         {             x / y         }            // applying currying approach          val m = (div _).curried            // Displays division         println(m(72)(9))     } }

   Producción:

   8.0
   

   Aquí, el enfoque de curry divide la función dada en dos funciones, donde cada función toma un parámetro, por lo que debe pasar un valor para cada una de las funciones y obtener el resultado deseado.