Why are closures so cool? Well imagine this example based on a presentation on closures in the Java language An update on Java Closures
List parseItems(String line ) {
List list; return Item.map( line, { Item s => list.put( s.uid ) });
}Do you see what is happening here? First the purpose of this code is to take a string and parse it into a list of items. Next notice we are passing �line� into a function called map() along with what appears to be an anonymous function. But wait, inside the anonymous function there is a reference to list!. This lexical scoping allows us to access variables defined in the scope of the calling method (parseItems()) and use them inside this anonymous function, Which is actually called a Lexical Closure Now you might be saying, why we can’t just do this as a loop? Well, we can’t like so.
List parseItems(String line) {
List items;
List list;
// Get a list of the items from the map items = ListItem.map( line );
// Now iterate over the list and get the user id
Iterator myVeryOwnIterator = items.entrySet().iterator();
while(myVeryOwnIterator.hasNext()) {
List e = myVeryOwnIterator.next();
List.put( e.uid );
} }Despite the obvious, This takes more code there is a lot of boiler plate code
to the second example. I mean, you have to call the map() function to get a
list, then iterate over the list to get at what you actually want. Which is
item.number But what if you want item.name or item.something? What
typical programmers then do is copy the boiler plate code in parseItems() and
create a new function called parseItemsName() which returns a list of names
instead of user id’s using almost the exact code but changing only a few lines
to get the desired result. Code duplication! (Unnecessarily I might add) But
by using closures we eliminate the need to use boiler plate code and just use
to the map() function in it’s simplest form. If we want e.name instead of e.uid
we do this. Item.map( line, { Item s => list.put( s.name ) }); But wait! Our
requirements change. Again! Now we have to get only the user id and names of
items that are of a certain age or older. So now with lexical closures we can
do this.
Item.map( line, {
If( s.age > 20 ) {
list.put( s.name );
}
});In our boiler plate example we would have to change each function that utilized the boiler plate and modify, possibly copying even more boiler plate code into another method that limits by age. Bottom line. More copy and paste. But you say, that lexical closure code is ugly! (And I would agree). Anything beyond 1 line lexical closures do tend to look ugly, but what if we add a little syntactic sugar. The following is just such sugar from the Java lexical closure proposal
Item.map(line : s ) {
If ( s.age > 20 ) {
list.put.( s.name );
}}