Hygienic macro syntax-rules

[jcubic]

Hygienic macro syntax-rules

• Handling of ellipsis.
• Handling identifiers.
• Proper macro expand.
• Ellipsis alias (nested syntax-rules).
• Proper working identifiers
• Matching literal atoms
• Matching symbol as last cdr in pattern
• Spread ellipsis (x ... ...)
• SRFI 46 (named ellipsis)
• vectors
  • pattern
  • template
• objects
  • pattern
  • template
• Example Usage:
  • SRFI 26
  • SRFI 156
  • define-values from R7RS spec
  • SRFI 197
  • SRFI 210
  • SRFI 239
  • R6RS do macro
  • Gauche ellipsis test from (SRFI-149)
• Ellipsis (pattern language) extensions from R7RS
  • Escape ellipsis

List of issues

• Syntax-rules should freeze the scope variables when defined #172
• Hygienic macro can't define a value #170
• Identifiers in syntax-rules can't be shadowed by local variables #291
• You can't define class inside syntax-rules macro #124
• Macro related errors in minikanren #201
• Wrong error messages when invoking macro #243
• Invalid syntax-rules matching when using (_ () var1 ... var2) #244
• Different calls to hygienic macros should create unique hygiene values #288
• define-values doesn't work with dot #290
• let binding should shadow syntax-parameters #293
• identifers from nested syntax-rules macro #296
• Recursive flatten syntax-rules macro crashes NodeJS #304
• Nested syntax rules with escape ellipsis #334

[jcubic]

This macro don't work:

(define-syntax for
  (syntax-rules (in as)
    ((for element in list body ...)
     (map (lambda (element)
            body ...)
          list))
    ((for list as element body ...)
     (for element in list body ...))))

(for '(0 1 2 3 4) as i
     (print i))

Because identifiers are not used to match the pattern. The code try to match first pattern so element is a list.

[jcubic]

for macro is working.

[jcubic]

Example that don't work (taken from SRFI 46)

(let-syntax
    ((f (syntax-rules ()
          ((f ?e)
           (let-syntax
               ((g (syntax-rules ::: ()
                     ((g (??x ?e) (??y :::))
                      '((??x) ?e (??y) :::)))))
             (g (1 2) (3 4)))))))
  (f :::))

it should return ((1) 2 (3) (4)) but it return ((#:??x) 2 (3) (4))

[jcubic]

SRFI 46 example works.

[jcubic]

Two examples that should work:

(define-syntax foo (syntax-rules () ((_ x ...) #(x ...))))
(define-syntax foo (syntax-rules () ((_ #(x y ...)) x)))

There is need to add vector support to syntax-rules.

[jcubic]

Another use case nested ellipsis from practical-scheme.net.

(define-syntax ellipsis-test
  (syntax-rules ()
    [(_ (a (b c ...) ...) ...)
     '((a ...)
       (((a b) ...) ...)
       ((((a b c) ...) ...) ...))]))

(ellipsis-test (1 (2 3 4) (5 6)) (7 (8 9 10 11)))
;; ⇒ ((1 7)
;;    (((1 2) (1 5)) ((7 8)))
;;    ((((1 2 3) (1 2 4)) ((1 5 6))) (((7 8 9) (7 8 10) (7 8 11)))))

NOTE: this is not part of R7RS, can be implemented later.

[jcubic]

While debugging SRFI-197 macro, found another example that doesn't work:

(define-syntax foo
  (syntax-rules ()
    ((_)
     (let ()
       (define-syntax %foo
         (syntax-rules (foo bar)
           ((_ (foo))
            (display "foo"))
           ((_ x)
            (display 'x))))
       (%foo (10))))))

(foo)

should print (10). The problem here are collisions of _ ==> foo in outer syntax that maps into nested _ which is also the name of the identifier. Changing the identifier from foo to foo_ or nested _ to __ solves the issue.

This one case can be fixed by not matching the first expression in the pattern to identifiers.

Also this:

(define-syntax foo
  (syntax-rules ()
    ((_)
     (let ()
       (define-syntax %foo
         (syntax-rules (foo bar)
           ((__ (foo))
            (print '(foo)))
           ((__ x)
            (print 'x))))
       (%foo (foo)))))

prints: (#:foo) instead of (foo).

[jcubic]

The problem with SRFI-210 is not about hygiene:

This works fine:

(define-syntax foo
  (syntax-rules ()
    ((_ () ((operand1 arg1) ...))
     (let ((arg1 operand1) ...)
       (list arg1 ...)))
    ((_ (operand1 operand2 ...) (temp ...))
     (foo (operand2 ...) (temp ... (operand1 arg1))))))


(pprint (macroexpand (foo (10 20) ())))
;; (#:let ((#:arg1 10)
;;         (#:arg1 20))
;;      (#:list #:arg1 #:arg1))
(print (foo (10 20) ()))
;; => (10 20)

[jcubic]

The problem was that identifiers in syntax-rules were checking the scope if they were not shadowed, but this was wrong. So the code was removed and the unit test updated.

[jcubic]

Another problem found from SRFI-210 is this macro:

(define-syntax foo
  (syntax-rules ()
    ((_ (arg more ...))
     (letrec-syntax ((aux (syntax-rules ::: ()
                            ((aux () ((operand1 arg1) :::))
                             (let ((arg1 operand1) :::)
                               (list arg1 :::)))
                            ((aux (operand1 operand2 :::) (temp :::))
                             (aux (operand2 :::) (temp ::: (operand1 arg1)))))))
       (aux (arg more ...) ())))))

(print (foo (10 20)))
;; ==> (20 20)

Same code with single a syntax-rules works fine.

[jcubic]

This is the limitation of renaming syntax-rules, I don't think I can fix this. Inside nested syntax rules everything got renamed including nested syntax-rules so arg1 is renamed before the macro is expended and it got one value.

The whole syntax-rules need to be refactored into a proper scope based system.