Why does (c1) return 1, 2, 3 ect.. and not #?

Question

This is from the SICP course for the environmental model section:

(define make-counter 
   (lambda (n)    
     (lambda () (set! n (+ n 1))
       n)))    

Below,the interpreter says that (make-counter 0) is a procedure:

> (make-counter 0)
#<procedure:...make_counter.rkt:8:5>

Below, I define c1 to be (make-counter 0).

(define c1 (make-counter 0)

Below is where I get confused as to the reason (c1) returns the counter values instead of "procedure".

>(c1)
1
> (c1)
2
> (c1)
3

My thinking process is that if (c1) points to a procedure, (make-counter), then (c1) should return "procedure:...make_counter.rkt:8:5".

Because procedure -> procedure.

I see what should happen, I am just confused, conceptually, as to how and why.

Answer 1

What is your question? Do you doubt it works like the name suggests, or do you not understand how it does?

The first can be tested in 30 seconds, I'll answer the second:

make-counter is a procedure that takes one argument. Now look at the code again: what does it return? A procedure with 0 arguments.

So executing (c1) will return the numbers from 1 on upwards (if starting with 0).

For completeness:

Gambit v4.8.1

> (define make-counter 
   (lambda (n)    
     (lambda () (set! n (+ n 1))
       n)))    
> (define c1 (make-counter 0))
> (c1)
1
> (c1)
2
> (c1)
3
> 

Addition after question edit:

c1 is the procedure, but (c1) is procedure application, what you would call "calling the procedure" in another programming world.

> c1
#<procedure #2 c1>
> (c1)
1

BTW a nice piece of functional code, if you have understood this you will look at programming differently.

More questions via comment:

Now, its (make-counter 0). Working it by hand, I am not understanding why n is not returned.

The answer is the same we gave you about c1 and (c1):

make-counter returns lambda (), and n is only returned if you call the lambda. Functions (in scheme: procedures, lambdas) are values that can be handed around, functional programming principle. You have to call them (correct term: apply) the get the procedure result.

Now tell me: how do you call a procedure in scheme?

more edits:

Okay, we call a procedure in scheme by enclosing it in parens.

Now tell me: What is the substitution step for (c1) ?

Answer 2

My thinking process is that if (c1) points to a procedure, (make-counter), then (c1) should return "procedure:...make_counter.rkt:8:5".

This is wrong.

What is happening here is that c1 “points to a procedure”, as you say, (really it is a name bound to a procedure).

You should remember that in Scheme the form (f e1 e2 ... en) is the way to call the procedure f, passing to it the values of the expressions e1 e2 ... en.

So, (c1) is completely different from c1: it is a way of calling the procedure c1 (that has no parameter). And each time the interpreter/compiler evaluates (c1), it calls the procedure, that increases the value and return it.

Answer 3

You have

(define make-counter 
   (lambda (n)    
     (lambda () (set! n (+ n 1))
       n)))  

so evaluating make-counter

returns

   (lambda (n)    
     (lambda () (set! n (+ n 1))
       n))

and evaluating (make-counter 0) just replaces make-counter in that call with its value, and proceeds as

( (lambda (n)    
     (lambda () (set! n (+ n 1))
       n))
   0 )
=>
(let ((n 0))    
     (lambda () (set! n (+ n 1)) 
       n))

so the closure object is created and returned,

=>
(closure {environment1: ((n 0))}     ; its own binding for `n`
     (lambda () (set! n (+ n 1)) 
       n))

so after (define c1 (make-counter 0)) this closure is the value of c1.

Evaluating c1 returns its value, the procedure (closure) above. Its printed representation is implementation-dependent (showing e.g. #<procedure> or something similar).

Evaluating (c1) calls this procedure,

(c1)
=>
( (closure {environment1: ((n 0))}     ; its own binding for `n`
     (lambda () (set! n (+ n 1)) 
       n)) )
=>
(under {environment1: ((n 0))}
  (  (lambda () (set! n (+ n 1)) 
       n)) )

Calling ((lambda () ...) ) without any arguments just evaluates its body without creating any new environment, since the parameters list is empty and there are no arguments:

=>
(under {environment1: ((n 0))}
    (set! n (+ n 1))             ; perform this first
    n )
=>
(under {environment1: ((n 1))}   ; <--- altered binding for `n`!
    n )                          ; now evaluate this and return its value
=>
1

and it leaves the altered environment1 in its wake. When that procedure (closure) will be called again, (c1), its environment will now contain ((n 1)), and so will be changed to ((n 2)), etc.