Scala - Functions

---

---

A function is a group of statements that perform a task. You can divide up your code into separate functions. How you divide up your code among different functions is up to you, but logically, the division usually is so that each function performs a specific task.

Scala has both functions and methods and we use the terms method and function interchangeably with a minor difference. A Scala method is a part of a class which has a name, a signature, optionally some annotations, and some bytecode where as a function in Scala is a complete object which can be assigned to a variable. In other words, a function, which is defined as a member of some object, is called a method.

A function definition can appear anywhere in a source file and Scala permits nested function definitions, that is, function definitions inside other function definitions. Most important point to note is that Scala function's name can have characters like +, ++, ~, &,-, --, \, /, :, etc.

Function Declarations

A Scala function declaration has the following form −

def functionName ([list of parameters]) : [return type]

Methods are implicitly declared abstract if you dont use the equals sign and the method body.

Function Definitions

A Scala function definition has the following form −

Syntax

def functionName ([list of parameters]) : [return type] = {
   function body
   return [expr]
}

Here, return type could be any valid Scala data type and list of parameters will be a list of variables separated by comma and list of parameters and return type are optional. Very similar to Java, a return statement can be used along with an expression in case function returns a value. Following is the function which will add two integers and return their sum −

Syntax

object add {
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b
      return sum
   }
}

A function, that does not return anything can return a Unit that is equivalent to void in Java and indicates that function does not return anything. The functions which do not return anything in Scala, they are called procedures.

Syntax

Here is the syntax −

object Hello{
   def printMe( ) : Unit = {
      println("Hello, Scala!")
   }
}

Calling Functions

Scala provides a number of syntactic variations for invoking methods. Following is the standard way to call a method −

functionName( list of parameters )

If a function is being called using an instance of the object, then we would use dot notation similar to Java as follows −

[instance.]functionName( list of parameters )

Try the following example program to define and then call the same function.

Example

object Demo {
   def main(args: Array[String]) {
      println( "Returned Value : " + addInt(5,7) );
   }
   
   def addInt( a:Int, b:Int ) : Int = {
      var sum:Int = 0
      sum = a + b

      return sum
   }
}

Save the above program in Demo.scala. The following commands are used to compile and execute this program.

Command

\>scalac Demo.scala
\>scala Demo

Output

Returned Value : 12

Anonymous Functions

Anonymous functions defined without a name. Anonymous functions are used as arguments to higher-order functions. These functions are also known as function literals.

Syntax

The syntax of the anonymous function is -

(val param1: Type1, param2: Type2) => {
  // Function body
}

Example

The following example shows an anonymous function in Scala programming -

object Demo {
  def main(args: Array[String]): Unit = {
    val add = (a: Int, b: Int) => a + b
    val sum = add(5, 3)
    println(s"The sum is: $sum")
  }
}

Save the above program in Demo.scala. Use the following commands to compile and execute this program.

Command

> scalac Demo.scala
> scala Demo

Output

The sum is: 8

In the example, an anonymous function is assigned to the add variable. The Demo object calls the anonymous function and prints the result.

Higher-Order Functions

Higher-order functions take other functions as parameters. These functions may also return functions.

Syntax

The syntax of the higher order function is -

def higherOrderFunction(f: (Type1, Type2) => ReturnType): ReturnType = {
  // Function body
}

Example

The following example shows a higher-order function in Scala programming -

object Demo {
  def applyFunction(f: (Int, Int) => Int, a: Int, b: Int): Int = {
    f(a, b)
  }

  def main(args: Array[String]): Unit = {
    val add = (a: Int, b: Int) => a + b
    val sum = applyFunction(add, 5, 3)
    println(s"The sum is: $sum")
  }
}

Save the above program in Demo.scala. Use the following commands to compile and execute this program.

Command

> scalac Demo.scala
> scala Demo

Output

The sum is: 8

In the example, the applyFunction function takes another function f as a parameter with two integers a and b. The Demo object calls applyFunction with anonymous function that adds two numbers.

Curried Functions

Curried functions return other functions. So, you can apply arguments one at a time.

Syntax

The syntax of the curried function is −

def curriedFunction(param1: Type1)(param2: Type2): ReturnType = {
   // Function body
}

Example

The following example shows a curried function in Scala programming -

object Demo {
  def add(a: Int)(b: Int): Int = {
    a + b
  }

  def main(args: Array[String]): Unit = {
    val addFive = add(5) _
    val sum = addFive(3)
    println(s"The sum is: $sum")
  }
}

Save the above program in Demo.scala. Use the following commands to compile and execute this program.

Command

> scalac Demo.scala
> scala Demo

Output

The sum is: 8

In the example, the add function is a curried function. It takes two parameters separately. Demo object shows how to partially apply the add function to create a new function addFive, which adds 5 to its argument.

Functions as Objects

Functions in Scala are objects. These can be assigned to variables. These can be passed as parameters and returned from other functions.

Syntax

The syntax of the function as object is −

val functionName = (param1: Type1, param2: Type2) => {
   // Function body
}

Example

The following example treats functions as objects in Scala programming -

object Demo {
  val add = (a: Int, b: Int) => a + b

  def main(args: Array[String]): Unit = {
    val sum = add(5, 3)
    println(s"The sum is: $sum")
  }
}

Save the above program in Demo.scala. Use the following commands to compile and execute this program.

Command

> scalac Demo.scala
> scala Demo

Output

The sum is: 8

Scala functions are the heart of Scala programming and that's why Scala is assumed as a functional programming language. Following are few important concepts related to Scala functions which should be understood by a Scala programmer.