splicing macros

[Stefan Israelsson Tampe]

Hi all,

This is something fun to implement using ck-macros and
local-syntax-value.

The idea is to patch guile's quasisyntax.scm in ice-9 to implement
splicing of macros. 

If we assume a reader macro #.code  ==> (macro-splicing code), with the
proposed hack I can now write:

  (define-syntax-rule (2x x) (x x))

and

  (define-syntax 4x
     (lambda (x)
        (syntax-case x ()
          ((_ x) #`(#.(2x x) #.(2x x))))))

and

 (define-syntax g (lambda (x) #`(#.(4x 1) #.(4x 2))))

$4 = (1 1 1 1 2 2 2 2)


------------------------------------------------------------
I will assume that you are familliar with th ck macro, included in
recent guile releases or else consider looking it up at

  http://okmij.org/ftp/Scheme/macros.html

It is now quite natural to use his c-append macro to do do the
transformation:
  (a b #.(f x) c d)
 -->
  (ck () (c-append '(a b) (c-append (ck-it '(f x)) '(c d))))

And assuming that ck-it can dispatch the macro (f x) the appending would 
be obvious. The second magic is ck-it, it is defined as

(use-modules (system syntax))

(define-syntax ck-it 
  (lambda (x)
    (syntax-case x (quote)
      ((_ s (quote f))
       (and (identifier? #'f) (eq? (syntax-local-binding #'f) 'macro))
       (call-with-values (lambda () (syntax-local-binding #'f))
         (lambda (m transformer)
           (list #'ck-it #'s (list #'quote (transformer #'f))))))

      ((_ s (quote (quote x))) 
       (list #'ck #'s #'(quote x)))

      ((_ s (quote (f . x)))
       (and (identifier? #'f) (eq? (syntax-local-binding #'f) 'macro))
       (call-with-values (lambda () (syntax-local-binding #'f))
         (lambda (m transformer)
           (list #'ck-it #'s (list #'quote (transformer #'(f . x)))))))
          
      ((_ s f)
       (list #'ck #'s #'f)))))


It will iterativelly apply macros until a non macro sexp is appearing,
To inhibit macro expeansion one need to quote it. This is a bit unclean
because if the macro returns (quote x), x any sexp, it will return x in 
stead. A better solution might be to introduce a special inhibit
macro. Also notice how splicing in already spliced syntaxes works as the
example above works. Another thing to note is how we use
syntax-local-binding to search find the macro transformer and use that
in order to make all this work.

Any thoughts? Should we add ck-it to guile's ck.scm? Should we add
splicing macros? 

/Stefan