Re: Replacement for Common Lisp's GENSYM in Emacs Lisp

Re: Replacement for Common Lisp's GENSYM in Emacs Lisp

[David Kastrup]

Teemu Likonen <tlikonen@iki.fi> writes:

> In Common Lisp GENSYM function generates unique symbol names. It seems
> that Emacs Lisp does not have similar function (unless with CL
> extension). In plain Emacs Lisp code and macros, what would you
> suggest as a replacement for GENSYM? Just some very unlikely names?

Uninterned symbols created with make-symbol work just fine for most
purposes.  Only rare applications need unique print names and/or symbols
accessed by name.

-- 
David Kastrup

Re: Replacement for Common Lisp's GENSYM in Emacs Lisp

[Teemu Likonen]

* 2010-03-06 17:10 (+0100), David Kastrup wrote:

> Uninterned symbols created with make-symbol work just fine for most
> purposes. Only rare applications need unique print names and/or
> symbols accessed by name.

Yes, I agree. Thanks.

Re: Replacement for Common Lisp's GENSYM in Emacs Lisp

[Tim X]

Teemu Likonen <tlikonen@iki.fi> writes:

> In Common Lisp GENSYM function generates unique symbol names. It seems
> that Emacs Lisp does not have similar function (unless with CL
> extension). In plain Emacs Lisp code and macros, what would you suggest
> as a replacement for GENSYM? Just some very unlikely names?
>
>

This is actually a non-trivial problem. Best approach would probably be
to do something similar to how they generate universally unique IDs. 

I'd probably use some combination of letters/name and a random number.
Once generated, I'd look to see if the symbol by that name is already
interned and if it was, increment the number and try again. 

Other approaches I've seen use name/letters and the date as seconds
since epoch plus a cuple of random digits. 

The solution that is best really depends on what the criteria is for
correctness. A large lisp implementation that runs a flight control
centre in a busy airport probalby has a higher correctness criteria than
a bit of elisp that uses gensyms in a macro that handles address records
for a address book.

In reality, I'd just use (require 'cl)

Tim


-- 
tcross (at) rapttech dot com dot au

Re: Replacement for Common Lisp's GENSYM in Emacs Lisp

[Stefan Monnier]

> This is actually a non-trivial problem.  Best approach would probably be
> to do something similar to how they generate universally unique IDs.

