I find the notion of closures fundamental and a bit trivial in high-level languages with first-class function. So, I was surprised seeing a large number of forums in where they are discussed, and also how it is used in for job interviews that requires coding in a high-level language (in particular for javascript).

But before getting too much into the discussion, let me define first what are closures. The most straightforward definition I can think of goes something like this:

Closures are a computer language feature, so I will be using C++, javascript, and python to illustrate the central concepts in this and future posts. The minimal example of a closure is the following code

def CreateClosure(context):
    def method():
        return context
    return method

closure = CreateClosure('A')

print('', closure())
#> context in closure: A

in where python interpreter creates a closure with the method function and by implicitly capturing variable context.

It is essential to spell out that returning a reference or pointer to a function does not create a closure! For emphasis, I am writing the following example using C++ that did not support closures before C++11².

// Example of what is not a closure!
#include <iostream>
#include <sting>

using namespace std;

// Defining context and method in global namespace.
string context = "";
string Method()
{
    return context;
}
// Return a reference to Method.
string (*CreateMethodWithContext(string value))()
{
    context = value;
    return Method;
}
int main(int argc, const char* argv[])
{
    // Create a reference to method and set context
    string (*method)() = CreateMethodWithContext("A");
    cout << "context when calling method: " << method() << endl;
    return 0;
}
//> context when calling method: A

In this case, there is no need to create a closure made of method and a context because both exist in the global namespace, and therefore they are trivially accessible throughout the whole program. It is possible for me to write a version of this example in C++, as well in high level languages like javascript, and python.

One question that naturally arises is how the variables are captured, by copy/value or by reference³. The answer for both javascript and python depends on the nature of the input context. If context is an immutable object, then the closure tend to behave like a capture by copy/value. This is because immutable objects cannot be changed, and therefore it looks like as the closure contains only the value of context. On another hand, if input context is a mutable object, then it is possible to change context value using the initial reference pass to the CreateClosure function. The following code in javascript, and python provide working examples of these two behaviors.

A follow-up question is then: what about the life cycle of those variables capture in closures? The answer to that question will be the topic of my next post.

References