Scala Methods vs Functions

This chapter takes you through the differences between methods and functions in Scala programming. Both methods and functions are fundamental in Scala. But these have distinct characteristics and usages.

Introduction to Methods and Functions

Both methods and functions in Scala are reusable blocks of code. These perform specific tasks. However, both of these have some differences.

Methods

Methods in Scala are defined inside classes, traits, and objects. You can define a method using the def keyword in Scala. Methods can take parameters and return values. Methods encapsulate logic to be executed when called. These are invoked using the dot notation on objects or instances.

Functions

Functions in Scala are first-class citizens. It can be assigned to variables, passed as arguments, and returned from other functions. These are defined using function literals (also known as lambda expressions) and can be treated as values. You can define a function using the def keyword and the => symbol for anonymous function.

Differences between Methods and Functions

Methods

You can define a method using the def keyword, followed by the method name, parameter list, return type, and method body.

The syntax of the method is -

def methodName(param1: Type1, param2: Type2): ReturnType = {
  // Method body
  // return some value of ReturnType
}

Functions

You can define a function using the => syntax (function literal). It can be assigned to variables.

The syntax of the function is -

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

Example

The following examples shows the differences between methods and functions in Scala programming -

Method Example

object Demo {
  def add(a: Int, b: Int): 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

In the example, the add method takes two parameters of type Int. This method returns their sum. The Demo object calls the add method and prints the result.

Function Example

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.

Invoking Methods vs. Functions

Invoking Methods

Methods are invoked on instances of classes, traits, and objects using dot notation.

Example

val calc = new Calculator()
val result = calc.add(5, 3)

Invoking Functions

Functions are invoked by calling the function variable with the required parameters.

Example

val add = (x: Int, y: Int) => x + y
val result = add(5, 3)

Passing Functions as Parameters

You can pass functions as parameters to other functions and methods. So, there can be higher-order functions.

Example

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 method takes a function f as parameter with two integers a and b. The Demo object calls applyFunction with an anonymous function that adds two numbers.

Method-to-Function Conversion

You can convert a method into a function by using the underscore _ syntax.

Example

class Calculator {
  def add(x: Int, y: Int): Int = {
    x + y
  }
}

object Demo {
  def main(args: Array[String]): Unit = {
    val calc = new Calculator()
    val addFunction = calc.add _
    val result = addFunction(5, 3)
    println(s"The sum is: $result") // The sum is: 8
  }
}

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

Difference Between Methods and Functions

The following table shows the differences between methods and functions in Scala −

class Calculator {
def add(x: Int, y: Int): Int = x + y
}

val add = (x: Int, y: Int) => x + y

Methods vs Functions Summary

• Methods and functions are reusable blocks of code in Scala. But these have some differences.
• Methods are defined within a class, object, and trait using the def keyword and are invoked using dot
• Functions are first-class citizens. Functions can be assigned to variables, passed as arguments, and returned from other functions. These can be defined using the def keyword and the => symbol is used for anonymous functions.