4

我有一个宏在传递一个参数时工作，我想扩展它以使用 ... 接受 n 个参数，但我无法弄清楚语法。

该宏要么接受自定义语法，即key:val key:val，要么接受一个过程。

例如：（3种不同的用法）

(schema-properties [(name:first-name type:string)])
(schema-properties [(name:age type:number required:#t)])
(schema-properties [(my-custom-fn arg1 arg2 arg3)])

定义：

(define-syntax (schema-properties stx)
  (syntax-parse stx
    [(_ [(prop:expr ...)])
     (with-syntax ([prop0 (make-prop-hash #'(prop ...))])
       #'(list prop0))]))

(define-for-syntax (make-prop-hash stx)
  (with-syntax ([(props ...) stx])
    (if (regexp-match #px":"
                      (symbol->string (car (syntax->datum #'(props ...)))))
        #'(pairs->hash 'props ...)
        #'(props ...))))

这是有效的，因为它检查 prop:expr 语法是否存在“：”，如果存在，则将其传递给函数（pairs->hash 'props ...），否则，它只是调用它（props ...）。

现在，我希望能够通过：

(schema-properties [(name:first-name type:string)
                    (name:last-name type:string)
                    (my-fn arg1 arg2 arg3)])

并让它以同样的方式工作。但我目前处于省略号地狱中，我的大脑不再正常工作。

任何见解都值得赞赏。

4

2 回答 2

4

建议：使用辅助函数来帮助处理嵌套。您的schema-properties宏知道如何处理一层嵌套，并且您希望将其应用于多个子句。这与我们处理事物列表时的原则相同：有一个助手来处理事物，然后将其应用于您的列表。它有助于降低复杂性。

对于您的代码，我们可以这样做：

#lang racket
(require (for-syntax syntax/parse))

(define-syntax (schema-properties stx)
  (syntax-parse stx
    [(_ [clause ...])
     (with-syntax ([(transformed-clauses ...)
                    (map handle-clause (syntax->list #'(clause ...)))])
       #'(list transformed-clauses ...))]))


;; handle-clause: clause-stx -> stx
(define-for-syntax (handle-clause a-clause)
  (syntax-parse a-clause
    [(prop:expr ...)
     (make-prop-hash #'(prop ...))]))


(define-for-syntax (make-prop-hash stx)
  (with-syntax ([(props ...) stx])
    (if (regexp-match #px":"
                      (symbol->string (car (syntax->datum #'(props ...)))))
        #'(pairs->hash 'props ...)
        #'(props ...))))


;;; Let's try it out.  I don't know what your definition of pairs->hash is,
;;; but it probably looks something like this:
(define (pairs->hash . pairs)
  (define ht (make-hash))
  (for ([p pairs])
    (match (symbol->string p)
      [(regexp #px"([-\\w]+):([-\\w]+)" 
               (list _ key value))
       (hash-set! ht key value)]))
  ht)

(schema-properties [(name:first-name type:string)
                    (name:last-name type:string)
                    (list 1 2 3)])
于 2013-04-17T20:33:00.903 回答
4

另一个建议：使用语法类来帮助处理嵌套：

首先，定义一个可以识别 key:value 标识符的语法类（并使它们的组件字符串可用作key和value属性）：

(begin-for-syntax
  (define-syntax-class key-value-id
    #:attributes (key value)
    (pattern x:id
             #:do [(define m (regexp-match "^([^:]*):([^:]*)$" 
                                           (symbol->string (syntax-e #'x))))]
             #:fail-unless m #f
             #:with (_ key value) m)))

现在将一个子句定义为这些序列的序列（以一种方式处理）或其他任何东西（被视为一个表达式，它必须产生一个过程）。该code属性包含每种子句的解释。

(begin-for-syntax
  (define-syntax-class clause
    #:attributes (code)
    (pattern (x:key-value-id ...)
             #:with code #'(make-immutable-hash '((x.key . x.value) ...)))
    (pattern proc
             #:declare proc (expr/c #'(-> any))
             #:with code #'(proc.c))))

现在宏只是将各个部分放在一起：

(define-syntax (schema-properties stx)
  (syntax-parse stx
    [(_ [c:clause ...])
     #'(list c.code ...)]))
于 2013-04-17T22:21:27.347 回答