Related Articles
Lambda Expression in Scala
• Last Updated : 28 Feb, 2019

Lambda Expression refers to an expression that uses an anonymous function instead of variable or value. Lambda expressions are more convenient when we have a simple function to be used in one place. These expressions are faster and more expressive than defining a whole function. We can make our lambda expressions reusable for any kind of transformations. It can iterate over a collection of objects and perform some kind of transformation to them.
Syntax:

`val lambda_exp = (variable:Type) => Transformation_Expression`

Example:

```// lambda expression to find double of x
val ex = (x:Int) => x + x```
Working With Lambda Expressions
• We can pass values to a lambda just like a normal function call.
Example :
 `// Scala program to show``// working of lambda expression`` ` `// Creating object``object` `GfG``{``     ` `// Main method``def` `main(args``:``Array[String])``{ ``    ``// lambda expression``    ``val` `ex``1` `=` `(x``:``Int) ``=>` `x + ``2`` ` `    ``// with multiple parameters``    ``val` `ex``2` `=` `(x``:``Int, y``:``Int) ``=>` `x * y``     ` `    ``println(ex``1``(``7``))``    ``println(ex``2``(``2``, ``3``))``}``}`

Output:

```9
6```
• To apply transformation to any collection, we generally use map() function. It is a higher-order function where we can pass our lambda as a parameter in order to transform every element of the collection according to the definition of our lambda expression.
Example :

 `// 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)``}``}`

Output:

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

We can see that the defined anonymous function to perform the square operation is not reusable.

• We are passing it as an argument. However, we can make it reusable and may use it with different collections.
Example :
 `// Scala program to apply``// transformation on collection`` ` `// Creating object``object` `GfG``{``    ``// Main method``    ``def` `main(args``:``Array[String])``    ``{``        ``// list of numbers``        ``val` `l``1` `=` `List(``1``, ``1``, ``2``, ``3``, ``5``, ``8``)``        ``val` `l``2` `=` `List(``13``, ``21``, ``34``)``     ` `        ``// reusable lambda``        ``val` `func ``=` `(x``:``Int) ``=>` `x * x`` ` `        ``// squaring each element of the lists``        ``val` `res``1` `=` `l``1``.map( func )``        ``val` `res``2` `=` `l``2``.map( func )``     ` `        ``println(res``1``)``        ``println(res``2``)``    ``}``}`

Output:

```List(1, 1, 4, 9, 25, 64)
List(169, 441, 1156)```
• A lambda can also be used as a parameter to a function.
Example :
 `// 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)``}``}`

Output:

`12.56`

In above example, transform function accepts integer x and function f, applies the transformation to x defined by f. Lambda passed as the parameter in function call returns Double type. Therefore, parameter f must obey the lambda definition.

• We can perform the same task on any collection as well. In case of collections, the only change we need to make in transform function is using map function to apply transformation defined by f to every element of the list l.
Example :
 `// 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)``    ``}``}`

Output:

`List(3.14, 12.56, 28.259999999999998)`
My Personal Notes arrow_drop_up