[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: How many arguments to a macro transformer?



On Tue, 9 Aug 2005, Keith Wright wrote:

This revision is more than a trival change.  It seems to me
that it would be a good idea to extend the discussion period
to give more time to think about it.

I certainly agree that discussion is not finished and I will request an extension from the editor.

MzScheme also has two procedures called |datum->syntax-object|
and |syntax-object->datum|.  These conflict with your newly
renamed  |datum->syntax| and |syntax->datum|.  I don't know
why you changed the names, but it is a conflict, not a
compatibility, because the MzScheme syntax objects are not
lists and can not be accessed with |car| and |cdr|.

It seems unlikely that programs written to work with the
MzScheme system that used these procedures could run unchanged
on the SRFI system or vice-versa---the data types are completely
different!

Although, as long as you don't use |car|, |cdr|, etc., and just use syntax-case with the pattern matching idiom described in the syntax-case papers, you can ignore the difference. One may therefore, if one wishes, regard the fact that syntax objects are lists as an irrelevant implementation detail, and stick with a purely portable programming style, which the shorter names datum->syntax would prevent.

I must say that I personally also like the shorter datum->syntax better. However, with the longer version, /pure/ "portable syntax-case" macros will be portable between the canonical Chez implementation and the system described here. For example, the macros |loop| and |include| on

 http://www.scheme.com/csug/syntax.html#g2138

will work unmodified with this SRFI. I believe that they will also work unmodified on MzScheme.

As an aside, the canonical Chez implementation does allow |car| and |cdr| in some situations. See, on the above page, the uses of (car cmore) and (cdr cmore) and also (null? cmore):

(define-syntax cond
  (lambda (x)
    (syntax-case x ()
      ((_ c1 c2 ...)
       (let f ((c1 (syntax c1)) (cmore (syntax (c2 ...))))
         (if (null? cmore)
             (syntax-case c1 (else =>)
               ((else e1 e2 ...) (syntax (begin e1 e2 ...)))
               ((e0) (syntax (let ((t e0)) (if t t))))
               ((e0 => e1) (syntax (let ((t e0)) (if t (e1 t)))))
               ((e0 e1 e2 ...) (syntax (if e0 (begin e1 e2 ...)))))
             (with-syntax ((rest (f (car cmore) (cdr cmore))))
               (syntax-case c1 (=>)
                 ((e0) (syntax (let ((t e0)) (if t t rest))))
                 ((e0 => e1) (syntax (let ((t e0)) (if t (e1 t) rest))))
                 ((e0 e1 e2 ...)
                  (syntax (if e0 (begin e1 e2 ...) rest)))))))))))

(However, Chez does not allow this on all syntax objects, which is confusing. Also, this macro will not work on MzScheme.)

Cheers
Andre