Scala | Closures

In Scala, a closure is a function whose return value depends on the value of one or more variables declared outside this function. Essentially, the function "closes over" an environment, encapsulating variables not passed in as parameters. This is a powerful feature found in many functional languages.

Let's look at closures in more detail using Scala:

Example 1: Basic Closure

Here's a simple example where we have a function inside another function, and the inner function refers to a variable from its outer function:

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

val closure = outerFunction(5)
println(closure())  // Outputs: 15

In the above code, innerFunction is a closure because it uses the variable x, which is defined outside of its scope.

Example 2: Closure with Mutable Data

This demonstrates how closures can capture mutable state:

def counter(): () => Int = {
  var count = 0
  def increment(): Int = {
    count += 1
    count
  }
  increment
}

val myCounter = counter()
println(myCounter())  // Outputs: 1
println(myCounter())  // Outputs: 2

In the above example, every time we call myCounter(), it increments the count variable. This is possible because the closure increment has captured (or closed over) the mutable variable count.

How do Closures Work?

When you create a closure, the function captures variables by reference, not by value. That's why, in the second example, we can update the count variable and see the changes the next time we invoke the closure.

Use Cases:

Higher Order Functions: Closures are frequently used in higher-order functions where a function takes another function as an argument or returns a function. Scala��s collection operations like map, filter, reduce, etc., all make use of closures.
Local State Encapsulation: As seen in the counter example, closures can encapsulate local state, giving a way to produce stateful functions.
Functional Constructs: Concepts like currying and partial application in functional programming often leverage closures.

In conclusion, closures in Scala allow functions to access and modify variables that are outside their definition, providing a mechanism to carry state in functional constructs.

Creating and Using Closures in Scala:
Closures are functions that capture variables from their lexical scope. In Scala, closures are created when a function literal references variables from its enclosing scope.
```
def createClosure(x: Int): Int => Int = {
  (y: Int) => x + y
}

val addFive = createClosure(5)
val result = addFive(3) // Result: 8
```
Lexical Scoping and Closures in Scala:
Lexical scoping in Scala means that the scope of a variable is determined by its location in the source code. Closures in Scala capture variables from their lexical scope.
```
def lexicalScoping(): Int => Int = {
  val x = 10
  (y: Int) => x + y
}

val addTen = lexicalScoping()
val result = addTen(5) // Result: 15
```

Capturing Variables in Scala Closures:

Closures capture variables by reference. Changes to captured variables outside the closure affect the closure and vice versa.

var globalVar = 20

def captureVariable(): Int => Int = {
  (y: Int) => globalVar + y
}

val addGlobal = captureVariable()
globalVar = 30
val result = addGlobal(5) // Result: 35

Immutable Closures in Functional Programming with Scala:
In functional programming, it's common to use immutable closures to avoid side effects. Immutable closures do not modify captured variables.
```
def immutableClosure(x: Int): Int => Int = {
  val captured = x * 2
  (y: Int) => captured + y
}

val addImmutable = immutableClosure(5)
val result = addImmutable(3) // Result: 13
```
Currying and Partial Application Using Closures in Scala:
Currying involves transforming a function with multiple arguments into a series of functions, each taking one argument. Closures enable currying and partial application.
```
def curryExample(x: Int)(y: Int): Int = x + y

val curriedClosure = curryExample(5) _
val result = curriedClosure(3) // Result: 8
```
Here, curryExample is a curried function, and the closure curriedClosure represents a partially applied version.