Functions And Methods | Scala Basics

Introduction to Functions

Functions are fundamental building blocks in Scala that allow you to encapsulate code for reuse. A function is defined using the def keyword followed by the function's name, parameters, and return type.

Defining a Function

Here is how you can define a simple function in Scala:

def add(a: Int, b: Int): Int = a + b

This function add takes two integer parameters a and b and returns their sum as an integer.

Calling a Function

To call a function, simply use its name followed by arguments in parentheses:

val result = add(5, 3)

In this case, result will hold the value 8.

Output: 8

Understanding Methods

In Scala, a method is similar to a function but is defined within a class or an object. Methods can access the instance variables of the class.

Defining a Method

Here's how you define a method within a class:

class Calculator {
def multiply(a: Int, b: Int): Int = a * b
}

The Calculator class has a method multiply that returns the product of two integers.

Creating an Instance and Calling a Method

To use the method, create an instance of the class:

val calc = new Calculator()
val product = calc.multiply(4, 5)

After calling the multiply method, product will hold the value 20.

Output: 20

Higher-Order Functions

Scala supports higher-order functions, which can take other functions as parameters or return them. This allows for greater flexibility and abstraction.

Here's an example of a higher-order function:

def applyFunction(f: Int => Int, x: Int): Int = f(x)

In this case, applyFunction takes a function f and an integer x and applies the function to x.

Using Higher-Order Functions

You can use the higher-order function like this:

val double = (x: Int) => x * 2
val result = applyFunction(double, 10)

Here, result will hold the value 20, as the double function doubles the input.