Anonymous Functions in Scala

In Scala, An anonymous function is also known as a function literal. A function which does not contain a name is known as an anonymous function. An anonymous function provides a lightweight function definition. It is useful when we want to create an inline function.

Syntax:

(z:Int, y:Int)=> z*y
Or
(_:Int)*(_:Int)

• In the above first syntax, => is known as a transformer. The transformer is used to transform the parameter-list of the left-hand side of the symbol into a new result using the expression present on the right-hand side.
• In the above second syntax, _ character is known as a wildcard is a shorthand way to represent a parameter who appears only once in the anonymous function.

Anonymous Functions With Parameters

When a function literal is instantiated in an object is known as a function value. Or in other words, when an anonymous function is assigned to a variable then we can invoke that variable like a function call. We can define multiple arguments in the anonymous function.

Example 1:

Scala

// Scala program to illustrate the anonymous method 
object Main 
{ 
    def main(args: Array[String]) 
    { 
        
        // Creating anonymous functions 
        // with multiple parameters Assign 
        // anonymous functions to variables 
        var myfc1 = (str1:String, str2:String) => str1 + str2
        
        // An anonymous function is created 
        // using _ wildcard instead of 
        // variable name because str1 and 
        // str2 variable appear only once 
        var myfc2 = (_:String) + (_:String)

        
        // Here, the variable invoke like a function call 
        println(myfc1("Geeks", "12Geeks")) 
        println(myfc2("Geeks", "forGeeks")) 
    } 
} 

Output:

Geeks12Geeks
GeeksforGeeks

Anonymous Functions Without Parameters

We are allowed to define an anonymous function without parameters. In Scala, We are allowed to pass an anonymous function as a parameter to another function.

Example 2:

Scala

// Scala program to illustrate anonymous method 
object Main 
{ 
    def main(args: Array[String]) 
    { 
        
        // Creating anonymous functions 
        // without parameter 
        var myfun1 = () => {"Welcome to GeeksforGeeks...!!"} 
        println(myfun1()) 
        
        // A function which contain anonymous 
        // function as a parameter 
        def myfunction(fun:(String, String)=> String) =
        { 
            fun("Dog", "Cat") 
        } 
        
        // Explicit type declaration of anonymous 
        // function in another function 
        val f1 = myfunction((str1: String, 
                    str2: String) => str1 + str2) 
        
        // Shorthand declaration using wildcard 
        val f2 = myfunction(_ + _) 
        println(f1) 
        println(f2) 
    } 
} 

Output:

Welcome to GeeksforGeeks...!!
DogCat
DogCat