方案宏，我需要每个重复元素的索引号

Question

我正在尝试制作一个类似于 Common Lisp cl-ppcre 库中的 register-groups-bind 的宏。这个想法是，你用组创建一个正则表达式，并给它一个变量列表和要执行的语句。它将每个正则表达式组与其中一个变量绑定，然后使用这些绑定执行语句。例如：

(register-groups-bind 
    (s1 s2 s3) 
    ("(\\w+) +(\\w+) +(\\w+)" "moe  larry  curly")   
    (list s2 s3 s1)) 

这将返回

("larry" "curly" "moe")

。另一个复杂之处是，在变量列表中，您不仅可以指定一个函数来对匹配的字符串运行，而不仅仅是一个变量，例如

(register-groups-bind ((string->number x) ...

这样它就会在将匹配的值绑定到 x 之前对它运行 string->number 。当您指定这样的函数时，您可以指定多个变量，例如：

(string->number x y z)

。

我正在尝试将其设置为创建像这样的 let 绑定：

(let ((s1 (match:substring m 1))
      (s2 (match:substring m 2))
      (s3 (match:substring m 3)))
   ... statements ...

有两件事我不知道如何使用任何计划卫生宏观设施。首先，我如何处理 var 列表可以包含 var 名称的混合，或者包含函数名称和 var 的列表。其次，对于每个 let 绑定，我需要一个序列号来指示要获取哪个正则表达式组。

我可以在 Guile Scheme 中使用 defmacro 来做到这一点，如下所示：

(defmacro regex-group-bind (vars re-match . statements)
    (let* ((bind-var (gensym))
       (converted (convert-var-list vars bind-var)))
     `(let ((,bind-var ,re-match))
        (if (regexp-match? ,bind-var)
          (let (,@converted)
            ,@statements)
          #f))))

Where

convert-var-list 是将 var 列表转换为

let

绑定列表的函数。当我调用

convert-var-list

时，我需要传入包含正则表达式匹配结果的变量。

convert-var-list

的输出示例如下：

scheme@(guile-user)> (define match-var (gensym))
scheme@(guile-user)> (convert-var-list '(foo bar (string->number x y z)) match-var)

$9 = ((foo (match:substring #{ g5228}# 1))
      (bar (match:substring #{ g5228}# 2))
      (x (string->number (match:substring #{ g5228}# 3)))
      (y (string->number (match:substring #{ g5228}# 4)))
      (z (string->number (match:substring #{ g5228}# 5))))
scheme@(guile-user)> 

我希望能够使用卫生宏来做到这一点，并且我假设我可能需要使用

syntax-case

，并且可能仍然有像

convert-var-list

这样的功能，但我不确定这是否是作弊。我需要使用

syntax->datum

和

datum->syntax

才能做到这一点吗？

Answer 1

您可以使用

register-groups-bind

宏来实现

syntax-rules

的Scheme版本，但我认为在

syntax-case

中更好。下面使用一个辅助宏来构建一系列

let

赋值，一次使用给定列表中的一个变量。它具有在匹配组字符串上调用函数并绑定该结果的语法的情况，以及仅用于裸变量名称的情况。不过，它没有

cl-ppcre

变量的

nil

行为，只是跳过将相应的匹配组绑定到任何内容（但添加起来并不困难，使用

#f

代替，因为这个 is 方案） 。这留给读者作为练习，并暗示语法模式可以包含文字值。

(use-modules (ice-9 regex))

(define-syntax rgb-helper
  (lambda (stx)
    (syntax-case stx ()
      ((_ () (transformed ...) match counter regex target-string body ...) ; used up all variable bindings
       #'(let ((match (string-match regex target-string)))
           (when match
             (let (transformed ...) body ...))))
      ((_ ((fn) bindings ...) (transformed ...) match counter regex target-string body ...) ; no more variables to wrap in a function; on to the next binding
       #'(rgb-helper (bindings ...) (transformed ...) match counter regex target-string body ...))
      ((_ ((fn var vars ...) bindings ...) (transformed ...) match counter regex target-string body ...) ; bind a variable to the result of passing the group to a function
       #`(rgb-helper ((fn vars ...) bindings ...)
                     ((var (fn (match:substring match counter))) transformed ...)
                     match #,(+ (syntax->datum #'counter) 1) regex target-string body ...))
      ((_ (var bindings ...) (transformed ...) match counter regex target-string body ...) ; bare variable binding
       #`(rgb-helper (bindings ...)
                     ((var (match:substring match counter)) transformed ...)
                     match #,(+ (syntax->datum #'counter) 1) regex target-string body ...)))))

(define-syntax register-groups-bind
  (lambda (stx)
    (syntax-case stx ()
      ((_ (bindings ...) (regex target-string) body ...)
       #'(rgb-helper (bindings ...) () match 1 regex target-string body ...)))))


;;; examples of use
(write (register-groups-bind (first second third fourth)
                             ("((a)|(b)|(c))+" "abababc")
                             (list first second third fourth)))
(newline)

(write (register-groups-bind (first (string->number a b))
                             ("(.)(.)(.)" "a12")
                             (list first a b)))
(newline)

---

这里的技巧，以及使用

syntax-case

的目的，是每次分配一个变量时，当前匹配组的计数器作为宏扩展的一部分直接递增；一个

syntax-rules

使用相同的基本思想，但是用

#,(+ (syntax->datum #'counter) 1)

替换

(+ counter 1)

位会产生大量

(match:substring match (+ (+ (+ 1 1) 1) 1)

等调用，因为

syntax-rules

不允许您在扩展期间直接执行代码。