就像这样：

//! StrictLanguage
def fizzBuzz(rng: Range = 1...100)
  for n in rng match n
    1: _ |*| 3 + 0 => cout << "Fizz " << n
    2: _ |*| 5 + 0 => cout << "Buzz " << n
    1: & 2: => print "FizzBuzz " << n

要是我的 GalScript 反向模式匹配真的可以写出来，就可以这么写了

match [*'®'.repeat(rc), *'©'.repeat(cc)] = "®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®©©©©©©©©©©©©©©©©©©©©©©©©"

println("(R): ", rc) println("(C):", cc)

不过这是不可能的，因为我还没打算支持方法调用参数的反向模式匹配...

目前只能反向模式匹配 self，不能反向参数，所以只能

match [*rc.timesStr('®'), *cc.timesStr('©')] = "®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®©©©©©©©©©©©©©©©©©©©©©©©©"

而且也没有重复 repeat pattern，只有 ES6 的 expand operator

就像这样：

//! StrictLanguage
def fizzBuzz(rng: Range = 1...100)
  for n in rng match n
    1: _ |*| 3 + 0 => cout << "Fizz " << n
    2: _ |*| 5 + 0 => cout << "Buzz " << n
    1: & 2: => print "FizzBuzz " << n

我这周打算给 GeekApk 未来的脚本系统设计的一门多范式编程语言，支持编译到 Java/ES5/ES6 和利用 GalVM 虚拟机解释

而且这货还支持 implicit、cross inlined definition（不过 implicit 参数只能查找调用的一层作用域和 object instance ）

语言总体主要是面向对象和函数式（此外也有点过程式和描述式的感觉），支持 rewrite 尾递归重写、渐进类型支持 type patterns（多态），此外它还支持反向模式匹配（match n+1 = 2 这种）
不太支持参数化类型（没有用户自定义的），但有函数类型、Map 类型什么的

实现的难点在学校里已经考虑过了，我觉得是时间问题

难点一方面在解析器上，它是 2D syntax，支持缩进语义所以非常灵活
一方面是在新的 reverse pattern matching 上面，我下了好大功夫设计，而且还很难实现（但是一些基础的 reverse pattern 不难实现）

譬如上面那个 match x + 1 = n 这个，n=1
此时解释实现需构造一个 MixPattern 对象 MixPattern(+1, Unknown("x")) 就可以了，它接受一个输入，然后把输入 -1 交给 Unknown("x") 匹配，就可以得到一个副作用，执行完就有了未知数 x 的值

另外一个实现问题就是 reverse method call pattern 可以从参数和返回值推导回 self，可是 self 的类型是什么？如果把实现调用接口的类型一个一个排除就太 inefficient 了

这就必须使用 1. 显示类型标记声明了但是没有定义的变量 2. is pattern，这个 pattern 断言了未知数一定是某个类型，就可以确定反向计算的接受者(receiver) 类型了（从而可以拿到对应 match 方法的实现进行反向计算）

match s.repace("aaa", "bbb") = "xbbb"

// Inefficient

match (s is Str).repace("aaa", "bbb") = "xbbb"

// OK

val s: Str
match s.repace("aaa", "bbb") = "xbbb"

// OK

可是这就意味着 reverse pattern matching 的某些组合需要参考它子项目的属性，而且必须是有传递性的（因为不能保证永远是 (s is Str), (s is Str + 'a') 也是一样...）
这个我还没想好....

目前需要这个功能的好像还只有 reverse method call pattern 一个，我觉得大概可以在解析类型推导的时候解决

GalScript 里有函数和方法的区分，但是目前不打算支持函数的反向模式匹配... 因为函数没有隐式的 self 参数，就必须可以这么干了

let add(x, 1) = 2
let sub(x, -2) = 1

可是这很麻烦（特别是对应的 match operator fn 实现起来... 它得知道啥是未知啥是已知。我有办法（implicit & match fn）可是我觉得很鸡肋 ），而且 GalScript 又不是确切的逻辑式语言，支持部分反向计算本意是作为 Pattern matching 的扩充，这样的话对 GalScript 不好

... 算了，我还是不支持 first-class pattern 的 custom match operator，然后支持 implicit 参数的 match operator fn 的推导算了...
就像这样：

class Str kind [char]
  match operator fn repeat where
    (implicit self, n: Nat)(it: Str) { self = it.take(n)[0..findSeqLength] } // 注意这不是 scala 的 currying 表示，()() 只是分割不同类型参数的语法糖....
    (self, implicit n: Nat)(it: Str) { n = it.substrTakeWhile(self::startsWith).size }
    fn findSeqLength(implicit it: Str) {...}