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:
 (filter 
 (lambda (book) (&gt;= (book-sales book) threshold))
 book-list))
In this example, the lambda expression codice_1 is part of the function codice_2. 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 codice_3 variable, which is a free variable inside the lambda. (A "free variable" is a name that is not bound to a value.)
The codice_4 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 codice_3, the closure can use that value each time codice_4 runs the closure. The function codice_4 itself might be written in a completely separate file.
Here is the same example rewritten in (JavaScript), another popular language with support for closures:
// Return a list of all books with at least 'threshold' copies sold.
function bestSellingBooks(threshold) {
 return bookList.filter(
ECMAScript uses the word codice_8 here instead of codice_9, and the codice_10 method in place of the codice_4 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:
 (lambda (x) (/ (- (f (+ x dx)) (f x)) dx)))
In ECMAScript:
// Return a function that approximates the derivative of f
// using an interval of dx, which should be appropriately small.
function derivative(f, dx) {
 return function(x) {
 return (f(x + dx) - f(x)) / dx;
} 
The closure environment keeps the bound variables codice_12 and codice_13 after the "enclosing" function (codice_14) 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:
def derivative(f, dx):
 def gradient(x):
 return (f(x + dx) - f(x)) / dx
 return gradient
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.
def derivative(f, dx):
 return lambda x: (f(x + dx) - f(x)) / dx
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:
In Scheme
 (set! foo (lambda (msg) (set! secret-message msg)))
 (set! bar (lambda () secret-message)))
(display (bar)) ; prints "none"
(display (bar)) ; prints "meet me by the docks at midnight"
Note: Some speakers call any data structure that binds a lexical environment a closure, but the term usually refers specifically to functions.