Closure (computer science)

Missing image Merge_articles.png

It has been proposed that this article or section be merged with function object. This request may be discussed on the article's talk page.

In programming languages, a closure is an abstraction representing a function, plus the lexical environment (see static scoping) in which the function was created.

Closures are typically implemented with a special data structure that contains a pointer to the function code, plus a representation of the function's lexical environment (i.e., the set of available variables and their values) at the time when the function was created.

Closures typically appear in languages that allow functions to be first-class values—in other words, such languages allow functions to be passed as arguments, returned from function calls, bound to variable names, etc., just like simpler types such as strings and integers.

For example, in ML, the following code defines a function f that returns its argument plus 1:

fun f(x) = x + 1;

Such a function may capture name/value bindings from its enclosing environment, producing a closure. For example, in the code fragment:

val x = 1;
fun f(y) = x + y;

the closure data structure representing f contains a pointer to the enclosing environment, in which x is bound to 1. Therefore, f will always return its argument plus 1, even if the environment in which it is applied has a different value for x. Therefore, consider the code fragment:

let
  val x = 1;
  fun f(y) = x + y;
in
  let
    val x = 2;
  in
    f(3)
  end
end

In this code, the call f(3) occurs in an environment (the inner let) where x is bound to 2. However, the closure for f was constructed in an environment (the outer let) where x is bound to 1. Therefore the result of the call f(3) is 4, not 5.

Closures have many uses:

• Designers of software libraries can allow users to customize behavior by passing closures as arguments to important functions. For example, a function that sorts values can accept a closure argument that compares the values to be sorted according to a user-defined criterion.
• Because closures delay evaluation—i.e., they do not "do" anything until they are called—they can be used to define control structures. For example, all Smalltalk's standard control structures, including branches (if/then/else) and loops (while and for), are defined using objects whose methods accept closures. Users can easily define their own control structures as well.
• Multiple functions can be produced which close over the same environment, enabling them to communicate privately by altering that environment.

Note: Some speakers call any data structure that binds a lexical environment a closure, but the term usually refers specifically to functions.

Scheme was the first programming language to have fully general, lexically scoped closures. Virtually all functional programming languages, as well as the Smalltalk-descended object-oriented programming languages, support some form of closures. Some prominent languages that support closures include:

• Haskell
• Lisp (including Scheme)
• JavaScript
• All variants of ML
• Python
• Perl
• Ruby
• Smalltalk
• Lua
• Boo
• Groovy

Some object-oriented languages enable the programmer to use objects to simulate some features of closures. For example:

• Java allows the programmer to define "anonymous classes" inside a method; an anonymous class may refer to names in lexically enclosing classes, or final names in the lexically enclosing method.
• In C++ and D, programmers may define classes that overload the () (function application) operator. Instances of such classes are called function objects, or occasionally functors (although the latter term is confusing, because it has a very different meaning in other programming languages). Such function objects behave somewhat like functions in a functional programming language, but they are different from closures in that variables from their environment are not captured. To approximate an actual closure, one can imagine placing all global variables in a single struct, a copy of which can be passed to a function object.
• Support for closures is introduced in version 2.0 of C#. In C#, they are called "anonymous methods".

See also

• funarg problem
• kleene closure

External links

• The Original "Lambda Papers" (http://library.readscheme.org/page1.html): A classic series of papers by Guy Steele and Gerald Sussman discussing, among other things, the versatility of closures in the context of Scheme (where they appear as lambda expressions).
• Description from the Portland Pattern Repository (http://c2.com/cgi/wiki?WhatIsClosure)
• What's a closure? (http://theoryx5.uwinnipeg.ca/CPAN/perl/pod/perlfaq7/What's_a_closure.html)
• Description from the VisualWorks wiki (http://wiki.cs.uiuc.edu/VisualWorks/Closures)
• Closures by the Spirit library of Boost (http://boost.org/libs/spirit/doc/closures.html)
• Description from the GObject Reference Manual (http://developer.gnome.org/doc/API/2.0/gobject/gobject-Closures.html)
• Uses of Interface jaxlib.closure.Function (http://www.jaxlib.org/docs/api/jaxlib/closure/class-use/Function.html)
• Javascript Closures (http://jibbering.com/faq/faq_notes/closures.html)
• Python closures (http://ivan.truemesh.com/archives/000392.html)
• PHP Closures (http://steike.com/PhpClosures)
• Syntactic Closures (A 1988 paper, by Alan Bawden and Jonathan Rees, that discusses a special use of closures in LISP syntax macros) (http://doi.acm.org/10.1145/62678.62687)
• Citations from CiteSeer (http://citeseer.ist.psu.edu/cis?q=function+closure)
• Implementation of Closures (Anonymous Methods) in C# 2.0 (http://pensieve.thinkingms.com/CommentView,guid,9fe42970-09e3-44e2-a4d0-32d63139351a.aspx)
• MF Bliki: Closures (http://www.martinfowler.com/bliki/Closures.html)

de:Closure