make-counter which retain the state of variable next

Question

I read such a make-counter example from Section 2.9. Assignment of Scheme Programming

> (define make-counter
    (lambda ()
      (let ([next 0])
        (lambda ()
          (let ([v next])
            (set! next (+ next 1))
            v)))))
> (define count1 (make-counter))
> (count1)
0
> (count1)
1

I am very confused here, how is the state of 'next' maintained?

with my understanding,
(define count1 (make-counter)), return the value v,then the procedure of make-counter gone and destroyed,

When count1 was invoked again, a fresh make-counter called, so the expected results should be "0" constantly.

However, it magically print the following:

> (count1)
1
> (count1)
2
> (count1)
3
> (count1)
4
> (count1)
5

How the state of 'next' is kept?

Answer 1

When count1 was invoked again, a fresh make-counter called, so the expected results should be "0" constantly.

No, make-counter is not called again. It is the innermost lambda that is called again, because (make-counter) returned the innermost lambda.

To see this more clearly, rewrite make-counter like this:

(define (make-counter)
  (let ([next 0])
    (lambda ()  ; <- This lambda is the return value of `(make-counter)`.
      (let ([v next])
        (set! next (+ next 1))
        v))))

To see it even more clearly, get rid of make-counter:

> (define count1 (let ([next 0])
                   (lambda ()
                     (let ([v next])
                       (set! next (+ next 1))
                       v))))
> (count1)
0
> (count1)
1

Every time you execute (count1), you are executing the body of the lambda.

Even if you call (count1) over and over again, next will not become 0, because (count1) will only execute the body of the lambda. next was only set to 0 when count1 was initially defined.

Answer 2

It is the concept of closure, which is a pair of a pointer to environment and a pointer to code. The variable from the code points to the closure's environment. Each time when you call the yielder the code will access the closure's environment and update it.

You can do it simpler so:

(define make-counter
  (lambda(k)    ;; closure encloses the global env. containing `+`, `-`, `set!`, etc.
    (lambda()   ;; internal closure encloses an environment containing k
      (set! k (+ 1 k))  ;; each call of (counter) mutates `k`
      (- k 1))))
(define counter (make-counter 0))
(counter)
0
(counter)
1
(counter)
2