Subject: Re: Dynamic unquote ( , )?
From: (Rob Warnock)
Date: Thu, 09 Feb 2006 05:22:24 -0600
Newsgroups: comp.lang.lisp
Message-ID: <>
Eli Gottlieb  <> wrote:
| Rob Warnock wrote:
| > Yup. This is one place where Scheme got it right, IMHO, by at least
| > standardizing the name of the quasiquotation macro and the associated
| > internal syntax markers -- QUASIQUOTE, UNQUOTE, and UNQUOTE-SPLICING --
| >
| > Also, by making QUASIQUOTE an explicit operator ("syntax", but it
| > could have been a macro in CL), it allows the embedding of "implicit
| > quasiquotation" in the forms of *other* wrapper macros, such as are
| > used by the Scheme Shell, for example. [I have written elsewhere
| > (several times) on why the lack of such standarization makes it
| > practically impossible to write a "CL Shell" with Scsh-style syntax.]
| Why couldn't you do similar things in CL?  All a quasiquote does is 
| stand in for explicit list construction!

In CL perhaps [though even there the situation is a little more
complicated than you imply -- it is a stand-in for construction
of a *code* sequence that, when evaluated, will perform an explicit
list construction], but in Scheme the separation between the reader
and the evaluator is complete: *All* the reader does is change the
(respectively); it is the evaluator which "executes" the resulting
QUASIQUOTE forms. And in particular, even though R5RS warns that:

    Unpredictable behavior can result if any of the symbols
    QUASIQUOTE, UNQUOTE, or UNQUOTE-SPLICING appear in positions
    within a <QQ template> otherwise than as described above.

all Scheme systems I have access to allow the reading of "isolated"
or "improperly-nested" UNQUOTE and UNQUOTE-SPLICING subforms, e.g.:

    > (quote (a ,b ,@(c d) e))
    ==> (a (unquote b) (unquote-splicing (c d)) e)

This means that *other* macros besides QUASIQUOTE can use those
forms [albeit by doing a tree walk and interpreting the embedded
UNQUOTE and UNQUOTE-SPLICING subforms], which is what happens in
Scsh, allowing one to write things like this:

    (let ((foo "filename"))   ; RUN is a Scsh macro that does what
      (run (ls -l ,foo)))     ;  might be called "implicit quasiquoting".

    (run (cc ,file ,@flags))  ; Compile FILE with FLAGS.

Unfortunately those are illegal to a standard CL reader, so in a
(hypothetical) "CLsh" the above would have to look like this:

    (let ((foo "filename"))
      (run `(ls -l ,foo)))    ; Note explicit backquote

    (run `(cc ,file ,@flags)) ; (ditto)

This is why I said it's "practically impossible to write a CL Shell
with Scsh-style syntax" [unless you manually add explicit backquotes
at various points].


Rob Warnock			<>
627 26th Avenue			<URL:>
San Mateo, CA 94403		(650)572-2607