Lambda Expression in Scala

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
We can pass values to a lambda just like a normal function call.Example :// Scala program to show// working of lambda expression  // Creating objectobject GfG{      // Main methoddef 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))}}Output:9
6
// Scala program to show// working of lambda expression  // Creating objectobject GfG{      // Main methoddef 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))}}
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 objectobject GfG{      // Main methoddef 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 )  /* ORval 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.
// Scala program to apply// transformation on collection  // Creating objectobject GfG{      // Main methoddef 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 )  /* ORval 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 objectobject 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)    }}Output:List(1, 1, 4, 9, 25, 64)
List(169, 441, 1156)
// Scala program to apply// transformation on collection  // Creating objectobject 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)    }}
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 objectobject 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.56In 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.
// Scala program to pass lambda// as parameter to a function  // Creating objectobject 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 objectobject 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)
// Scala program to pass lambda// as parameter to a function  // Creating objectobject 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)
Picked
Scala
Scala-Method
Scala
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
For Loop in Scala
Scala | map() method
Scala | flatMap Method
String concatenation in Scala
Scala | reduce() Function
Scala List filter() method with example
Type Casting in Scala
Scala Tutorial – Learn Scala with Step By Step Guide
Scala String substring() method with example
How to Install Scala with VSCode?