Overview
我们知道在Scala中是没有switch语句的，取而代之的是从其他函数式编程语言（Haskell等）中吸收的更加强大的模式匹配功能。除了代替switch语句进行条件分支之外，还能够进行类型检查，对象解构等操作，帮助我们摆脱冗长的if判断。
ch match {
case '+' => println("positive")
case '-' => println("negtive")
case _ => println("default")
}
与传统的相比switch语句，Scala不仅不需要使用break来防止语句跌入下一个条件分支，case的表达式也更加灵活。除了对值进行匹配之外，还能够对目标的类型进行判断。
obj match {
case obj:String => println("string object")
case obj:Int => println("integer object")
}
这里跟 instanceof 判断类型的效果一样，在Java中是可以通过Visitor Pattern来实现类似的效果的。不过需要注意的是在匹配泛型对象时，由于JVM在runtime时泛型参数是会被擦拭掉的，所以类似List[String] 的匹配方式，在运行时可能并不会匹配到和你想象中完全一样的结果。事实上List("A") 和 List(2) 都可以匹配成功。
此外，我们还能够通过模式匹配来对目标对象进行解构。
def quicksort[T <% Ordered[T]](l: List[T]): List[T] =
l match {
case head :: tail => quicksort(tail.filter { _ < head }) ::: List(head) ::: quicksort(tail.filter { _ > head })
case _ => Nil
}
这是一个简单的快速排序的例子，由于List对象总是由一个head和一个包含剩下元素的tail对象构成的。因此我们可以通过head::tail的方式将列表解构成表头和剩下的元素组成的列表。同理，对于更加复杂的数据结构我们也可以做类似的操作。这样通过构造器的方式来对不同的情况进行匹配并且能够直接获取到需要的值。相比而言，用许多if语句来拼凑和赋值是不是没有这样简单直观呢？
这些功能背后是提取器机制。在对目标进行模式匹配时，会调用该目标的伴生对象的unapply方法，通过该方法将目标对象传递进去，然后从中提取值。例如List能解构成head和tail就是由List伴生对象的unapply方法决定的。
你往往可以把unapply方法当做是apply方法的反向操作因为通常提取得到的这些值就是当初用来构造该对象的。而当你在创建case class的时候，这些方法则会自动创建在你定义的类的伴生对象当中以便你使用。使用字节码反编译的工具可以帮助你看到自动生成的代码。
Pattern Matching in Python
在大概了解了模式匹配的概念之后，我们来看下如何在我们熟悉的Python中山寨这一功能吧：）
显然由于语言本身的限制，我们没法把代码中出现的表达式推迟计算到值真正匹配的时候，把print("test")之类的表达式作为参数传递给特定的代码块只会导致它们直接被计算出来然后将值传递过去而已。
第一个尝试的方案是将要执行的代码块作为字符串参数传递过去，然后在匹配到时候才通过Python内置的eval函数进行计算。当然，匹配的pattern也同样用字符串来表达然后通过一个parser来进行解析。例子的话，就是这样。
match(val,[
("x:str","len(x)"),
("x:int","x**2"),
])
然而这样做的话也有不少缺点。首先我们将代码作为字符串来动态进行求值的时候，就损失了包括IDE的静态检查以及其他代码在执行前的预先优化的可能性了。另外由于实际代码是在这个模块内部通过eval执行的缘故，因此如果你需要在递归函数中使用这个特性的话，就必须完整的注明调用函数所属的module，否则就会得到一个未知引用的错误。
#Test.py
def quicksort(l):
return match(l,[
("[]","[]"),
("head::xs","Test.quicksort([x for x in l if x <= head]) + [head] + Test.quicksort([x for x in l if x > head])"),
])
因此我们这里也只好注明quicksort方法是从Test文件中引用的。这样实际负责计算的模块就能够通过正则表达式来将代码块中的疑似模块的东西全匹配出来然后import。
def import_module(exp):
matches = re.findall(r"([a-zA-Z_][a-zA-Z0-9_]*)\.", exp)
for module_name in matches:
try:
module = __import__(module_name)
globals()[module_name] = module
except ImportError as e:
pass
显然这样做有一点蠢。因此在第二次的尝试中，我选择通过decorator的方式对Pattern进行初始化，然后实际匹配的时候会才会根据规则走进对应的函数分支，从而避免了之前的问题，也没有任何额外需要解析的代码。
@t(int)
def fuck(obj):
return "Int"
@t(str)
def fuck(obj):
return "String"
@otherwise
def fuck(_):
return "Other"
fuck(1) # "Int"
fuck("1") # "String"
fuck(object()) # "Other"
这样子是不是清爽了很多呢？不同的decorator对应了不同的匹配模式以及解构的方法，只要在装饰器初始化函数的时候根据同样的函数名称返回同样的函数对象就可以实现这个功能了。对应的快速排序的代码是这样子的了。
@nil
def qs():
return []
@list_head_tail
def qs(x, xs):
return qs([y for y in xs if y <= x]) + [x] + qs([y for y in xs if y > x])
qs([]) # []
qs([3, 1, 4, 2]) # [1, 2, 3, 4]
TODO
目前只能对单个输入参数的情况进行匹配。目标是能够像Haskell那样子的方式。另外由于现在只是通过预先设定好的描述符进行匹配，因此也没有变量绑定之类的功能。
总的来说还停留在随便写写的阶段（连我自己都不会想到去用它）。哪天想起来在更新好了。大概就是这样。
