comparing symbols coming from gensym?

comparing symbols coming from gensym?

[Joe Corneli]

Why is it that

(setq a (gensym)) ;=> G2007
a                 ;=> G2007
(equal a 'G2007)  ;=> nil

while 

(setq a 'foo)    ;=> foo
a                ;=> foo
(equal a 'foo)   ;=> t

?

Re: comparing symbols coming from gensym?

[Alan Mackenzie]

Joe Corneli <jcorneli@math.utexas.edu> wrote on Tue, 23 Aug 2005 23:50:46
-0500:

> Why is it that

> (setq a (gensym)) ;=> G2007
> a                 ;=> G2007
> (equal a 'G2007)  ;=> nil

> while 

> (setq a 'foo)    ;=> foo
> a                ;=> foo
> (equal a 'foo)   ;=> t

> ?

This is because your gensymmed symbol, 'G2007, has only been
"half-created".  It hasn't been "interned" in the "obarray", the
structure which holds (almost) all symbols - that 'G2007 is a
free-floating symbol.

When you do (equal a 'G2007), this _creates_ a full-bloodied
industrial-strength NEW _interned_ symbol G2007, since there wasn't
already such a symbol in the obarray.  This is distinct from your
gensymmed one.

That is, in fact, the whole point of gensym - to create a symbol distinct
from any other symbol which ever has been or ever will be.  You asked for
it, you got it!  If you want to actually _use_ it, you'll need something
like (symbol-value a)

Look up `gensym' in the CL manual, and `intern' in the Elisp manual.

-- 
Alan Mackenzie (Munich, Germany)

Email: aacm@muuc.dee; to decode, wherever there is a repeated letter
(like "aa"), remove half of them (leaving, say, "a").

Re: comparing symbols coming from gensym?

[N. Raghavendra]

At 2005-08-23T23:50:46-05:00, Joe Corneli wrote:

> Why is it that
> 
> (setq a (gensym)) ;=> G2007
> a                 ;=> G2007
> (equal a 'G2007)  ;=> nil

Perhaps this is because `a' is an uninterned symbol --- see
`(elisp)Creating Symbols' --- while `G2007' is an interned symbol.
(`gensym' creates an uninterned symbol.)

ELISP> (intern-soft a)
nil
ELISP> (intern-soft 'G55817)
G55817

> while 
> 
> (setq a 'foo)    ;=> foo
> a                ;=> foo
> (equal a 'foo)   ;=> t

In this case, both `a' and `foo' are interned.

ELISP> (intern-soft a)
foo
ELISP> (intern-soft 'foo)
foo

Raghavendra.

-- 
N. Raghavendra <raghu@mri.ernet.in> | See message headers for contact
Harish-Chandra Research Institute   | and OpenPGP details.

RE: comparing symbols coming from gensym?

[Drew Adams]

    Why is it that
    (setq a (gensym)) ;=> G2007
    a                 ;=> G2007
    (equal a 'G2007)  ;=> nil
    while
    (setq a 'foo)    ;=> foo
    a                ;=> foo
    (equal a 'foo)   ;=> t

Perhaps because gensym, like make-symbol, doesn't intern the symbol it
creates? The reader interns `foo' in (setq a 'foo). So, they are different
symbols: one is interned in obarray; the other is an uninterned symbol.

Re: comparing symbols coming from gensym?

[Joe Corneli]

   When you do (equal a 'G2007), this _creates_ a full-bloodied
   industrial-strength NEW _interned_ symbol G2007, since there wasn't
   already such a symbol in the obarray.  This is distinct from your
   gensymmed one.

   That is, in fact, the whole point of gensym - to create a symbol distinct
   from any other symbol which ever has been or ever will be.  You asked for
   it, you got it!  If you want to actually _use_ it, you'll need something
   like (symbol-value a)

(setq a (gensym)) ;=> G2016 this morning
(symbol-name a)   ;=> "G2016"
(symbol-value a)  ;=> `void-variable' error

So I guess `symbol-name' is the thing to use.

Incidentally,

(symbol-value 'G2016)

also gives a `void-variable' error.

The moral of the story here is that I shouldn't be using `gensym' but
rather something "gensym-like", better tailored to the situation I'm
working in.


Just to pick up the original thread briefly, the fact that I was using
`equal' and not `eq' is maybe an argument for the comparison to return
`t' even though the two variables are distinct and stored in
different places; remember, it says

,----
| Return t if two Lisp objects have similar structure and contents.
| They must have the same data type.
`----

They have no contents (as evidenced above) and appear to be internally
similar?

(type-of 'G2016)
(type-of a)

Both are symbols.  I guess the interpreter judges them by their
situation in the world as well as their internal contents, which
doesn't seem very egalitarian of it.

Or perhaps the idea is like with infinities, even though both values
are singular, they aren't necessarily equal?

Perhaps some additional information should appear on the `equal'
docstring?