Closure (computer programming)

In computer science, a **closure** is a function that has an environment of its own. In this environment, there is at least one bound variable (a name that has a _value_, such as a number). The closure's environment keeps the bound variables in memory between uses of the closure.

Peter J. Landin gave this idea the name _closure_ in 1964. The Scheme programming language made closures popular after 1975. Many programming languages made after that time have closures.

Anonymous functions (functions with no name) are sometimes wrongly called closures. Most languages that have anonymous functions also have closures. An anonymous function is also a closure if it has an environment of its own with at least one bound variable. An anonymous function with no environment of its own is not a closure. A named closure is not anonymous.

## Closures and first-class functions

_Values_ may be numbers or some other type of data, such as letters, or data structures made up of simpler parts. In the rules of a programming language, the first-class values are values that can be given to functions, returned by functions, and bound to a variable name. Functions that take or return other functions are called higher-order functions. Most languages that have functions as first-class values also have higher-order functions and closures.

For example, take a look at the following Scheme function:

In this example, the lambda expression `(lambda (book) (>= (book-sales book) threshold))` is part of the function `best-selling-books`.  When the function is run, Scheme must make the value of the lambda. It does this by making a closure with the code for the lambda and a reference to the `threshold` variable, which is a free variable inside the lambda. (A _free variable_ is a name that is not bound to a value.)

The `filter` function then runs the closure on each book in the list to pick which books to return. Because the closure itself has a reference to `threshold`, the closure can use that value each time `filter` runs the closure. The function `filter` itself might be written in a completely separate file.

Here is the same example rewritten in ECMAScript (JavaScript), a popular language with support for closures:

ECMAScript uses the word `function` here instead of `lambda`, and the `Array.filter` method  in place of the `filter` function, but otherwise the code does the same thing in the same way.

A function may create a closure and return it.  The following example is a function that returns a function.

In Scheme:

In ECMAScript:

The closure environment keeps the bound variables `f` and `dx` after the _enclosing_ function (`derivative`) returns. In languages without closures, these values would be lost after the enclosing function returns. In languages with closures, a bound variable must be kept in memory as long as any closure has it.

A closure need not be formed using an anonymous function. The Python programming language, for example, has limited support for anonymous functions but does have closures. For example, one way the above ECMAScript example could be implemented in Python is:

In this example, the function named _gradient_ makes a closure together with the variables _f_ and _dx_. The outer enclosing function named _derivative_ returns this closure. In this case, an anonymous function would work also.Python must often use named functions instead because its lambda expressions may only contain other _expressions_ (code that returns a value) and not _statements_ (code that has effects but no value). But in other languages, such as Scheme, all code returns a value; in Scheme, everything is an expression.

## Uses of closures

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 (in languages that allow assignment).

In Scheme

- Closures can be used to implement object systems.

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