In programming languages, a closure is an abstraction representing a function, plus the lexical environment (see static scoping) in which the function was created, and its application to arguments. A closure results in a fully closed term: one with no free variables left.

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. However, note that the function f is not closed, because it has a free term in the argument; so f(3) is a fully closed term.

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
• Perl
• Python
• Ruby
• Smalltalk

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.

See also

• funarg problem
• kleene closure

External links

• Description from the Portland Pattern Repository
• What's a closure?
• Description from the VisualWorks wiki
• Closures by the Spirit library of Boost
• Description from the GObject Reference Manual
• Uses of Interface jaxlib.closure.Function
• Javascript Closures
• PHP Closures
• Transitive closure for XPath
• Citations from CiteSeer
• Article "Closure, Function, Emergence, Semiosis and Life: The Same Idea? - Reflections on the Concrete and the Abstract in Theoretical Biology" by Claus Emmeche