Grammars

Grammars - 一组具名 regexes 组成正式的 grammar

Grammars 是一个很强大的工具用于析构文本并通常返回数据结构。

例如, Raku 是使用 Raku 风格 grammar 解析并执行的。

对普通 Raku 使用者更实用的一个例子是 JSON::Tiny模块, 它能反序列化任何合法的 JSON 文件, 而反序列代码只有不到 100 行, 还能扩展。

Grammars 允许你把 regexes 组织到一块儿, 就像类(class) 中组织方法那样。

具名正则 (Named Regexes)

　 grammars 的主要组成部分是 regexes。 而 Raku 的 regexes语法不在该文档的讨论范围, 具名正则(named regexes) 有它自己的特殊语法, 这跟子例程(subroutine) 的定义很像:

my regex number { \d+ [ \. \d+ ]?   }   # 普通 regex 中空格被忽略, [] 是非捕获组

上面的代码使用 my 关键字指定了本地作用域的 regex, 因为具名正则(named regexes) 通常用在 grammars 里面。

正则有名字了就方便我们在任何地方重用那个正则了:

say "32.51" ~~ &number;
say "15 + 4.5" ~~ /  \s* '+' \s*  /
&number           # my regex number { \d+ [ \. \d+ ]?   }

为什么用 &number, 对比具名子例程你就知道了:

> sub number { say "i am a subroutine" }  # 具名子例程
> &number                                 # sub number () { #`(Sub|140651249646256) ... }

&number 就是直接引用了具名的 regex 或 子例程。而在`/ /` 或 grammars 里面, 引用一个具名正则的语法也很特殊, 就是给名字包裹上 < >。<> 就像引号那样, 当用它引起某个具名正则后, 引用这个 `` 就会把该具名正则插入(带入)到整个正则之中, 就像字符串插值那样：

use v6;
# 具名正则的声明
my regex number { \d+ [ \. \d+]? }
my token ident  { \w+            }
my rule  alpha  { <[A..Za..z]>   }
# 1.0 通过 & 来引用
say so "12.34" ~~ &number; # true
# 2.0 在正则构造 // 里使用
say so "12.88 + 0.12" ~~ /  \s* '+' \s*  /; # true
# say so "12.88 + 0.12" ~~ /  \s* '+' \s*  /;
# wrong, method 'number' not found for invocant of class 'Cursor'
# 3.0 在 grammar 里面使用
grammar EquationParse {
    # 这里也不能给 number 起别名, 除非 number 是在 grammar 内部声明的
     token TOP {  \s* '+' \s*  \s* '=' \s*  }
}
# 等式解析
my $expr = EquationParse.parse("12.88 + 0.12 = 13.00");
say $expr;

声明具名正则不是只有一个 regex 声明符, 实际上 , regex 声明符用的最少, 大多数时候, 都是使用 token 或 rule 声明符。token 和 rule 这两个都是 ratcheing (棘轮)的, 这意味着如果匹配失败, 那么匹配引擎就不会回并尝试匹配了。这通常会是你想要的, 但不适用于所有情况:

棘轮用于单向驱动, 防止逆转。

my regex works-but-slow { .+ q } # 可能会回溯
my token fails-but-fast { .+ q } # 不回溯
my $s = 'Tokens and rules won\'t backtrack, which makes them fail quicker!';
say so $s ~~ &works-but-slow; # True
say so $s ~~ &fails-but-fast; # False, .+ 得到了整个字符串但不回溯

`token` 和 `rule` 的唯一区别就是 `rule` 声明符会让正则中的 `:sigspace` 修饰符起效:

my token non-space-y { 'once' 'upon' 'a' 'time' }
my rule space-y { 'once' 'upon' 'a' 'time' }
say 'onceuponatime'    ~~ &non-space-y;
say 'once upon a time' ~~ &space-y;

创建 Grammar

