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

Quasisyntax



Can quasisyntax be written as a macro in terms of syntax-case? I suspect so, but if not, I would urge its inclusion.

With-syntax often forces one to break apart the natural shape of the
output code, and introduce names (such as rest) that would not be necessary otherwise.

Also, I often find myself writing code fragments like this

  (define (helper bindings body)
    (with-syntax ((bindings bindings)  ; !!
                  (body     body))     ; !!
       (syntax (let bindings body)))

This is bothersome, when quasisyntax instead allows

  (define (helper bindings body)
    (quasisyntax (let #,bindings #, body)))

Also compare

  (define-syntax let-in-order
    (lambda (form)
      (syntax-case form ()
        ((_ ((i e) ...) e0 e1 ...)
         (let f ((ies (syntax ((i e) ...)))
                 (its '()))
           (syntax-case ies ()
             (()            (with-syntax ((its its))
                              (syntax (let its e0 e1 ...))))
             (((i e) . ies) (with-syntax ((rest (f (syntax ies)
                                                   (cons (syntax (i t)) its))))
                              (syntax (let ((t e)) rest))))))))))

with the following, which I find easier to write and read, since now the macro
can follow the structure of the output without the order inversions
required above.

  (define-syntax let-in-order
    (lambda (form)
      (syntax-case form ()
        ((_ ((i e) ...) e0 e1 ...)
         (let f ((ies (syntax ((i e) ...)))
                 (its (syntax ())))
           (syntax-case ies ()
             (()            (quasisyntax (let #,its e0 e1 ...)))
             (((i e) . ies) (quasisyntax
                             (let ((t e))
                               #,(f (syntax ies)
                                    (quasisyntax ((i t) #,@its))))))))))))

Regards
Andre