Expresión Lambda en Scala

Lambda Expression hace referencia a una expresión que utiliza una función anónima en lugar de una variable o un valor. Las expresiones lambda son más convenientes cuando tenemos una función simple para usar en un solo lugar. Estas expresiones son más rápidas y expresivas que definir una función completa. Podemos hacer que nuestras expresiones lambda sean reutilizables para cualquier tipo de transformaciones. Puede iterar sobre una colección de objetos y realizar algún tipo de transformación en ellos.
Sintaxis :

val lambda_exp = (variable:Type) => Transformation_Expression

Ejemplo :

// lambda expression to find double of x
val ex = (x:Int) => x + x

• Podemos pasar valores a una lambda como una llamada de función normal.
  Ejemplo :

  // Scala program to show // working of lambda expression    // Creating object object GfG {        // Main method def main(args:Array[String]) {      // lambda expression     val ex1 = (x:Int) => x + 2        // with multiple parameters     val ex2 = (x:Int, y:Int) => x * y            println(ex1(7))     println(ex2(2, 3)) } }

  Producción:

  9
  6

• Para aplicar la transformación a cualquier colección, generalmente usamos la función map() . Es una función de orden superior donde podemos pasar nuestra lambda como parámetro para transformar cada elemento de la colección de acuerdo con la definición de nuestra expresión lambda.
  Ejemplo :

  // Scala program to apply // transformation on collection    // Creating object object GfG {        // Main method def main(args:Array[String]) {     // list of numbers     val l = List(1, 1, 2, 3, 5, 8)        // squaring each element of the list     val res = l.map( (x:Int) => x * x )    /* OR val res = l.map( x=> x * x ) */     println(res) } }

  Producción:

  List(1, 1, 4, 9, 25, 64)

  Podemos ver que la función anónima definida para realizar la operación cuadrada no es reutilizable.

• Lo estamos pasando como un argumento. Sin embargo, podemos hacerlo reutilizable y usarlo con diferentes colecciones.
  Ejemplo :

  // Scala program to apply // transformation on collection    // Creating object object GfG {     // Main method     def main(args:Array[String])     {         // list of numbers         val l1 = List(1, 1, 2, 3, 5, 8)         val l2 = List(13, 21, 34)                // reusable lambda         val func = (x:Int) => x * x            // squaring each element of the lists         val res1 = l1.map( func )         val res2 = l2.map( func )                println(res1)         println(res2)     } }

  Producción:

  List(1, 1, 4, 9, 25, 64)
  List(169, 441, 1156)

• Una lambda también se puede utilizar como parámetro de una función.
  Ejemplo :

  // Scala program to pass lambda // as parameter to a function    // Creating object object GfG {        // transform function with integer x and      // function f as parameter     // f accepts Int and returns Double     def transform( x:Int, f:Int => Double)      =     f(x)        // Main method     def main(args:Array[String])     {                // lambda is passed to f:Int => Double         val res = transform(2, r => 3.14 * r * r)            println(res) } }

  Producción:

  12.56

  En el ejemplo anterior, la función de transformación acepta el número entero x y la función f, aplica la transformación a x definida por f. Lambda pasada como parámetro en la llamada de función devuelve el tipo doble . Por lo tanto, el parámetro f debe obedecer la definición lambda.

• También podemos realizar la misma tarea en cualquier colección. En el caso de las colecciones, el único cambio que necesitamos hacer en la función de transformación es usar la función de mapa para aplicar la transformación definida por f a cada elemento de la lista l .
  Ejemplo :

  // Scala program to pass lambda // as parameter to a function    // Creating object object GfG {        // transform function with integer list l and      // function f as parameter     // f accepts Int and returns Double     def transform( l:List[Int], f:Int => Double)      =     l.map(f)        // Main method     def main(args:Array[String])     {         // lambda is passed to f:Int => Double         val res = transform(List(1, 2, 3), r => 3.14 * r * r)         println(res)     } }

  Producción:

  List(3.14, 12.56, 28.259999999999998)