Closure As Object

Closures are an important concept in many languages that supports first-class function. It really just is a simple concept. It is in Python, JavaScript, Ruby and Golang where functions are first-class citizens. It is also in OOP-ish languages like Java and C# in the form of Delegate Action Func or Consumer Producer. It is not in C. Now C++ has closures too.

I always think of closure as some sorts of inferior version of class object (inferior in the sense that class object can do everything function closure does and it can do more than function closure). This is probably not fair and not true - but it seems to be a great mental model for me for now.

To be specific, closure is function + environment. I see a closure as a class, where the “function” is a method this class exposes (and that is the only public method), and the “environments” are the private variables this class hold.

The lexical scope that closure captures is like the class state an object maintains.

Of course, ultimately these two concepts are fundamentally different and each has its own use case.

Take this example in Python:

def counting(start):
	_start = start
	def inc():
	    nonlocal _start
	    _start += 1
	    return _start
	return inc

c = counting(0)
d = counting(9)
print(c(), c(), d(), c(), d())

It (kinda) achieves the same thing as

class Counting:
    def __init__(self, start):
        self._start = start
    
    def inc(self):
        self._start += 1
        return self._start

c2 = Counting(0)
d2 = Counting(9)
print(c2.inc(), c2.inc(), d2.inc(), c2.inc(), d2.inc())

Both produces the same output 1 2 10 3 11.