History and etymology
The concept of closures was developed in the 1960s for the mechanical evaluation of expressions in the λ-calculus and was first fully implemented in 1970 as a language feature in the PAL programming language to support lexically scopedAnonymous functions
The term ''closure'' is often used as a synonym fora
and b
are closures, in both cases produced by returning a nested function with a free variable from the enclosing function, so that the free variable binds to the value of parameter x
of the enclosing function. The closures in a
and b
are functionally identical. The only difference in implementation is that in the first case we used a nested function with a name, g
, while in the second case we used an anonymous nested function (using the Python keyword lambda
for creating an anonymous function). The original name, if any, used in defining them is irrelevant.
A closure is a value like any other value. It does not need to be assigned to a variable and can instead be used directly, as shown in the last two lines of the example. This usage may be deemed an "anonymous closure".
The nested function definitions are not themselves closures: they have a free variable which is not yet bound. Only once the enclosing function is evaluated with a value for the parameter is the free variable of the nested function bound, creating a closure, which is then returned from the enclosing function.
Lastly, a closure is only distinct from a function with free variables when outside of the scope of the non-local variables, otherwise the defining environment and the execution environment coincide and there is nothing to distinguish these (static and dynamic binding cannot be distinguished because the names resolve to the same values). For example, in the below program, functions with a free variable x
(bound to the non-local variable x
with global scope) are executed in the same environment where x
is defined, so it is immaterial whether these are actually closures:
f
can be seen to be a closure because x
in the body of f
is bound to the x
in the global namespace, not the x
local to g
:
Applications
The use of closures is associated with languages where functions areFirst-class functions
Closures typically appear in languages with(lambda (book) (>= (book-sales book) threshold))
appears within the function best-selling-books
. When the lambda expression is evaluated, Scheme creates a closure consisting of the code for the lambda expression and a reference to the threshold
variable, which is a filter
function, which calls it repeatedly to determine which books are to be added to the result list and which are to be discarded. Because the closure itself has a reference to threshold
, it can use that variable each time filter
calls it. The function filter
itself might be defined in a completely separate file.
Here is the same example rewritten in function
keyword is used here instead of lambda
, and an Array.filter
method instead of a global filter
function, but otherwise the structure and the effect of the code are the same.
A function may create a closure and return it, as in the following example:
f
and dx
live on after the function derivative
returns, even though execution has left their scope and they are no longer visible. In languages without closures, the lifetime of an automatic local variable coincides with the execution of the stack frame where that variable is declared. In languages with closures, variables must continue to exist as long as any existing closures have references to them. This is most commonly implemented using some form of State representation
A closure can be used to associate a function with a set of "Other uses
Closures have many uses: * 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 ofImplementation and theory
Closures are typically implemented with a specialDifferences in semantics
Lexical environment
As different languages do not always have a common definition of the lexical environment, their definitions of closure may vary also. The commonly held minimalist definition of the lexical environment defines it as a set of all bindings of variables in the scope, and that is also what closures in any language have to capture. However the meaning of a variable binding also differs. In imperative languages, variables bind to relative locations in memory that can store values. Although the relative location of a binding does not change at runtime, the value in the bound location can. In such languages, since closure captures the binding, any operation on the variable, whether done from the closure or not, are performed on the same relative memory location. This is often called capturing the variable "by reference". Here is an example illustrating the concept infoo
and the closures referred to by variables f
and g
all use the same relative memory location signified by local variable x
.
In some instances the above behaviour may be undesirable, and it is necessary to bind a different lexical closure. Again in ECMAScript, this would be done using the Function.bind()
.
Example 1: Reference to an unbound variable
Example 2: Accidental reference to a bound variable
For this example the expected behaviour would be that each link should emit its id when clicked; but because the variable 'e' is bound the scope above, and lazy evaluated on click, what actually happens is that each on click event emits the id of the last element in 'elements' bound at the end of the for loop.e
would need to be bound by the scope of the block using handle.bind(this)
or the let
keyword.
On the other hand, many functional languages, such as ML, bind variables directly to values. In this case, since there is no way to change the value of the variable once it is bound, there is no need to share the state between closures—they just use the same values. This is often called capturing the variable "by value". Java's local and anonymous classes also fall into this category—they require captured local variables to be final
, which also means there is no need to share state.
Some languages enable you to choose between capturing the value of a variable or its location. For example, in C++11, captured variables are either declared with /code>, which means captured by reference, or with /code>, which means captured by value.
Yet another subset, lazy functional languages such as Haskell, bind variables to results of future computations rather than values. Consider this example in Haskell:
-- Haskell
foo :: Fractional a => a -> a -> (a -> a)
foo x y = (\z -> z + r)
where r = x / y
f :: Fractional a => a -> a
f = foo 1 0
main = print (f 123)
The binding of r
captured by the closure defined within function foo
is to the computation (x / y)
—which in this case results in division by zero. However, since it is the computation that is captured, and not the value, the error only manifests itself when the closure is invoked, and actually attempts to use the captured binding.
Closure leaving
Yet more differences manifest themselves in the behavior of other lexically scoped constructs, such as return
, break
and continue
statements. Such constructs can, in general, be considered in terms of invoking an escape continuation established by an enclosing control statement (in case of break
and continue
, such interpretation requires looping constructs to be considered in terms of recursive function calls). In some languages, such as ECMAScript, return
refers to the continuation established by the closure lexically innermost with respect to the statement—thus, a return
within a closure transfers control to the code that called it. However, in Smalltalk
Smalltalk is an object-oriented, dynamically typed reflective programming language. It was designed and created in part for educational use, specifically for constructionist learning, at the Learning Research Group (LRG) of Xerox PARC by Alan ...
, the superficially similar operator ^
invokes the escape continuation established for the method invocation, ignoring the escape continuations of any intervening nested closures. The escape continuation of a particular closure can only be invoked in Smalltalk implicitly by reaching the end of the closure's code. The following examples in ECMAScript and Smalltalk highlight the difference:
"Smalltalk"
foo
, xs ,
xs := #(1 2 3 4).
xs do: ^x
^0
bar
Transcript show: (self foo printString) "prints 1"
// ECMAScript
function foo()
alert(foo()); // prints 0
The above code snippets will behave differently because the Smalltalk ^
operator and the JavaScript return
operator are not analogous. In the ECMAScript example, return x
will leave the inner closure to begin a new iteration of the forEach
loop, whereas in the Smalltalk example, ^x
will abort the loop and return from the method foo
.
Common Lisp
Common Lisp (CL) is a dialect of the Lisp programming language, published in ANSI standard document ''ANSI INCITS 226-1994 (S20018)'' (formerly ''X3.226-1994 (R1999)''). The Common Lisp HyperSpec, a hyperlinked HTML version, has been derived fr ...
provides a construct that can express either of the above actions: Lisp (return-from foo x)
behaves as Smalltalk
Smalltalk is an object-oriented, dynamically typed reflective programming language. It was designed and created in part for educational use, specifically for constructionist learning, at the Learning Research Group (LRG) of Xerox PARC by Alan ...
^x
, while Lisp (return-from nil x)
behaves as JavaScript
JavaScript (), often abbreviated as JS, is a programming language that is one of the core technologies of the World Wide Web, alongside HTML and CSS. As of 2022, 98% of websites use JavaScript on the client side for webpage behavior, of ...
return x
. Hence, Smalltalk makes it possible for a captured escape continuation to outlive the extent in which it can be successfully invoked. Consider:
"Smalltalk"
foo
^ ^x bar
, f ,
f := self foo.
f value: 123 "error!"
When the closure returned by the method foo
is invoked, it attempts to return a value from the invocation of foo
that created the closure. Since that call has already returned and the Smalltalk method invocation model does not follow the spaghetti stack discipline to facilitate multiple returns, this operation results in an error.
Some languages, such as Ruby
A ruby is a pinkish red to blood-red colored gemstone, a variety of the mineral corundum ( aluminium oxide). Ruby is one of the most popular traditional jewelry gems and is very durable. Other varieties of gem-quality corundum are called ...
, enable the programmer to choose the way return
is captured. An example in Ruby:
# Ruby
# Closure using a Proc
def foo
f = Proc.new
f.call # control leaves foo here
return "return from foo"
end
# Closure using a lambda
def bar
f = lambda
f.call # control does not leave bar here
return "return from bar"
end
puts foo # prints "return from foo from inside proc"
puts bar # prints "return from bar"
Both Proc.new
and lambda
in this example are ways to create a closure, but semantics of the closures thus created are different with respect to the return
statement.
In Scheme A scheme is a systematic plan for the implementation of a certain idea.
Scheme or schemer may refer to:
Arts and entertainment
* ''The Scheme'' (TV series), a BBC Scotland documentary series
* The Scheme (band), an English pop band
* ''The Schem ...
, definition and scope of the return
control statement is explicit (and only arbitrarily named 'return' for the sake of the example). The following is a direct translation of the Ruby sample.
; Scheme
(define call/cc call-with-current-continuation)
(define (foo)
(call/cc
(lambda (return)
(define (f) (return "return from foo from inside proc"))
(f) ; control leaves foo here
(return "return from foo"))))
(define (bar)
(call/cc
(lambda (return)
(define (f) (call/cc (lambda (return) (return "return from lambda"))))
(f) ; control does not leave bar here
(return "return from bar"))))
(display (foo)) ; prints "return from foo from inside proc"
(newline)
(display (bar)) ; prints "return from bar"
Closure-like constructs
Some languages have features which simulate the behavior of closures. In languages such as Java, C++, Objective-C, C#, VB.NET, and D, these features are the result of the language's object-oriented paradigm.
Callbacks (C)
Some C libraries support
callbacks. This is
sometimes implemented by providing two values when
registering the callback with the library: a function
pointer and a separate void*
pointer to
arbitrary data of the user's choice. When the library
executes the callback function, it passes along the data
pointer. This enables the callback to maintain state and
to refer to information captured at the time it was
registered with the library. The idiom is similar to
closures in functionality, but not in syntax. The
void*
pointer is not type safe
In computer science, type safety and type soundness are the extent to which a programming language discourages or prevents type errors. Type safety is sometimes alternatively considered to be a property of facilities of a computer language; that ...
so this C
idiom differs from type-safe closures in C#, Haskell or ML.
Callbacks are extensively used in GUI Widget toolkits to
implement Event-driven programming by associating general
functions of graphical widgets (menus, buttons, check boxes,
sliders, spinners, etc.) with application-specific functions
implementing the specific desired behavior for the application.
Nested function and function pointer (C)
With a gcc extension,
nested function
can be used and a function pointer can emulate closures, providing the function does not exit the containing scope.
The following example is invalid because adder
is a top-level definition (depending on compiler version, it could produce a correct result if compiled without optimization, i.e. at -O0
):
#include
typedef int (*fn_int_to_int)(int); // type of function int->int
fn_int_to_int adder(int number)
int main(void)
But moving adder
(and, optionally, the typedef
) in main
makes it valid:
#include
int main(void)
If executed this now prints 11
as expected.
Local classes and lambda functions (Java)
Java
Java (; id, Jawa, ; jv, ꦗꦮ; su, ) is one of the Greater Sunda Islands in Indonesia. It is bordered by the Indian Ocean to the south and the Java Sea to the north. With a population of 151.6 million people, Java is the world's mo ...
enables classes to be defined inside methods
Method ( grc, μέθοδος, methodos) literally means a pursuit of knowledge, investigation, mode of prosecuting such inquiry, or system. In recent centuries it more often means a prescribed process for completing a task. It may refer to:
*Scien ...
. These are called ''local classes''. When such classes are not named, they are known as '' anonymous classes'' (or anonymous ''inner'' classes). A local class (either named or anonymous) may refer to names in lexically enclosing classes, or read-only variables (marked as final
) in the lexically enclosing method.
class CalculationWindow extends JFrame
The capturing of final
variables enables you to capture variables by value. Even if the variable you want to capture is non-final
, you can always copy it to a temporary final
variable just before the class.
Capturing of variables by reference can be emulated by using a final
reference to a mutable container, for example, a single-element array. The local class will not be able to change the value of the container reference itself, but it will be able to change the contents of the container.
With the advent of Java 8's lambda expressions, the closure causes the above code to be executed as:
class CalculationWindow extends JFrame
Local classes are one of the types of inner class that are declared within the body of a method. Java also supports inner classes that are declared as ''non-static members'' of an enclosing class. They are normally referred to just as "inner classes". These are defined in the body of the enclosing class and have full access to instance variables of the enclosing class. Due to their binding to these instance variables, an inner class may only be instantiated with an explicit binding to an instance of the enclosing class using a special syntax.
public class EnclosingClass
Upon execution, this will print the integers from 0 to 9. Beware to not confuse this type of class with the nested class, which is declared in the same way with an accompanied usage of the "static" modifier; those have not the desired effect but are instead just classes with no special binding defined in an enclosing class.
As of Java 8
The Java language has undergone several changes since JDK 1.0 as well as numerous additions of classes and packages to the standard library. Since J2SE 1.4, the evolution of the Java language has been governed by the Java Community ...
, Java supports functions as first class objects. Lambda expressions of this form are considered of type Function
with T being the domain and U the image type. The expression can be called with its .apply(T t)
method, but not with a standard method call.
public static void main(String[] args)
Blocks (C, C++, Objective-C 2.0)
Apple Inc., Apple introduced Blocks (C language extension), blocks, a form of closure, as a nonstandard extension into C, C++, Objective-C 2.0
Objective-C is a general-purpose, object-oriented programming language that adds Smalltalk-style messaging to the C programming language. Originally developed by Brad Cox and Tom Love in the early 1980s, it was selected by NeXT for its NeX ...
and in Mac OS X 10.6 "Snow Leopard" and iOS 4.0. Apple made their implementation available for the GCC and clang compilers.
Pointers to block and block literals are marked with ^
. Normal local variables are captured by value when the block is created, and are read-only inside the block. Variables to be captured by reference are marked with __block
. Blocks that need to persist outside of the scope they are created in may need to be copied.
typedef int (^IntBlock)();
IntBlock downCounter(int start)
IntBlock f = downCounter(5);
NSLog(@"%d", f());
NSLog(@"%d", f());
NSLog(@"%d", f());
Delegates (C#, VB.NET, D)
C# anonymous methods and lambda expressions support closure:
var data = new[] ;
var multiplier = 2;
var result = data.Select(x => x * multiplier);
Visual Basic .NET, which has many language features similar to those of C#, also supports lambda expressions with closures:
Dim data =
Dim multiplier = 2
Dim result = data.Select(Function(x) x * multiplier)
In D, closures are implemented by delegates, a function pointer paired with a context pointer (e.g. a class instance, or a stack frame on the heap in the case of closures).
auto test1()
auto test2()
void bar()
D version 1, has limited closure support. For example, the above code will not work correctly, because the variable a is on the stack, and after returning from test(), it is no longer valid to use it (most probably calling foo via dg(), will return a 'random' integer). This can be solved by explicitly allocating the variable 'a' on heap, or using structs or class to store all needed closed variables and construct a delegate from a method implementing the same code. Closures can be passed to other functions, as long as they are only used while the referenced values are still valid (for example calling another function with a closure as a callback parameter), and are useful for writing generic data processing code, so this limitation, in practice, is often not an issue.
This limitation was fixed in D version 2 - the variable 'a' will be automatically allocated on the heap because it is used in the inner function, and a delegate of that function can escape the current scope (via assignment to dg or return). Any other local variables (or arguments) that are not referenced by delegates or that are only referenced by delegates that do not escape the current scope, remain on the stack, which is simpler and faster than heap allocation. The same is true for inner's class methods that reference a function's variables.
Function objects (C++)
C++ enables defining function object
In computer programming, a function object is a construct allowing an object to be invoked or called as if it were an ordinary function, usually with the same syntax (a function parameter that can also be a function). Function objects are often c ...
s by overloading operator()
. These objects behave somewhat like functions in a functional programming language. They may be created at runtime and may contain state, but they do not implicitly capture local variables as closures do. As of the 2011 revision, the C++ language also supports closures, which are a type of function object constructed automatically from a special language construct called ''lambda-expression''. A C++ closure may capture its context either by storing copies of the accessed variables as members of the closure object or by reference. In the latter case, if the closure object escapes the scope of a referenced object, invoking its operator()
causes undefined behavior since C++ closures do not extend the lifetime of their context.
void foo(string myname)
Inline agents (Eiffel)
Eiffel includes inline agents defining closures. An inline agent is an object representing a routine, defined by giving the code of the routine in-line. For example, in
ok_button.click_event.subscribe (
agent (x, y: INTEGER) do
map.country_at_coordinates (x, y).display
end
)
the argument to subscribe
is an agent, representing a procedure with two arguments; the procedure finds the country at the corresponding coordinates and displays it. The whole agent is "subscribed" to the event type click_event
for a
certain button, so that whenever an instance of the event type occurs on that button – because a user has clicked the button – the procedure will be executed with the mouse coordinates being passed as arguments for x
and y
.
The main limitation of Eiffel agents, which distinguishes them from closures in other languages, is that they cannot reference local variables from the enclosing scope. This design decision helps in avoiding ambiguity when talking about a local variable value in a closure - should it be the latest value of the variable or the value captured when the agent is created? Only Current
(a reference to current object, analogous to this
in Java), its features, and arguments of the agent itself can be accessed from within the agent body. The values of the outer local variables can be passed by providing additional closed operands to the agent.
C++Builder __closure reserved word
Embarcadero C++Builder provides the reserve word __closure to provide a pointer to a method with a similar syntax to a function pointer.Full documentation can be found at http://docwiki.embarcadero.com/RADStudio/Rio/en/Closure
In standard C you could write a for a pointer to a function type using the following syntax:
typedef void (*TMyFunctionPointer)( void );
In a similar way you can declare a for a pointer to a method using the following syntax:
typedef void (__closure *TMyMethodPointer)();
See also
* Anonymous function
In computer programming, an anonymous function (function literal, lambda abstraction, lambda function, lambda expression or block) is a function definition that is not bound to an identifier. Anonymous functions are often arguments being passed t ...
* Blocks (C language extension)
* Command pattern
* Continuation
* Currying
In mathematics and computer science, currying is the technique of translating the evaluation of a function that takes multiple arguments into evaluating a sequence of functions, each with a single argument. For example, currying a function f tha ...
* Funarg problem In computer science, the funarg problem ''(function argument problem)'' refers to the difficulty in implementing first-class functions (functions as first-class objects) in programming language implementations so as to use stack-based memory all ...
* Lambda calculus
Lambda calculus (also written as ''λ''-calculus) is a formal system in mathematical logic for expressing computation based on function abstraction and application using variable binding and substitution. It is a universal model of computation th ...
* Lazy evaluation
* Partial application
* Spaghetti stack
* Syntactic closure
* Value-level programming
Notes
References
External links
Original "Lambda Papers"
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
Lambda (}, ''lám(b)da'') is the 11th letter of the Greek alphabet, representing the voiced alveolar lateral approximant . In the system of Greek numerals, lambda has a value of 30. Lambda is derived from the Phoenician Lamed . Lambda gave ri ...
expressions'').
*
*
Closures
An article about closures in dynamically typed imperative languages, by Martin Fowler.
Collection closure methods
An example of a technical domain where using closures is convenient, by Martin Fowler.
{{DEFAULTSORT:Closure (Computer Science)
Programming language concepts
Implementation of functional programming languages
Subroutines
Articles with example Python (programming language) code
Articles with example Scheme (programming language) code
Articles with example JavaScript code
Articles with example C++ code
Articles with example Eiffel code
Articles with example C Sharp code
Articles with example D code
Articles with example Objective-C code
Articles with example Java code
Articles with example Ruby code
Articles with example Smalltalk code
Articles with example Haskell code