About self-referential object

About self-referential object

[Xue Fuqiao]

I have a question about self-referential object:

(setq foo '(nil))
=> (nil)
(setcar foo foo)
=> (#0)

It is an infinite recursion.  What does the `#0' mean here?  Can anybody help?  Thanks.
-- 
Best regards, Xue Fuqiao.
http://www.emacswiki.org/emacs/XueFuqiao

RE: About self-referential object

[Drew Adams]

> (setq foo '(nil)) => (nil)
> (setcar foo foo)  => (#0)
> 
> It is an infinite recursion.  What does the `#0' mean here?  

The Elisp manual is your friend.  There are no doubt several ways to look this
up.  Start with `i' usually, which uses the indexes.

If you don't find what you want using `i' then try searching: `C-s #0' finds an
answer immediately in this case, in node `Output Function'.

If you can find what you want by means other than using the indexes (`i'),
consider reporting an Emacs bug to improve the index, explaining how you tried
to find it.

Re: About self-referential object

[Xue Fuqiao]

On Fri, 4 Jan 2013 15:47:42 -0800
"Drew Adams" <drew.adams@oracle.com> wrote:

> The Elisp manual is your friend.  There are no doubt several ways to look this
> up.  Start with `i' usually, which uses the indexes.
I've used 
> If you don't find what you want using `i' then try searching: `C-s #0' finds an
> answer immediately in this case, in node `Output Function'.
Sorry for not mentioning my preparation for this question(and other questions).
Before I ask a question, I usually try these methods:
1. Search the archives of comp.emacs and gnu.emacs.help.
2. Search on the web.
3. Use `icicle-Info-index'.
4. Use `icicle-search' on the manuals flattened with 	`Info-merge-subnodes'.
5. Search the Emacs FAQ.
6. Read the source code(but I'm not an Emacs Lisp guru).

I had found it in (info "(elisp) Output Functions"), it says:
Emacs detects such recursion and prints `#LEVEL' instead of recursively printing an object already being printed.  For example, here `#0' indicates a recursive reference to the object at level 0 of the current print operation.

But I don't understand.  What does `object at level 0 of the current print operation' mean?

> If you can find what you want by means other than using the indexes (`i'),
> consider reporting an Emacs bug to improve the index, explaining how you tried
> to find it.
Thanks for your advice.  I'll do that the next time.
-- 
Best regards, Xue Fuqiao.
http://www.emacswiki.org/emacs/XueFuqiao

RE: About self-referential object

[Drew Adams]

> Emacs detects such recursion and prints `#LEVEL' instead of 
> recursively printing an object already being printed.  For 
> example, here `#0' indicates a recursive reference to the 
> object at level 0 of the current print operation.
> 
> But I don't understand.  What does `object at level 0 of the 
> current print operation' mean?

It starts to print the object `foo', which is a cons cell whose car is the value
of `foo' and whose cdr is ().  To print the cons cell it prints `(', followed by
the car, followed by `)' - since the cdr is ().

Let's assume first that it tries to print the infinite object without any
abbreviation.  When it starts printing the value of `foo' it is at level 0 (top
level).  When it tries to print the car of that cons, it needs to print the
value of `foo' again, this time at printing level 1: `((foo))'.  When it tries
to print that third `foo' it is at level 2, and so on.  Think of the printing
"levels" here as recursive calls to a printing function.

To abbreviate, it prints just (#0), meaning a single cons cell with, as its car,
the same cons cell, i.e., the object that the printer started out to print.

Printing it the long way would be impossible.  But it would also be misleading
(incorrect), because we would naturally read `(((...(foo)...)))' as being a cons
cell with a different cons cell as its car, and that cons cell having another
cons cell as its car,... etc.

IOW, we would read it incorrectly as nested cons cells, all of which are
different.  In fact, there is only one cons cell, whose car is itself.

Pascal correctly mentioned the _read_ syntax for this kind of thing: #1=(#1#).
If you try to read the printed value #0 then an error is raised.

See also (elisp) `Circular Objects'.

Re: About self-referential object

[Xue Fuqiao]

On Fri, 4 Jan 2013 16:55:56 -0800
"Drew Adams" <drew.adams@oracle.com> wrote:

> Let's assume first that it tries to print the infinite object without any
> abbreviation.  When it starts printing the value of `foo' it is at level 0 (top
> level).  When it tries to print the car of that cons, it needs to print the
> value of `foo' again, this time at printing level 1: `((foo))'.  When it tries
> to print that third `foo' it is at level 2, and so on.  Think of the printing
> "levels" here as recursive calls to a printing function.
> 
> To abbreviate, it prints just (#0), meaning a single cons cell with, as its car,
> the same cons cell, i.e., the object that the printer started out to print.
Ah, I see, thanks.
-- 
Best regards, Xue Fuqiao.
http://www.emacswiki.org/emacs/XueFuqiao

Re: About self-referential object

[Xue Fuqiao]

A typo: no "I've used" in between.
-- 
Best regards, Xue Fuqiao.
http://www.emacswiki.org/emacs/XueFuqiao

Re: About self-referential object

[Pascal J. Bourguignon]

"Drew Adams" <drew.adams@oracle.com> writes:

>> (setq foo '(nil)) => (nil)
>> (setcar foo foo)  => (#0)
>> 
>> It is an infinite recursion.  What does the `#0' mean here?  
>
> The Elisp manual is your friend.  There are no doubt several ways to look this
> up.  Start with `i' usually, which uses the indexes.
>
> If you don't find what you want using `i' then try searching: `C-s #0' finds an
> answer immediately in this case, in node `Output Function'.
>
> If you can find what you want by means other than using the indexes (`i'),
> consider reporting an Emacs bug to improve the index, explaining how you tried
> to find it.

Emacs lisp is really baroque.  
Why introduce #0 when #1=(#1#) can already denote it?


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

Re: About self-referential object

[Stefan Monnier]

> Emacs lisp is really baroque.
> Why introduce #0 when #1=(#1#) can already denote it?

Because the second one came after (IIRC around Emacs-21) the first one.


        Stefan

Re: About self-referential object

[Pascal J. Bourguignon]

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

> I have a question about self-referential object:
>
> (setq foo '(nil))
> => (nil)
> (setcar foo foo)
> => (#0)
>
> It is an infinite recursion.  What does the `#0' mean here?  Can anybody help?  Thanks.

It means you've commited the sacrilege of modifying a literal value!
If you modify a mutable cons cell, everything works as expected:


*** Welcome to IELM ***  Type (describe-mode) for help.
ELISP> (setq print-circle t)
t
ELISP> (setq foo (cons nil nil))
(nil)

ELISP> (setcar foo foo)
#1=(#1#)

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