Hi All,

I'm working on a macro using keyword args, and I wish to have a
unnamed default like this:

(defmacro test (&key arg)
  (when (eq arg 't) (setq arg (gensym)))
  ...

The idea is I can call it any of three ways:

(test)
(test :arg my-arg)
(test :arg t)

This works fine as long as I use T in that last form and not, say,
'T.  But for the sake of the fact that I will always forget and first
try 'T, I'd like to support that too.

Any ideas?  (I'm using SBCL...)  I suppose this ? applies to functions
as well as macros.  Thanks!

On Dec 2, 1:05=A0pm, fortunatus <daniel.elia...@excite.com> wrote:
> Hi All,
>
> I'm working on a macro using keyword args, and I wish to have a
> unnamed default like this:
>
> (defmacro test (&key arg)
> =A0 (when (eq arg 't) (setq arg (gensym)))
> =A0 ...
>
> The idea is I can call it any of three ways:
>
> (test)
> (test :arg my-arg)
> (test :arg t)
>
> This works fine as long as I use T in that last form and not, say,
> 'T. =A0But for the sake of the fact that I will always forget and first
> try 'T, I'd like to support that too.

Remember that 'T =3D=3D> (QUOTE T) at read time. Also, you could just use
GENSYM as the default value for the key, which would be a lot easier:

(DEFMACRO TEST (&KEY (ARG (GENSYM)))
  ...)

But it's hard to give much more help beyond that without knowing what
you want the macro to do. My gut tells me you're heading down the
wrong path with whatever solution you have in mind.

HTH, ;-)

Jeff M.

> Remember that 'T =3D=3D> (QUOTE T) at read time.

Ah - yes!  If I use EQUALP rather than EQ, that works - thanks!

> Also, you could just use
> GENSYM as the default value for the key, which would be a lot easier:
>
> (DEFMACRO TEST (&KEY (ARG (GENSYM)))
> =A0 ...)

That precludes one of the forms I wish to support, when the keyword
and arg are omitted, in which case I avoid generating some code...

> My gut tells me you're heading down the
> wrong path with whatever solution you have in mind.

Mine too, I agree!  ;->  But it's working now, and somewhat
reasonable...

> Ah - yes! =A0If I use EQUALP rather than EQ, that works - thanks!

Actually, I take it back - this works on CLISP where I tried it first,
but not on SBCL.  Dang!

> > Ah - yes! =A0If I use EQUALP rather than EQ, that works - thanks!
> Actually, I take it back - this works on CLISP where I tried it first,
> but not on SBCL. =A0Dang!

To support both (TEST :ARG T) and (TEST :ARG 'T) calls, on CLISP
all I had to do was:

(defmacro test (&key arg)
  (when (equalp arg 't) (setq arg (gensym)))
  ...

Whereas on SBCL I had to do:

(defmacro test (&key arg)
  (when (or (eq 't arg)
            (equalp '(quote t) arg)) (setq arg (gensym)))
  ...

Which does NOT work the same way on CLISP...  So now it's working, but
what is the closest to the Common Lisp standard behaviour???

BTW, my gut really hurts now!!!  ;->

On Dec 2, 4:45=A0pm, fortunatus <daniel.elia...@excite.com> wrote:
> > > Ah - yes! =A0If I use EQUALP rather than EQ, that works - thanks!
> > Actually, I take it back - this works on CLISP where I tried it first,
> > but not on SBCL. =A0Dang!
>
> To support both (TEST :ARG T) and (TEST :ARG 'T) calls, on CLISP
> all I had to do was:
>
> (defmacro test (&key arg)
> =A0 (when (equalp arg 't) (setq arg (gensym)))
> =A0 ...
>
> Whereas on SBCL I had to do:
>
> (defmacro test (&key arg)
> =A0 (when (or (eq 't arg)
> =A0 =A0 =A0 =A0 =A0 =A0 (equalp '(quote t) arg)) (setq arg (gensym)))
> =A0 ...
>
> Which does NOT work the same way on CLISP... =A0So now it's working, but
> what is the closest to the Common Lisp standard behaviour???
>
> BTW, my gut really hurts now!!! =A0;->

Well, T evaluates to itself. So you shouldn't quote it (there isn't
any point).
--------------
from http://sunsite.univie.ac.at/textbooks/cltl/clm/node70.html (CLTL)

[Constant]
t

The value of t is always t.
---------------

It may be that in one implementation T is its own boolean type,
Whereas in another it is actually a symbol which evaluates to itself.

fortunatus <daniel.eliason@excite.com> writes:

Well, of course, the real answer is to learn to use your macro properly
and not invoke it with 'T or 'VAR-NAME either.  In fact, I bet if you
called it with

   (test :arg 'my-variable)

it wouldn't do what you want either.

So pass it the proper arguments, namely unquoted symbols.


> Whereas on SBCL I had to do:
> 
> (defmacro test (&key arg)
>   (when (or (eq 't arg)
>             (equalp '(quote t) arg)) (setq arg (gensym)))
>   ...

But if you insist on ignoring my advice:

This is really the only safe way.  You could also use EQUAL rather than
EQUALP, by the way.  That is because you could be getting either T or
(QUOTE T) as the input.  I'm guessing that CLISP may do some
short-circuiting of reading quoted constants like T, NIL and perhaps
numbers as well.

-- 
Thomas A. Russ,  USC/Information Sciences Institute

tar@sevak.isi.edu (Thomas A. Russ) writes:

> [...] I'm guessing that CLISP may do some
> short-circuiting of reading quoted constants like T, NIL and perhaps
> numbers as well.

Not at all.  It's conformant.


-- 
__Pascal Bourguignon__

On Dec 2, 8:54=A0pm, anonymous.c.lis...@gmail.com wrote:
> Well, T evaluates to itself. So you shouldn't quote it (there isn't
> any point).

Aren't you saying that T evaluates to 'T?  I mean, the expression T
(which is a variable) evaluates to the symbol T (which is a value)?

But then if I quote it, doesn't it (conceptually at least) save the
need to evalutate?

So that by quoting T, I am directly coding the value I wish to have in
the expression at that point.

On Dec 3, 7:38=A0am, p...@informatimago.com (Pascal J. Bourguignon)
wrote:
> t...@sevak.isi.edu (Thomas A. Russ) writes:
>
> > [...] I'm guessing that CLISP may do some
> > short-circuiting of reading quoted constants like T, NIL and perhaps
> > numbers as well.
>
> Not at all. =A0It's conformant.
>
> --
> __Pascal Bourguignon__


Is the SBCL behaviour also conformant?

daniel.eliason@excite.com writes:

> On Dec 3, 7:38�am, p...@informatimago.com (Pascal J. Bourguignon)
> wrote:
>> t...@sevak.isi.edu (Thomas A. Russ) writes:
>>
>> > [...] I'm guessing that CLISP may do some
>> > short-circuiting of reading quoted constants like T, NIL and perhaps
>> > numbers as well.
>>
>> Not at all. �It's conformant.
>
> Is the SBCL behaviour also conformant?

Yes of course.  There's no difference in behavior; when you pass 1 to
a macro, you get 1, when you pass '1 you get '1.


[pjb@simias :0.0 ~]$ clall '(defmacro m (arg) `(list (type-of (quote ,arg)) (quote ,arg)))' '(values (m t) (m (quote t)) (m 1) (m (quote 1)))'


========================================================================
CLISP 2.43 (2007-11-18) (built 3414750461) (memory 3414750593) 


Evaluation of
(DEFMACRO M (ARG) `(LIST (TYPE-OF ',ARG) ',ARG))
produced nothing on *STANDARD-OUTPUT*
produced nothing on *ERROR-OUTPUT*
produced no error
produced the following vals:
--> M


Evaluation of
(VALUES (M T) (M 'T) (M 1) (M '1))
produced nothing on *STANDARD-OUTPUT*
produced nothing on *ERROR-OUTPUT*
produced no error
produced the following vals:
--> (BOOLEAN T) ;
    (CONS 'T) ;
    (BIT 1) ;
    (CONS '1)

; loading system definition from
; /usr/share/common-lisp/systems/asdf-binary-locations.asd into
; #<PACKAGE "ASDF0">
; registering #<SYSTEM ASDF-BINARY-LOCATIONS {100273BDB1}> as
; ASDF-BINARY-LOCATIONS

========================================================================
SBCL 1.0.14-gentoo 


Evaluation of
(DEFMACRO M (ARG) `(LIST (TYPE-OF ',ARG) ',ARG))
produced nothing on *STANDARD-OUTPUT*
produced nothing on *ERROR-OUTPUT*
produced no error
produced the following vals:
--> M


Evaluation of
(VALUES (M T) (M 'T) (M 1) (M '1))
produced nothing on *STANDARD-OUTPUT*
produced nothing on *ERROR-OUTPUT*
produced no error
produced the following vals:
--> (BOOLEAN T) ;
    (CONS 'T) ;
    (BIT 1) ;
    (CONS '1)


========================================================================
GNU Common Lisp (GCL) GCL 2.6.7 


Evaluation of
(DEFMACRO M (ARG)
  (LIST 'LIST (LIST 'TYPE-OF (LIST 'QUOTE ARG)) (LIST 'QUOTE ARG)))
produced nothing on *STANDARD-OUTPUT*
produced nothing on *ERROR-OUTPUT*
produced no error
produced the following vals:
--> M


Evaluation of
(VALUES (M T) (M 'T) (M 1) (M '1))
produced nothing on *STANDARD-OUTPUT*
produced nothing on *ERROR-OUTPUT*
produced no error
produced the following vals:
--> (SYMBOL T) ;
    (CONS 'T) ;
    (FIXNUM 1) ;
    (CONS '1)


========================================================================
ECL 0.9j 


Evaluation of
(DEFMACRO M (ARG)
  (SI:QUASIQUOTE (LIST (TYPE-OF '(SI:UNQUOTE ARG)) '(SI:UNQUOTE ARG))))
produced nothing on *STANDARD-OUTPUT*
produced nothing on *ERROR-OUTPUT*
produced no error
produced the following vals:
--> M


Evaluation of
(VALUES (M T) (M 'T) (M 1) (M '1))
produced nothing on *STANDARD-OUTPUT*
produced nothing on *ERROR-OUTPUT*
produced no error
produced the following vals:
--> (BOOLEAN T) ;
    (CONS 'T) ;
    ((INTEGER 1 1) 1) ;
    (CONS '1)


========================================================================

-- 
__Pascal Bourguignon__

On Dec 3, 9:51=A0am, daniel.elia...@excite.com wrote:
> On Dec 2, 8:54=A0pm, anonymous.c.lis...@gmail.com wrote:
>
> > Well, T evaluates to itself. So you shouldn't quote it (there isn't
> > any point).
>
> Aren't you saying that T evaluates to 'T? =A0I mean, the expression T
> (which is a variable) evaluates to the symbol T (which is a value)?
>

No. 't should evaluate to t, but t does not evaluate to 't

> But then if I quote it, doesn't it (conceptually at least) save the
> need to evalutate?

Is quote evaluated? (yes)

>
> So that by quoting T, I am directly coding the value I wish to have in
> the expression at that point.

Imagine a keyword. Would you quote a keyword?
The whole point of the keyword is that you don't have to quote it.

---------------------------------------
An additional complication being that in the lambda of a macro,
things are not evaluated until the return-form.
(i.e. you can pass a symbol to a macro at top level)

ex.

>(defmacro foo (arg)
   (print arg)
 `(print ,arg))

>(foo bar)
BAR
>>> Error: {Determining function in error.}

>>> Error:Unbound variable: BAR
(#<COMPILED-FUNCTION 3:E196> ...)
---------------------------

so what you 'get' with your expansion is:
>(foo 't)    ;what you enter
>(quote t)   ;this print is in your macro expression [code to 'create' the =
form to be expanded]
>T           ; this print is the macro expansion
>T           ;this is what the print statement returns

---------------------------
So you see (eq t (quote t)) doesn't evaluate to t.

On 2008-12-03, Thomas A. Russ <tar@sevak.isi.edu> wrote:
> (QUOTE T) as the input.  I'm guessing that CLISP may do some
> short-circuiting of reading quoted constants like T, NIL and perhaps
> numbers as well.

The expressions (QUOTE T) and T only mean the same thing when they are an
evaluated portion of code.  Reducing one to the other at read time would be
unbelievably broken.