Lambda Expression in Scala

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 :



    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

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

    chevron_right

    
    

    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 :

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

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

    chevron_right

    
    

    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 :

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

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

    chevron_right

    
    

    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 :

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

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

    chevron_right

    
    

    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 :

    filter_none

    edit
    close

    play_arrow

    link
    brightness_4
    code

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

    chevron_right

    
    

    Output:

    List(3.14, 12.56, 28.259999999999998)


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.




Article Tags :

Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.