1

I am confused about the difference between '(()) and (cons null null) in scheme.

The code below show that b and c are completely the same thing. 

(define (dup2 x)
  (let ((d '(())))
    (set-car! d (car x))
    (set-cdr! d (cdr x))
    d))

(define a '(1 2))

(define b (dup2 a))
(define c (dup2 a))

(set-car! b 2)

> c  ;; --> (2 2)

However, when I used dup instead of dup2:

(define (dup x)
  (let ((d (cons null null)))
    (set-car! d (car x))
    (set-cdr! d (cdr x))
    d))

(define a '(1 2))

(define b (dup a))
(define c (dup a))

(set-car! b 2)

> c  ;; --> (1 2)

Variable b and c are different. I have done some experiments, but I haven't understand yet.

Nmzzz
  • 2,462
  • 3
  • 19
  • 18
  • 1
    possible duplicate of [Unexpected persistence of data](http://stackoverflow.com/questions/18790192/unexpected-persistence-of-data). The problem is because of the quoted data, not because of a difference in the values of `'(())` and `(cons null null)`. Try replacing `'(())` with `(list '())` and you won't observe this problem anymore. (That duplicate isn't Scheme, but Common Lisp, but the problem is the same.) For even more fun, rather than making a `dup` procedure, try writing one that _pushes_ data into the list `d`, and you'll see the list getting longer and longer over multiple calls. – Joshua Taylor Oct 03 '13 at 15:12

3 Answers3

1

The value of d in the first implementation is literal data, and is modified with undefined consequences. To highlight what's happening, consider the following code:

(define (incorrect-list-null-and-x x)
  (let ((l '(())))                 ; a list of the form (() . ())
    (set-cdr! l (cons x (cdr l)))  ; (cdr l) is (), so (cons x (cdr l)) should be (x . ()) == (x), right?
                                   ; and now l should be (() . (x . ())) == (() x), right?
    l))

The expected result is that (incorrect-list-null-and-x n) should return a list of the form (() n), and it does the first time, but successive calls are still accessing the same data:

(incorrect-list-null-and-x 1) ;=> (() 1)
(incorrect-list-null-and-x 2) ;=> (() 2 1)
(incorrect-list-null-and-x 3) ;=> (() 3 2 1)
(incorrect-list-null-and-x 4) ;=> (() 4 3 2 1)

The same problem manifests itself a bit differently in your dup2. Every value returned from dup2 is actually the same pair:

(let* ((x (dup2 (cons 1 2)))
       (y (dup2 (cons 3 4))))
  (display x)
  (display y))

outputs:

(3 . 4)(3 . 4)

because the call (dup2 (cons 3 4)) modifies the same structure that was previously returned by (dup2 (cons 1 2)).

Joshua Taylor
  • 84,998
  • 9
  • 154
  • 353
0

Data literals, like '(()), are meant to be read-only, and modifying it using set-car! or set-cdr! has undefined behaviour. For predictable behaviour, use the (cons '() '()) version if you want to use set-car! or set-cdr! on it.

In particular, cons creates a new cons cell, whereas a data literal usually won't.

Still, for the purposes of implementing dup, why are you using set-car! and set-cdr! anyway? Just use cons directly:

 (define (dup x)
   (cons (car x) (cdr x)))
C. K. Young
  • 219,335
  • 46
  • 382
  • 435
0

In your first code snippet you use (d '(())) which ends up binding a literal to d. You then modify the literal which is generally undefined. In your second code snippet you use (d (cons null null)) which binds d to a newly created 'cons cell' which you then modify. There is no problem modifying that.

Note: you've not defined null. Perhaps you meant '()?

GoZoner
  • 67,920
  • 20
  • 95
  • 145