Scheme explanation(construct)

Question

Can someone please explain me why :

(define a (lambda() (cons a #f)))

(car (a)) ==> procedure

((car (a))) ==> (procedure . #f)

I don't think I get it. Thanks

I believe it becomes a little bit clearer if you look at the value of `(a)` and compare that with `((car (a)))`. — molbdnilo, Dec 15 '14 at 11:50
I don't understand the (car (a)).It's the same to(car (a) '()) ?? — Valentin Emil Cudelcu, Dec 15 '14 at 13:08
No, that would be nonsense. `car` takes one parameter, not two. — molbdnilo, Dec 15 '14 at 14:21
You'true ,but "car" choose from a "cons"...or not? (car(cons 1 2)). In my example i have (car(a)). This is what i can't understand. — Valentin Emil Cudelcu, Dec 15 '14 at 17:50
I don't understand what it is you don't understand. What do you expect `(car (a))` and `((car (a)))` to be? (In `(car (a))`, `(a)` is not the list `(cons a '())` - or `(list a)` - it is a procedure call.) — molbdnilo, Dec 15 '14 at 20:24
@ValentinEmilCudelcu if you understand now, you should check the one answer that was most helpful to you. This will also give you a +2 rep bump. And with 15 rep you can also *upvote* any answer that you deem useful. — Will Ness, Dec 16 '14 at 09:32

molbdnilo · Accepted Answer · 2014-12-16T12:15:13.713

This

(define a (lambda() (cons a #f)))

defines a procedure, a, which when called will return the pair

(<the procedure a> . #f)

i.e. whose car is the procedure itself, and whose cdr is #f.

In other words, the result of evaluating

(a)

is the result of calling the procedure a with no arguments, which is, by definition of a above,

(<the procedure a> . #f)

Hence,

(car (a))

is <the procedure a> (because it means "call car with the result of evaluating (a)")

When you add another pair of parentheses

((car (a)))

you're calling that procedure, which - since it's the procedure a - returns the same result as (a),

 (<the procedure a> . #f)

score 1 · Answer 2 · answered Dec 15 '14 at 10:05

define from top level defines a global variable a.

The anonymous procedure (lambda() (cons a #f), when called, makes a pair out of the evaluation of a and #f.

When you evaluate a you get a procedure. In my system you get #<procedure:a>.

When you evaluate (a) you get (#<procedure:a> . #f). Now the way procedures display is highly implementation dependent. There are no standard, but many will use a convension where the name a would be present, but don't count on it.

Since a also can be accessed as the car of the result of calling a you can ((car (a))) and get the same as (a). That's because (eq? a (car (a))) is #t.

Scheme explanation(construct)

2 Answers2