About Circular Objects

About Circular Objects

[Xue Fuqiao]

I have a question about the #N# read syntax and #N= syntax.  Look at this code:

(progn
  (setq x '#1=(a #1#))
  (eq x (cdr x)))

Why does this code return nil?  Isn't the second element the list itself?

-- 
Best regards.

Re: About Circular Objects

[Teemu Likonen]

Xue Fuqiao [2012-12-25 16:52:49 +0800] wrote:

> I have a question about the #N# read syntax and #N= syntax. Look at
> this code:
>
> (progn
>   (setq x '#1=(a #1#))
>   (eq x (cdr x)))
>
> Why does this code return nil? Isn't the second element the list
> itself?

No. It's the CAR of the second cons cell that points to the list itself.
If you want the CDR of the first (and only) cons cell to point back to
the cons cell, you would use this:

    (progn
      (setq x '#1=(a . #1#)) ; Note the dotted list.
      (eq x (cdr x)))

    => t

Re: About Circular Objects

[Lars Magne Ingebrigtsen]

Xue Fuqiao <xfq.free@gmail.com> writes:

> I have a question about the #N# read syntax and #N= syntax.  Look at
> this code:
>
> (progn
>   (setq x '#1=(a #1#))
>   (eq x (cdr x)))
>
> Why does this code return nil?  Isn't the second element the list itself?

(progn
  (setq x '#1=(a . #1#))
  (eq x (cdr x)))

=> t
  
-- 
(domestic pets only, the antidote for overdose, milk.)
  http://lars.ingebrigtsen.no  *  Lars Magne Ingebrigtsen

Re: About Circular Objects

[Pascal J. Bourguignon]

Xue Fuqiao <xfq.free@gmail.com> writes:

> I have a question about the #N# read syntax and #N= syntax.  Look at this code:
>
> (progn
>   (setq x '#1=(a #1#))
>   (eq x (cdr x)))
>
> Why does this code return nil?  Isn't the second element the list itself?

No.  Try it. (use M-x ielm). 


*** Welcome to IELM ***  Type (describe-mode) for help.
ELISP> (setq x '#1=(a #1#))
#1=(a #1#)

ELISP> x
#1=(a #1#)

ELISP> (cdr x)
#1=((a . #1#))

ELISP> (eq x (second x))
t
ELISP> (eq x (cadr x))
t
ELISP> (eq x (cdr x))
nil
ELISP> 


If you want (eq x (cdr x)), then write:

    (setq x '#1=(a . #1#))

instead of:

    (setq x '#1=(a #1#))


ELISP> (setq x '#1=(a . #1#))
#1=(a . #1#)

ELISP> (eq x (cdr x))
t
ELISP> 


Not all circular structures are circular lists.  Even circular lists may
have a stem:


ELISP> (let ((circle '#1=(a . #1#)))
         (setq x (list* 'a 'a 'a circle)))
(a a a . #1=(a . #1#))

ELISP> x
(a a a . #1=(a . #1#))

ELISP> (eq (car x) (cadr x))
t
ELISP> (eq (cadr x) (caddr x))
t
ELISP> (eq (caddr x) (cadddr x))
t

and so on ad libitum, but:

ELISP> (eq x (cdr x))
nil
ELISP> 




-- 
__Pascal Bourguignon__                     http://www.informatimago.com/
A bad day in () is better than a good day in {}.