Question

I noticed this semi weirdish-behavior in one of my projects using Scheme and lists. I managed to isolate the behavior into a single section. The code is:

(define x (list 1 2 3)) (define y (list 4 5)) (define z (cons (car x) (cdr y))) (define w (append y z)) (define v (cons (cdr x) (cdr y))) (set-car! x 6) (set-car! y 7) (set-cdr! (cdr x) (list 8))  x y z w v 

Gives us the output of:

(6 2 8) (7 5) (1 5) (4 5 1 5) ((2 8) 5) 

Can anyone explain to me:

1. Why does (set-car! x 6) not update Z? Since according to my understanding car/cdr return pointers or references to the corresponding values. This is really weird and I’m kinda confused.
2. If car/cdr does not return references/pointers then how is the final set-cdr! manipulating the list v?

Any ideas? It’s a simple fix, but I’m more curious as to why the weirdness with the variables is going on.

Answer 1

Okay, let’s step through your program line by line. I’m also assigning unique numbers (think of them as object addresses, if you’re used to C-like languages) for each newly-created object so you can see what’s what. 🙂

(define x (list 1 2 3))             ; => #1 = (1 . #2), #2 = (2 . #3), #3 = (3 . ()) (define y (list 4 5))               ; => #4 = (4 . #5), #5 = (5 . ()) (define z (cons (car x) (cdr y)))   ; => #6 = (1 . #5) (define w (append y z))             ; => #7 = (4 . #8), #8 = (5 . #6) (define v (cons (cdr x) (cdr y)))   ; => #9 = (#2 . #5) (set-car! x 6)                      ; => #1 = (6 . #2) (set-car! y 7)                      ; => #4 = (7 . #5) (set-cdr! (cdr x) (list 8))         ; => #2 = (2 . #10), #10 = (8 . ()) 

Now, let’s look at your values (for each reference, use the last assigned value):

x   ; #1 => (6 . #2) => (6 . (2 . #10)) => (6 2 8) y   ; #4 => (7 . #5) => (7 5) z   ; #6 => (1 . #5) => (1 5) w   ; #7 => (4 . #8) => (4 . (5 . #6)) => (4 . (5 . (1 . #5))) => (4 5 1 5) v   ; #9 => (#2 . #5) => ((2 . #10) 5) => ((2 8) 5) 

---

Edit: I’m adding a diagram to explain my answer, since you can’t have diagrams in a comment. I don’t have time to make a diagram showing the values above, but this hopefully explains a few things.

Each pair has two ‘slots’, car and cdr, represented as the left and right boxes in the diagram above. Each of these slots, as you see, has three possible things:

1. An atom (a number in your examples, or symbols in the diagram, such as let, s5, and sqrt)
2. A reference (represented as an arrow in the diagram)
3. Null (represented as a black box in the diagram)

You can put any of these in any of the slots. So, in my explanation above, each of the # items is an arrow, each of the non-# numbers is an atom, and each of the () is a black box. So, in the line

(define v (cons (cdr x) (cdr y))) 

you are creating a pair, where the left-hand slot has the same contents as the right-hand slot of x (i.e., an arrow going to pair 2), and the right-hand slot has the same contents as the right-hand slot of y (an arrow going to pair 5). In other words, both boxes in v contain arrows, each going off a different pair.

Hope this makes more sense. 🙂