Scala | Nested Functions

In Scala, you can define functions inside other functions. These inner functions are called "nested functions". They allow you to keep some logic localized and can help in creating more modular and readable code.

Benefits:

Encapsulation: Nested functions can access variables from their enclosing function, allowing you to encapsulate certain logic without exposing it to the outer scope.
Readability: They can be used to break down complex functions into smaller, more manageable pieces, making the code more readable.

Example:

Let's say you want to define a function to calculate the factorial of a number. A simple iterative approach using nested functions might look like this:

def factorial(n: Int): Int = {
  
  def loop(acc: Int, n: Int): Int = {
    if (n <= 0) acc
    else loop(acc * n, n - 1)
  }
  
  loop(1, n)
}

println(factorial(5))  // Outputs: 120

Here, the inner function loop is tail-recursive and does the actual computation, and the outer function factorial sets up the initial state for the loop.

Accessing Outer Function's Variables:

Nested functions can access the variables of their enclosing function:

def printMultiples(factor: Int): Unit = {
  def printValue(i: Int): Unit = {
    println(i * factor)
  }

  for (i <- 1 to 5) {
    printValue(i)
  }
}

printMultiples(2)

In the example above, the nested function printValue has access to the factor variable from the enclosing printMultiples function.

Conclusion:

Nested functions in Scala provide a powerful tool for modularizing and organizing your code. They can lead to cleaner, more readable code by allowing you to keep related logic closely tied together.

Scala Nested Functions Example:

Nested functions are functions defined inside another function.

def outerFunction(): Unit = {
  def innerFunction(): Unit = {
    println("Inside nested function")
  }

  innerFunction()
}

outerFunction()

Defining and Calling Nested Functions in Scala:

Define and call a nested function within another function.

def outerFunction(): Unit = {
  def innerFunction(): Unit = {
    println("Inside nested function")
  }

  innerFunction()
}

outerFunction()

Scope of Nested Functions in Scala:

Nested functions have access to variables in their enclosing scope.

def outerFunction(): Unit = {
  val outerVariable = "Outer"

  def innerFunction(): Unit = {
    println(s"Accessing $outerVariable inside nested function")
  }

  innerFunction()
}

outerFunction()

Accessing Outer Variables in Nested Functions:

Nested functions can access variables from their outer scope.

def outerFunction(): Unit = {
  val outerVariable = "Outer"

  def innerFunction(): Unit = {
    println(s"Accessing $outerVariable inside nested function")
  }

  innerFunction()
}

outerFunction()

Closure in Scala Nested Functions:

A closure is formed when a nested function refers to variables in its enclosing scope.

def outerFunction(x: Int): Int => Int = {
  def innerFunction(y: Int): Int = {
    x + y
  }

  innerFunction
}

val closure = outerFunction(5)
val result = closure(3) // Result: 8

Recursion with Nested Functions in Scala:

Recursive functions can be nested for modularity.

def factorial(n: Int): Int = {
  def factorialHelper(acc: Int, num: Int): Int = {
    if (num <= 0) acc
    else factorialHelper(acc * num, num - 1)
  }

  factorialHelper(1, n)
}

val result = factorial(5) // Result: 120

Modularity with Nested Functions in Scala:

Nested functions enhance code modularity by grouping related functionality.

def mathOperations(x: Int, y: Int): Int = {
  def square(a: Int): Int = a * a
  def cube(b: Int): Int = b * b * b

  square(x) + cube(y)
}

val result = mathOperations(2, 3) // Result: 17