The best approach often is to not use "unique symbols" at all.  A common
technique is to rely on lexical scoping to precisely control which
variables are visible to each part of a macro's argument during its
evaluation.  E.g.:

  (defmacro dotimes (xl e)
    (let ((x (car xl))
          (l (cadr xl)))
      `(let ((body (lambda (,x) ,e))
             (list ,l))
         (while (consp list)
           (funcall body (car list))
           (setq list (cdr list))))))

Notice how the expressions `l' and `e' are evaluated in a context where
neither of `body', nor `list' exist.  No need for gensym.

Of course Elisp's lack of good support for lexical scoping makes such
a technique impractical.  But `make-symbol' can be used instead of
`gensym' and works very well for that purpose.


        Stefan

Re: Replacement for Common Lisp's GENSYM in Emacs Lisp

[Helmut Eller]

* Stefan Monnier [2010-03-07 20:06+0100] writes:

>> This is actually a non-trivial problem.  Best approach would probably be
>> to do something similar to how they generate universally unique IDs.
>
> The best approach often is to not use "unique symbols" at all.  A common
> technique is to rely on lexical scoping to precisely control which
> variables are visible to each part of a macro's argument during its
> evaluation.  E.g.:
>
>   (defmacro dotimes (xl e)
>     (let ((x (car xl))
>           (l (cadr xl)))
>       `(let ((body (lambda (,x) ,e))
>              (list ,l))
>          (while (consp list)
>            (funcall body (car list))
>            (setq list (cdr list))))))
>
> Notice how the expressions `l' and `e' are evaluated in a context where
> neither of `body', nor `list' exist.  No need for gensym.

What makes you think that body and list aren't bound in e?

Helmut

Re: Replacement for Common Lisp's GENSYM in Emacs Lisp

[Stefan Monnier]

>>   (defmacro dotimes (xl e)
>>     (let ((x (car xl))
>>           (l (cadr xl)))
>>       `(let ((body (lambda (,x) ,e))
>>              (list ,l))
>>          (while (consp list)
>>            (funcall body (car list))
>>            (setq list (cdr list))))))
>> 
>> Notice how the expressions `l' and `e' are evaluated in a context where
>> neither of `body', nor `list' exist.  No need for gensym.

> What makes you think that body and list aren't bound in e?

Nothing, but luckily it doesn't make any difference whether they are
or not.


        Stefan

Re: Replacement for Common Lisp's GENSYM in Emacs Lisp

[Helmut Eller]

* Stefan Monnier [2010-03-08 05:55+0100] writes:

>>>   (defmacro dotimes (xl e)
>>>     (let ((x (car xl))
>>>           (l (cadr xl)))
>>>       `(let ((body (lambda (,x) ,e))
>>>              (list ,l))
>>>          (while (consp list)
>>>            (funcall body (car list))
>>>            (setq list (cdr list))))))
>>> 
>>> Notice how the expressions `l' and `e' are evaluated in a context where
>>> neither of `body', nor `list' exist.  No need for gensym.
>
>> What makes you think that body and list aren't bound in e?
>
> Nothing, but luckily it doesn't make any difference whether they are
> or not.

Your "dotimes" macro produces:

(let ((list '(1)) (result ()))
  (dotimes (i '(1 2 3)) (push list result))
  result) => ((3) (2 3) (1 2 3))

While a version which doesn't shadow "list" produces this:

(let ((list '(1)) (result ()))
  (dolist (i '(1 2 3)) (push list result))
  result) => ((1) (1) (1))

Helmut

Re: Replacement for Common Lisp's GENSYM in Emacs Lisp

[Stefan Monnier]

>> Nothing, but luckily it doesn't make any difference whether they are
>> or not.

> Your "dotimes" macro produces:

> (let ((list '(1)) (result ()))
>   (dotimes (i '(1 2 3)) (push list result))
>   result) => ((3) (2 3) (1 2 3))

> While a version which doesn't shadow "list" produces this:

> (let ((list '(1)) (result ()))
>   (dolist (i '(1 2 3)) (push list result))
>   result) => ((1) (1) (1))

Because you're trying it out in Elisp (which uses dynamic scoping),
whereas this technique relies on lexical-scoping.


        Stefan

Replacement for Common Lisp's GENSYM in Emacs Lisp

[Teemu Likonen]

In Common Lisp GENSYM function generates unique symbol names. It seems
that Emacs Lisp does not have similar function (unless with CL
extension). In plain Emacs Lisp code and macros, what would you suggest
as a replacement for GENSYM? Just some very unlikely names?

Re: Replacement for Common Lisp's GENSYM in Emacs Lisp

[tomas]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

On Sat, Mar 06, 2010 at 05:19:43PM +0200, Teemu Likonen wrote:
> In Common Lisp GENSYM function generates unique symbol names. It seems
> that Emacs Lisp does not have similar function (unless with CL
> extension). In plain Emacs Lisp code and macros, what would you suggest
> as a replacement for GENSYM? Just some very unlikely names?

It seems `make-symbol' is what you are looking for. It generates an
uninterned symbol. Cf. Emacs Lisp manual "13.6.3 Local Variables in
Macro Expansions" to find an usage example.

Regards
- -- tomás
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.4.6 (GNU/Linux)

iD8DBQFLkz4zBcgs9XrR2kYRAmYlAJ9u8h6o4RUYyjQrTM2BoHZViWsQ5ACaAsiu
WihLVHls9qY7oDOxCU4ysGM=
=3Ghx
-----END PGP SIGNATURE-----

Re: Replacement for Common Lisp's GENSYM in Emacs Lisp

[Teemu Likonen]

* 2010-03-07 06:48 (+0100), tomas@tuxteam.de wrote:

> On Sat, Mar 06, 2010 at 05:19:43PM +0200, Teemu Likonen wrote:
>> In Common Lisp GENSYM function generates unique symbol names. It
>> seems that Emacs Lisp does not have similar function (unless with CL
>> extension). In plain Emacs Lisp code and macros, what would you
>> suggest as a replacement for GENSYM? Just some very unlikely names?
>
> It seems `make-symbol' is what you are looking for. It generates an
> uninterned symbol. Cf. Emacs Lisp manual "13.6.3 Local Variables in
> Macro Expansions" to find an usage example.

That's right. My question was rather stupid, or at least asked too
hastily. It was in my mental patterns that I need GENSYM to create
symbols for macros. So I immediately thought I need to write a GENSYM
replacement for Emacs Lisp. But as you and David pointed out, the point
wasn't really unique print names but uninterned symbols. So make-symbol
is often sufficient. Thanks.

Re: Replacement for Common Lisp's GENSYM in Emacs Lisp

[Pascal J. Bourguignon]

Teemu Likonen <tlikonen@iki.fi> writes:

> * 2010-03-07 06:48 (+0100), tomas@tuxteam.de wrote:
>
>> On Sat, Mar 06, 2010 at 05:19:43PM +0200, Teemu Likonen wrote:
>>> In Common Lisp GENSYM function generates unique symbol names. It
>>> seems that Emacs Lisp does not have similar function (unless with CL
>>> extension). In plain Emacs Lisp code and macros, what would you
>>> suggest as a replacement for GENSYM? Just some very unlikely names?
>>
>> It seems `make-symbol' is what you are looking for. It generates an
>> uninterned symbol. Cf. Emacs Lisp manual "13.6.3 Local Variables in
>> Macro Expansions" to find an usage example.
>
> That's right. My question was rather stupid, or at least asked too
> hastily. It was in my mental patterns that I need GENSYM to create
> symbols for macros. So I immediately thought I need to write a GENSYM
> replacement for Emacs Lisp. But as you and David pointed out, the point
> wasn't really unique print names but uninterned symbols. So make-symbol
> is often sufficient. Thanks.

Of course, (even in Common Lisp) macros could always use make-symbol.
If we use (gensym), or even better, (gensym "varname"), it's to be able
to read the expansion of macros.  It's a debugging device.

But we could also (setq print-circle t) and use (make-symbol "varname");
the #=/## notation will allow us to distinguish the different symbols
generated.


-- 
__Pascal Bourguignon__