Today, we will talk\u00a0about Scala closures. We will learn about the problem that Scala Closures solve, Examples of Closures in Scala, see what is behind the magic and working of Scala Datatypes.<\/p>\n
So, let’s start Scala Closures tutorial.<\/p>\n
What do you do when you want to pass a function around as a variable? How do you let it refer to one or more fields in the same scope? This piece is to address this issue.<\/p>\n
A function whose return value depends on variable(s) declared outside it, is a closure. This is much like that in Python.<\/p>\n
We\u2019ve seen how to declare an anonymous function in Scala:<\/p>\n
scala> val sum=(a:Int,b:Float)=>a+b\r\nsum: (Int, Float) => Float = $$Lambda$1101\/539731466@12ebcdf6<\/pre>\nLet\u2019s make a call to it:<\/p>\n
scala> sum(2,3)\r\nres2: Float = 5.0<\/pre>\nThis added the numbers 2 and 3, and returned 5.<\/p>\n
Now, consider this version:<\/p>\n
scala> var c=7\r\nc: Int = 7\r\nscala> val sum1=(a:Int,b:Int)=>(a+b)*c\r\nsum1: (Int, Int) => Int = $$Lambda$1103\/1497170291@4a0a93ce<\/pre>\nHere, the function \u2018sum1\u2019 refers to the variable\/value \u2018c\u2019, which isn\u2019t a formal parameter to it.<\/p>\n
Let\u2019s try calling the function.<\/p>\n
scala> sum1(2,3)\r\nres3: Int = 35<\/pre>\nSo, while \u2018sum\u2019 is trivially closed over itself, \u2018sum1\u2019 refers to \u2018c\u2019 every time we call it, and reads its current value. Let\u2019s try changing the value of c:<\/p>\n
scala> c=8\r\nc: Int = 8<\/pre>\nWe changed \u2018c\u2019 from 7 to 8. Let\u2019s try calling sum1 again:<\/p>\n
scala> sum1(2,3)\r\nres5: Int = 40<\/pre>\nAs you can see, it reads the current value of c.<\/p>\n
Behind the Magic<\/h3>\n
Coming from a Java or C++ background, this must be nonplussing. Not only did it use the correct value of \u2018c\u2019 the first time, but it also picked up the change in it when we called it a second time.<\/p>\n
Let\u2019s find out how Scala Closures works.<\/p>\n
In our example, \u2018a\u2019 and \u2018b\u2019 are formal parameters to the function sum1. \u2018c\u2019, however, is a reference to a variable in the enclosing scope. Scala closes over \u2018c\u2019 here.
\nPaul Cantrell, in his article on Closures in Ruby, mentions three criteria for a closure:<\/p>\n\n
- We can pass around the code block as a value<\/li>\n
- At any time, anyone with the value can execute the code block<\/li>\n
- It can refer to variables from the context we created it in<\/li>\n<\/ol>\n
It is like two lovers separated in distance, yet united by the heart. Not only do they remember each other; they can sense what happens to the other.<\/p>\n
Example of Scala Closures<\/h3>\n
Let\u2019s work up another Scala\u00a0Closures example.<\/p>\n
scala> var age=22\r\nage: Int = 22\r\nscala> val sayhello=(name:String)=>println(s\"I am $name and I am $age\")\r\nsayhello: String => Unit = $$Lambda$1065\/467925240@78b9155e\r\nscala> sayhello(\"Ayushi\")<\/pre>\nI am Ayushi and I am 22
\nNow, let\u2019s take another function func that takes two arguments: a function and a string, and calls that function on that string. Did we mention that Scala supports higher-order functions?<\/p>\nscala> def func(f:String=>Unit,s:String){\r\n | f(s)\r\n | }\r\nfunc: (f: String => Unit, s: String)Unit\r\nscala> func(sayhello,\"Ayushi\")<\/pre>\nI am Ayushi and I am 22
\nWith this example, we hope it gets clearer to you.<\/p>\nWorking with Other Data Types<\/h3>\n
Just to be clearer, let\u2019s try this on a data type different that an Integer.<\/p>\n
a. Integer Arrays<\/h4>\n
First, we\u2019ll do this on an Integer array. Let\u2019s declare an array with three numbers:<\/p>\n
scala> val nums=Array(1,2,4)\r\nnums: Array[Int] = Array(1, 2, 4)\r\n<\/pre>\nNext, we define a function to work with this:<\/p>\n
scala> val saynum=(a:Int)=>println(s\"The number is $a\")\r\nsaynum: Int => Unit = $$Lambda$1194\/2122460177@5b810b54\r\n<\/pre>\nNow, let\u2019s define a function func:<\/p>\n
scala> for(i<-0 to 2){\r\n | saynum(nums(i))\r\n | }<\/pre>\nThe number is 1
\nThe number is 2
\nThe number is 4<\/p>\nb. ArrayBuffer<\/h4>\n
Now let\u2019s try this with an ArrayBuffer. First, we\u2019ll need to import ArrayBuffer.<\/p>\n
scala> import scala.collection.mutable.ArrayBuffer\r\nimport scala.collection.mutable.ArrayBuffer\r\n<\/pre>\nNow, we declare an ArrayBuffer with three strings:<\/p>\n
scala> val colors=ArrayBuffer(\"Red\",\"Green\",\"Blue\")\r\ncolors: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer(Red, Green, Blue)\r\n<\/pre>\nFinally, the function func to call sayhello on colors:<\/p>\n
scala> val func=(f:String=>Unit,s:String)=>f(s)\r\nfunc: (String => Unit, String) => Unit = $$Lambda$1270\/151863667@5d16f27b<\/pre>\nNow, let\u2019s use a for-loop to call this on each value in the ArrayBuffer.<\/p>\n
scala> for(i<-0 to 2){\r\n | func(sayhello,colors(i))\r\n | }<\/pre>\nI am Red and I am 22
\nI am Green and I am 22
\nI am Blue and I am 22<\/p>\nThis was all on Scala Closures. Hope you like the article on closures in Scala.<\/p>\n
Conclusion<\/h3>\n
Hence, we studied What is Scala\u00a0Closures with its examples and data types. Is this information helpful to you? Let us know in the comments.<\/p>\n