　 当使用 grammar 关键字而非 class 关键字声明来声明一个类时, 会自动得到以 Grammar 的父类。Grammars 应该只用于解析文本; 如果你想提取复杂的数据, 推荐 action object和 grammar 一块使用。

Proto regexes

Grammars 由 rules，token 和 regexes 组成; 他们实际上是方法，因为 grammars 是类。这些方法可以共享一个共同的名称和功能，因此可以使用 proto。

如果你有很多备选分支(alternations), 那么生成可读性好的代码或子类化(subclass)你的 grammar 可能会变得很困难。在下面的 Actions 类中, TOP 方法中的三元操作符并不理想, 并且当我们添加的操作越多, 它就变得越糟糕:

grammar Calculator {
    token TOP { [ <add> | <sub> ] }
    rule  add { <num> '+' <num> }
    rule  sub { <num> '-' <num> }
    token num { \d+ }
}
class Calculations {
    method TOP ($/) { make $<add> ?? $<add>.made !! $<sub>.made; }
    method add ($/) { make [+] $<num>; }
    method sub ($/) { make [-] $<num>; }
}
say Calculator.parse('2 + 3', actions => Calculations).made;
# OUTPUT:
# 5

为了让事情变得更好, 我们可以在 tokens 身上使用看起来像 :sym<…​> 那样的副词来使用正则表达式原型(protoregexes):

grammar Calculator {
    token TOP { <calc-op> }
    proto rule calc-op          {*}
          rule calc-op:sym<add> { <num> '+' <num> }
          rule calc-op:sym<sub> { <num> '-' <num> }
    token num { \d+ }
}
class Calculations {
    method TOP              ($/) { make $<calc-op>.made; }
    method calc-op:sym<add> ($/) { make [+] $<num>; }
    method calc-op:sym<sub> ($/) { make [-] $<num>; }
}
say Calculator.parse('2 + 3', actions => Calculations).made;
# OUTPUT:
# 5

在这个 grammar 中, 备选分支(alternation)已经被 <calc-op> 替换掉了, 它实质上是我们将要创建的一组值的名字。我们通过使用 proto rule calc-op 定义了一个 rule 原型类型(prototype) 来达成。我们之前的每一个备选分支已经被新的 rule calc-op 替换掉了并且备选分支的名字被附加上了 :sym<> 副词。

在 actions 类中, 我们现在摆脱了三目操作符, 仅仅只在 $<calc-op> 匹配对象上接收 .made 值。并且单独备选分支的 actions 现在和 grammar 遵守相同的命名模式: method calc-op:sym<add> 和 method calc-op:sym<sub>。

当你子类化(subclass)那个 grammar 和 actions 类的时候才能看到这个方法的真正魅力。假设我们想为 calculator 增加一个乘法功能:

grammar BetterCalculator is Calculator {
    rule calc-op:sym<mult> { <num> '*' <num> }
}
class BetterCalculations is Calculations {
    method calc-op:sym<mult> ($/) { make [*] $<num> }
}
say BetterCalculator.parse('2 * 3', actions => BetterCalculations).made;
# OUTPUT:
# 6

所有我们需要添加的就是为 calc-op 组添加额外的 rule 和 action, 感谢正则表达式原型(protoregexes), 所有的东西都能正常工作。

特殊的 Tokens

TOP

grammar Foo {
    token TOP { \d+ }
}

The TOP token is the default first token attempted to match when parsing with a grammar—the root of the tree. Note that if you’re parsing with .parse method, token TOP is automatically anchored to the start and end of the string (see also: .subparse).

TOP token 是默认的第一个尝试去匹配的 token , 当解析一个 grammar 的时候 - 那颗树的根。注意如果你正使用 .parse 方法进行解析, 那么 token TOP 被自动地锚定到字符串的开头和结尾(再看看 .subparse)。

使用 rule TOP 或 regex TOP 也是可以接受的。

在 .parse、.subparse 或 .parsefile Grammar 方法中使用 :rule 命名参数可以选择一个不同的 token 来进行首次匹配。

ws

