What is Closure in Scala

Closure in Scala

A closure in Scala is a function whose return value always depends on one or more variables declared outside the function. The variables outside of the function that the function depends on are defined. 

Closure in Scala evaluates based on the most recent free variable value. It may be a pure or impure function or called an anonymous function. 

Syntax of Closure in Scala is:-

// This is any freely defined variable
Var x = 15

// Set of parameters for Function
Def name_of_function(y: Int)	
{
    // Statements to be executed 
    // Value that depends on a free variable
    Println(x + y)
}

Example of closure in scala is:-

object sample
{
    // Main method
    def main(args: Array[String])
    {
        println(sum())
        println(sum())
        println(sum())
    }
          
    var num = 5
      
    // Defining closure function
    val sum = () => num
}

Output:

Closure Functioning in Scala

A closure function reference to a function's non-local variables gives the user access to all variables outside the function's immediate lexical scope. As a result, the function uses the variable earlier in the code referenced to return the result.

Recommended Topic, Cognizant Eligibility Criteria

Advantages of Closure Functions

Data encapsulation and data persistence are two key advantages of closure functions. Since variables have scopes and will have local scopes if they are defined inside functions, we can use closure functions to define global variables that can be used inside functions. As a result, we can have those variables even after the function task is complete.

Closures are advantageous because they enable you to link a function that operates on data (the lexical environment) with the data itself.

Example of Closure in Scala

We will see various examples to understand the functioning of Closure in Scala.

Passing string as Closure in Scala

In this example, we will pass a string as closure in scala.

// Creating an object
object coding
{
    // Main method
    def main(args: Array[String])
    {
        // Defining closure function
        val code = (name: String) => println(s"My name is $name")
          
        code("Ram")
    }
}

Output:

Passing function as Closure in Scala

In this example, we will pass a function as closure in scala.  

// Creating object
object coding
{
    def func(f:String=>Unit,s:String)
    {
    	f(s)
    }
    
	// Main method
	def main(args: Array[String])
    {
    	// Defining closure function
    	val code = (name: String) => println(s"My name is $name")    
    	
    	func(code,"Shayam")
    }
}

Output:

Passing Array of Integer as closure

In this example, we will pass an array of integers as closure in scala.

// Creating object
object coding
{
    
    def main(args: Array[String])
    {
    	var  ans = Array(10,20,30)
    	val prin =(b:Int) =>println("Value of Array using clousre is "+b)
    	
    	// Defining closure function
    	for(j<- 0 to ans.length)
    	{
    		prin(ans(j))
    	}
    }
}

Output:

You can also read about mock interview.

Frequently Asked Questions

Why is Scala considered as an object-oriented language?

Programming in Scala combines object-oriented and functional techniques, making it a language similar to Java. In the strictest sense, it is an object-oriented language since each value is an object. Classes describe the types and behaviours of objects. 

Who uses Scala?

Data engineers and software developers are the primary users of Scala. To process large amounts of data, some data scientists will pair it with Apache Spark.

What are some similarities between Java and Scala?

The object-oriented nature of both languages enables programmers to simulate the real world, and both languages use JVM.

Name the frameworks that Scala supports.

Frameworks like the Neo4j Framework, Spark Framework, Play Framework, Akka Framework, etc., are just a few of the frameworks that Scala supports.

What function do tuples serve in Scala?

Scala tuples combine a specific number of elements to allow for passing around as a whole. A tuple is immutable and can contain objects of various types, unlike an array or list.

Conclusion 

Congratulations on finishing the blog! We have discussed Closure in Scala. We further discussed the free variables, closure functioning, advantages, and examples of Closure in Scala.

We hope this blog has helped you enhance your knowledge of Closure in Scala. Do not stop learning! We recommend you read some of our Scala articles: 

1. Scala Programming Language

2. What is Scala?

3. Scala Interview Questions
 

Refer to our Guided Path to upskill yourself in DSA, Competitive Programming, JavaScript, System Design, and many more! If you want to test your competency in coding, you may check out the mock test series and participate in the contests hosted on Coding Ninjas Studio/

But suppose you have just started your learning process and are looking for questions from tech giants like Amazon, Microsoft, Uber, etc. For placement preparations, you must look at the problems, interview experiences, and interview bundles.

We wish you Good Luck! 

Happy Learning!