a Q on syntax-rules vs syntax-case

a Q on syntax-rules vs syntax-case

[Matt Wette]

I want to use macros inside a let which is part of an expansion of a top-level macro in order to have local bindings visible to macros. 

Is there a difference in implementation (e.g., when inside macros get expanded) between using syntax-rules versus syntax-case at the top level.   Is this coding considered OK?

(define-syntax foo
  (lambda (x)
    (syntax-case x ()
      ((_ <e>)
       #'(let* ((v (cons 'a #f))
		(doit (lambda (x) (set-cdr! v x))))
	   (letrec-syntax
	       ((foo-1 (syntax-rules ()
			 ((_ <v>)
			  (doit '<v>)))))
	     (foo-1 <e>))
	   v)))))

(define-syntax bar
  (syntax-rules ()
    ((_ <e>)
     (let* ((v (cons 'a #f))
	    (doit (lambda (x) (set-cdr! v x))))
       (letrec-syntax
	   ((foo-1 (syntax-rules ()
		     ((_ <v>)
		      (doit '<v>)))))
	 (foo-1 <e>))
       v))))

(foo 1) => (a . 1)
(bar 1) => (a . 1)

Re: a Q on syntax-rules vs syntax-case

[Mark H Weaver]

Hi Matt,

Matt Wette <mwette@alumni.caltech.edu> writes:
> I want to use macros inside a let which is part of an expansion of a
> top-level macro in order to have local bindings visible to macros.

Okay, that's fine.

> Is there a difference in implementation (e.g., when inside macros get
> expanded) between using syntax-rules versus syntax-case at the top
> level.

No.  'syntax-rules' is actually just a normal macro that expands into an
equivalent 'syntax-case' form.  Guile's implementation is made more
complex by the presence of features such as docstrings, procedure
metadata, custom ellipses, and R7RS 'syntax-error' support, but if you
strip away those extra features, it looks like this:

  (define-syntax syntax-rules
    (lambda (form)
      (syntax-case form ()
        ((_ (k ...) ((keyword . pattern) template) ...)
         #'(lambda (x)
             (syntax-case x (k ...)
               ((dummy . pattern) #'template)
               ...))))))

> Is this coding considered OK?

Yes, absolutely.  It's fully supported.

  Happy hacking!
      Mark

Re: a Q on syntax-rules vs syntax-case

[Matt Wette]

Thanks Mark.   

I did make progress on this.  I also discovered that I need to use the optional specification of ellipses (i..e, :::) in the top-level macro to avoid clash with ellipses in the letrec-syntax part.

For information, the project is an LALR parser generator which has a Scheme flavor for specifying grammars.   There is no need to declare tokens: the macro uses a fender to differentiate non-terminals (e.g., expr) from terminals (e.g., 'float, #\+).   The code turns out to be pretty clean and compact, I believe.  I plan to use the local bindings to provide macros for common patterns (e.g., ($opt 'const) int =>  opt-1 'int ,  (opt-1 () ('const)). 

Matt

(define spec0
  (lalr2-spec
   (start expr)
   (grammar
    (expr
     (expr #\+ term ($action (+ $1 $3)))
     (expr #\- term ($action (- $1 $3)))
     (term))
    (term
     (term #\* factor ($action (* $1 $3)))
     (term #\/ factor ($action (/ $1 $3)))
     (factor))
    (factor ('integer) ('float))
    )))