当使用 rule 而非 token 时, 原子(atom)后面的任何空白(whitespace)被转换为一个对 ws 的非捕获调用。即:

rule entry { <key> ’=’ <value> }

等价于:

token entry { <key> <.ws> ’=’ <.ws> <value> <.ws> } # . = non-capturing

默认的 ws 匹配”空白”(whitespace), 例如空格序列(不管什么类型)、换行符、unspaces、或 heredocs。

提供你自己的 ws token 是极好的:

grammar Foo {
    rule TOP { \d \d }
}.parse: "4   \n\n 5"; # Succeeds
grammar Bar {
    rule TOP { \d \d }
    token ws { \h*   }
}.parse: "4   \n\n 5"; # Fails

上面的例子中, 在 Bar Gramamr 中重写了自己的 ws, 只匹配水平空白符, 所以 \n\n 匹配失败。

sym

<sym> token 可以在原型正则表达式(proto regex) 中使用，以匹配那个特定正则表达式的 :sym 副词的字符串值：

grammar Foo {
    token TOP { <letter>+ }
    proto token letter {*}
    token letter:sym<P> { <sym> }
    token letter:sym<e> { <sym> }
    token letter:sym<r> { <sym> }
    token letter:sym<l> { <sym> }
    token letter:sym<*> {   .   }
}.parse("I ♥ Perl", actions => class {
    method TOP($/) { make $<letter>.grep(*.<sym>).join }
}).made.say; # OUTPUT: «Perl
»

当你已经将原型正则表达式与要匹配的字符串区分开来时，这很方便，因为使用 <sym> token 可防止重复这些字符串。

总是成功断言

<?> is the always succeed assertion(总是匹配成功). 当它用作 grammar 中的 token 时, 它可以被用于触发一个 Action 类方法。在下面的 grammar 中, 我们查找阿拉伯数字并且使用 always succeed assertion 定义一个 succ token。

在 action 类中, 我们使用对 succ 方法的调用来设置(在这个例子中, 我们在 @!numbers 中准备了一个新元素)。在 digit 方法中, 我们把阿拉伯数字转换为梵文数字并且把它添加到 @!numbers 数组的最后一个元素中。多亏了 succ, 最后一个元素总是当前正被解析的 digit 数字的数。

grammar Digifier {
    rule TOP {
        [ <.succ> <digit>+ ]+
    }
    token succ   { <?> }
    token digit { <[0..9]> }
}
class Devanagari {
    has @!numbers;
    method digit ($/) { @!numberslink:2358[*-1] ~= $/.ord.&[+].chr }
    method succ  ($)  { @!numbers.push: ''     }
    method TOP   ($/) { make @!numbers[^(*-1)] }
}
say Digifier.parse('255 435 777', actions => Devanagari.new).made;
# OUTPUT:
# (२५५ ४३५ ७७७)

Grammar 中的方法

在 grammar 中使用 method 代替 rule 或 token 也是可以的, 只要它们返回一个 Cursor 类型:

grammar DigitMatcher {
    method TOP (:$full-unicode) {
        $full-unicode ?? self.num-full !! self.num-basic;
    }
    token num-full  { \d+ }
    token num-basic { <[0..9]>+ }
}

上面的 grammar 会根据 parse 方法提供的参数尝试不同的匹配:

say +DigitMatcher.subparse: '12७१७९०९', args => \(:full-unicode);
# OUTPUT:
# 12717909
say +DigitMatcher.subparse: '12७१७९०९', args => \(:!full-unicode);
# OUTPUT:
# 12

Action Object

　 一个成功的 grammar 匹配会给你一棵匹配对象(Match objects)的解析树, 匹配树(match tree)到达的越深, 则 grammar 中的分支越多, 那么在匹配树中航行以获取你真正感兴趣的东西就变的越来越困难。

为了避免你在匹配树(match tree)中迷失, 你可以提供一个 action object。grammar 中每次解析成功一个具名规则(named rule)之后, 它就会尝试调用一个和该 grammar rule 同名的方法, 并传递给这个方法一个`Match` 对象作为位置参数。如果不存在这样的同名方法, 就跳过。

