Scala Higher Order Function

In scala, when a function accepts another function as an argument or returns a function as an output, is called Higher order function. Let’s understand this with examples.

Example1

Map is the good example for understanding higher order function. To demonstrate how this accepts a function as argument, we will create a function which will multiply the same number twice and then we will pass that function into map.

object multiply {
  def main(args: Array[String]): Unit = {
    def mulNum(a:Int) = a * a  //Function to multiply same number
    val lst = List.range(1,5)
    print(lst.map(mulNum))
  }
}

Output: List(1, 4, 9, 16)

We can also pass the anonymous function to perform the same task as above. For that, we can create an anonymous function as given below.

Anonymous function: x => x * x

It will give the same output.

object multiply {
  def main(args: Array[String]): Unit = {
    val lst = List.range(1,5)
    print(lst.map(x=>x*x))
  }
}

Output: List(1, 4, 9, 16)

Example2

Now, Let’s create a user defined higher order function which accepts a function as an arguments and returns nothing.

We will pass the below function as an argument, which itself accepts a String parameter and returns string parameter.

f:(String) => String

Next, define the function that matches the signature with above function which accept string parameter and return string parameter.

val myname = (name: String) => s”$name”

Now, Create a higher order function which takes 2 arguments and print the message as output of the function.

def PrintMsg(prefix: String) = (name:String ) => {
prefix + " " + name
}

We can call the function as given below.

val name="Shekhar"
printMsg(myname,name)

Now, let’s combine the full code and see the output.

object PrintName {
  def main(args: Array[String]): Unit = {
    val myname = (name: String)  => s"$name"
    def printMsg(f:(String) => String,msg:String){
      print(f(msg))
    }

    val name="Shekhar"
    printMsg(myname,name)

  }
}

Output: Shekhar

Example3

Let’s create a function that returns an anonymous function, assign that to a new function and then call that new function.

Define an anonymous function that takes a String as an argument and returns String.

(name:String)=>{ prefix + " " + name}

Let’s create a function that returns the above anonymous function from its body.

def PrintMsg(prefix: String) = (name:String ) => {
  prefix + " " + name
}

Now, We will call that function and assign it to a new function. New function will make another call with desired message to be printed.

val myNewFunc = PrintMsg("Hello")
print(myNewFunc("Thomas"))

Let’s combine the whole code and see the output.

object PrintName {
  def main(args: Array[String]): Unit = {
    def PrintMsg(prefix: String) = (name:String ) => {
      prefix + " " + name
    }

    val myNewFunc = PrintMsg("Hello")
    print(myNewFunc("Thomas"))
  }
}

Output: Hello Thomas