Blog Xebia France

A little of code often better than a long speech, here is an example very easy in use of closures in Ruby (Ruby makes an intensive usage of closures, what is probably at the origin of affection that carries it his users). This example is drawn of the article of Martin Fowler at subject [there].

Let us imagine that you want to extract from a list of employees a sub-list understanding only those who are frames. A possible realisation in popular dance is the following:

In Ruby, the same function would be suchlike encoded:

Method select Ruby's Collection is defined in the class. She takes in parametre a block of code - the closure famous - defined between braces. If the block of code takes arguments, these last are declared between two vertical bars (these are the "free" variables, with which range is defined by context). Method select encapsule the algorithmic: iteration on the collection, execution of the block of code for every element and building of a sub-list containing elements for which the block of code assesses at true.

There is of course in Popular dance a rather similar mechanism, allowed by the usage of anonymous overlapped classes (Anonymous Inner Class, or AIC).
Let us assume that the class List have a method, symmetrically in its counterpart Ruby, select, taking in parametre an interface defined as follows:

Then code popular dance could be spelt as follows:

AIC is the traditional mishap of closures in popular dance. IPA - INTERNATIONAL PHONETIC ALPHABET of JDK widely use it (think of interfaces Runnable, Comparable, Callable or TimerTask, who give closures in classes Thread or Executor, or else allow to configurer collections). Design Patterns callbacks, factories, predicates or stategies are of natural candidates for this type of building. Spring, especially in his framework of templates, exploits them in very good escient to conceal the tiring character of some IPA - INTERNATIONAL PHONETIC ALPHABET, JDBC especially.

Therefore, the programming by closures, very spread to rubyistes, is practically nonexistent at the programmers' popular dance. The listing above gives a first explanation: the syntax of AIC, verbose incredibly, is liable to discourage the best intentions. Then, the support of AIC in Popular dance as mechanism of closures suffers from strict limitations: once instanci e, AIC is a full object, endowed with a range which is peculiar to it, and partly blind in the context which created it. Consequently, variables or methods are solved in range of this new object.

Let us examine, to illustrate these some Ruby's lines:

This code allows to show the factorial of 100. Variable i is defined outside the closure and changed in its body. Code equivalent popular dance would not compile (supposing that one similar IPA - INTERNATIONAL PHONETIC ALPHABET is available). Indeed, so that an external variable is achieved in the body of AIC, she must be declared final (the underlying reason is that variable is copied in the context of AIC). She cannot therefore be changed. It does not put down difficulty if variable is of a variable type (as a list or a wrapper), but can turn out to be problematic if it is about an immutable type or about one worth portrays (especially G-string and primary types).

Here is a quintessence of the necessary contortions in popular dance to by-pass this pressure:

It is on this primordial official report that proposal CICE came into the world. Its object is not to corrupt language popular dance but to return more concise the syntax of creation of AIC (in fact, a subset of these last, called single-abstract-method-types or SAM, which are substantially interfaces including only an only method).

With the syntax offered by CICE, our initial example would be suchlike rewritten:

This concise said syntax is supplemented by an impairment of the rules of access to the local variables of the calling block (especially, those declared expressly public can be allocated in the body of AIC).

This approach has of course the merit of simplicity since ellle introduces no new concept and does not require the existent rewriting of the IPA - INTERNATIONAL PHONETIC ALPHABET; she could moreover be implemented probably with the aid of a modification minor of the compiler.

For some, however, approach CICE is only touching subject lightly and offers only a minimalist provision of closures in Popular dance.

Indeed, generally, AIC breaks the context of execution of calling code and does not allow to keep the semantics of a significant number of syntactic structures (those that Neal Gafter calls " lexically scoped language constructs "):

• names of variables
• names of methods
• names of types
• signification of this
• names of quality-labels
• referent of an education break without quality-label
• referent of an education continue without quality-label
• checked exceptions declared or intercepted
• referent of an education return
• and some others more exotic (state of allocation of variables, reachability, )

Proposal BGGA is an extension of language popular dance allowing the implementation of closures without break of transparency. The syntax offered by BGGA is far from being coarse, what is worth it many criticisms his denigrators are incidentally often the supporters of CICE.

Without entering the detail (who can be consulted on the site http://www.javac.info/), following characteristics will be kept:

• BGGA defines a syntax allowing to declare literal resembling closures in this:
  {int x, int y> x+y}

• BGGA also defines the concept of function portray, in whom a function has a list of arguments, a type back and a clause throws; it is possible to instancier a function portray with the aid of a compatible literal closure
• transparency lexical is completely guaranteed, both for the association of variables and for the resolution of names or structures of control (break, continue, return) some people closures can however be marked restricted and act in an identical way in AIC
• BGGA offers a simplified grammar allowing to exploit closures according to a syntax very close to that of structures of control native of language with such syntax, the modification of language to introduce the second form of curl for would have been superfluous

With BGGA, following algorithm

would become

in canonical form and, in simplified form:

Our initial example could be suchlike encoded (if the IPA - INTERNATIONAL PHONETIC ALPHABET of Collection popular dance acquires a method select appropriate):

As recalled higher, the medal has a back. If side client the use of closures BGGA seems relatively simple, the syntax risks of considerably complexifier IPA - INTERNATIONAL PHONETIC ALPHABET of JDK or of frameworks eager to take advantage of it. To give an idea, here is the code of the withLock function used higher:

Following the example of the generic, who returned almost unreadable in the common the source code of some classes of JDK, such syntactic evolution risks raising an additional barrier to the training of language popular dance, and digging the ditch even more between the user of IPA - INTERNATIONAL PHONETIC ALPHABET (Joe Java, as say certain) and the concepteur of IPA - INTERNATIONAL PHONETIC ALPHABET. Is the game worth the candle?

References (all in English):
[1] The proposal BGGA, introduced by Neal Gafter to GOOGLE TechTalks
[2]
[3] A very interesting exchange on the site of Crazy Bob, supporter of CICE
[4] Two articles appeared on developerWorks, first on closures in general, and second more specifically on debate BGGA vs CICE.
[5] A more ancient article, on the traditional approach of closures in popular dance Key words :closure, development, Popular dance