这儿有一个例子来说明 grammar 和 action：

use v6;
grammar TestGrammar {
    token TOP { ^ \d+ $ }
}
class TestActions {
    method TOP($/) {
        $/.make(2 + $/);  # 等价于 $/.make: 2 + $/
    }
}
my $actions = TestActions.new; # 创建 Action 实例
my $match   = TestGrammar.parse('40', :$actions);
say $match;       # ｢40｣
say $match.made;  # 42

TestActions 的一个实例变量作为具名参数 actions 被传递给 parse 调用, 然后当 token TOP 匹配成功之后, 就会自动调用方法 TOP, 并传递匹配对象(match object) 作为方法的参数。

为了让参数是匹配对象更清楚, 上面的例子使用 $/ 作为 action 方法的参数名, 尽管那仅仅是一个方便的约定, 跟内在无关。 $match 也可以。(尽管使用 $/`可以提供把 `$`作为$/`的缩写的优势。)

下面是一个更有说服力的例子:

use v6;
grammar KeyValuePairs {
    token TOP {
        [<pair> \n+]*
    }
    token ws {
        \h*
    }
    rule pair {
        <key=.identifier> '=' <value=.identifier>
    }
    token identifier {
        \w+
    }
}
class KeyValuePairsActions {
    method pair      ($/) {
        $/.make: $<key>.made => $<value>.made
    }
    method identifier($/) {
        # 子例程 `make` 和在 $/ 上调用 .make 相同
        make ~$/
    }
    method TOP ($match) {
        # TOP 方法的参数可以使用任意变量名, 而不仅仅是 $/
        $match.make: $match<pair>».made
    }
}
my $res = KeyValuePairs.parse(q:to/EOI/, :actions(KeyValuePairsActions)).made;
    second=b
    hits=42
    perl=6
    EOI
for @$res -> $p {
    say "Key: $p.key()\tValue: $p.value()";
}

这会输出:

Key: second     Value: b
Key: hits       Value: 42
Key: perl       Value: 6

pair 这个 rule, 解析一对由等号分割的 pair, 并且给 identifier 这个 token 各自起了别名。对应的 action 方法构建了一个 Pair 对象, 并使用子匹配对象(sub match objects)的 .made 属性。这也暴露了一个事实: submatches 的 action 方法在那些调用正则/外部正则之前就被调用。所以 action 方法是按后续调用的。

名为 TOP 的 action 方法仅仅把由 pair 这个 rule 的多重匹配组成的所有对象收集到一块, 然后以一个列表的方式返回。

注意 KeyValuePairsActions 是作为一个类型对象(type object)传递给方法 `parse`的, 这是因为 action 方法中没有一个使用属性(属性只能通过实例来访问)。

其它情况下, action 方法可能会在属性中保存状态。 那么这当然需要你传递一个实例给 parse 方法。

注意, token ws 有点特殊: 当 :sigspace 开启的时候(就是我们使用 rule`的时候), 我们覆写的 `ws 会替换某些空白序列。这就是为什么 rule pair 中等号两边的空格解析没有问题并且闭合 } 之前的空白不会狼吞虎咽地吃下换行符, 因为换行符在 TOP token 已经占位置了, 并且 token 不会回溯。

# ws 的内置定义
/ <.ws> /                # match "whitespace":
                         #   \s+ if it's between two \w characters,
                         #   \s* otherwise
> my token ws { \h* } # 重写 ws 这个内置的 token
> say so "\n" ~~ &ws # True

所以 <.ws> 内置的定义是：如果空白在两个 \w 单词字符之间, 则意思为 \s+, 否则为 \s*。 我们可以重写 ws 关于空白的定义, 重新定义我们需要的空白。比如把 ws 定义为 { \h* } 就是所有水平空白符, 甚至可以将`ws` 定义为非空白字符。例如: token ws { 'x' }