Search for a command to run...
Travel | Movies | History | Nature
I am a software developer. Started my career as a Java developer, but later switched to Scala. I wish to write Scala articles which are easier for newbies to follow. I love to travel, prefer to be alone or in very small group. Love to watch movies/series.
No comments yet. Be the first to comment.
Implementing Continuous Data Flows with FS2 Streaming
Building Resumable Data Pipelines with Redis-backed Offset Tracking and Batch Processing
Creating Flexible Data Integration Patterns for Cross-System Data Movement
How to leverage Scala 3 Mirrors to generically parse CSV files into case classes, making data handling more flexible and type-safe.
Introduction Recently, at work, there was a requirement to list out the direct dependencies of the our SBT project, something like Bill Of Materials. SBT itself provides the dependencies as list or tree or searchable HTML page using the built-in comm...
Closure is a function that is dependent on some variable outside its scope, and which is not part of the arguments list. In this article, let's look at some of the related concepts and how closure can be defined in Scala.
Bound variable is a variable that is defined and used as part of a function. The variable cease to exist when the function/method execution is completed. Let's look at it with an example:
def sum(v1:Int, v2:Int): Int = v1 + v2
In the code above, both the variables v1 and v2 are part of the method parameters and are used within the function sum. Outside the method sum, the variables v1 and v2 has no meaning/existence. In Scala, these variables will be allocated in the stack memory of the JVM.
In contrast, Free Variable is a variable which is defined outside the scope of the function where it is used. For example:
def multiply(num: Int): Int = num * factor
In the above code, the variable num is a bound variable in the method multiply. However, the variable factor is not part of the method signature, but still used within the method. That means, the variable factor is a free variable in the context of the method multiply.
Closure is defined as:
A function object that captures free variables, and is said to be "closed" over the variables visible at the time it is created.
Let's look at in detail with the previous example:
def multiply(num: Int): Int = num * factor
In Scala, if we try to compile the above code sample, it will will compiler error. We need to define the value for the variable factor. That process of defining the function by providing the value for the free variable is called as closing and such function is called as closure.
In Scala, the closures are very widely used in the core language semantics. Let's try to understand it with an example:
val list1 = List(1, 2, 3)
val list2 = List(10, 20)
list1.foreach { num1 =>
list2.foreach { num2 =>
println(s"$num1 * $num2 = " + num1 * num2)
}
}
Look at the line which prints the multiplied value. That can actually be represented using closure as:
list2.foreach { num2 =>
printMultiply(num2)
def printMultiply(num2: Int) = {
println(s"$num1 * $num2 = " + num1 * num2)
}
}
Now, the method printMultiply is a closure with the free variable num1 and it has the bound variable num2.
Generally, the local variables are allocated in the Stack memory of the JVM. That means, when the execution of the method is completed, the stack is cleared. However, sometimes the free variables outlives the method where it is used. Scala is intelligent enough to understand this and hence the free variable is allocated within the heap space rather than the stack.
def multiplier(factor: Int) = (num:Int) => (num * factor)
Here, multiplier is a closure with free variable as factor. Now, let's close this function:
val tripler: Int => Int = multiplier(3)
tripler is a function which multiplies any given value by 3. The multiplier closure is closed with the value 3 for factor. That means, the variable factor which is part of the method signature is normally available in stack and will be cleared after the method is returned. However, when we invoke tripler() it still needs to get the value for the factor. Scala compiler will identify this and make sure to allocate that variable in heap space so that it is accessible when tripler() is invoked later.
In this short article, we looked at closure and related terminologies.