apophenia comments on Open Thread: July 2010, Part 2

[apophenia]

The technical term for this is a closure. A closure is a first-class* function with some associated state. For example, in Scheme, here is a function which returns counters, each with its own internal ticker:

(define (make-counter)

(let ([internal-variable 0])

  (lambda ()

          (begin (set! internal-variable (+ internal-variable 1))

                internal-variable))))

To create a counter, you’d do something like

(define counter1 (make-counter 0))

(define counter2 (make-counter 0))

Then, to get values from the counter, you could call something like

(display (counter1))

(display (counter2))

(display (counter2))

(display (counter2))

(display (counter1))

(display (counter2)) which prints: 1, 1, 2, 3, 2, 4.

Here is the same example in Python, since that’s what most people seem to be posting in:

def make_counter():

def counter(internal_variable=[0]):

   internal_variable[0] += 1

   return internal_variable[0]

return counter

counter1 = make_counter()

counter2 = make_counter()

print(counter1())

print(counter2())

print(counter2())

print(counter2())

print(counter1())

print(counter2())

*That is, a function which you can pass around like a value.

[sketerpot]

While we’re sharing fun information, I’d like to point out a little-used feature of Markdown syntax: if you put four spaces before a line, it’s treated as code. Behold:

(define (make-counter)
  (let ([internal-variable 0])
    (lambda ()
      (begin (set! internal-variable (+ internal-variable 1))
         internal-variable))))

Also, the emacs rectangle editing functions are good for this. C-x r t is a godsend.