模式匹配（Pattern Matching）允许我们根据标识符值的不同进行不同的运算，它通常被拿来跟C#中的if…else或switch语法结构相比较，结论往往是模式匹配比后者要更为灵活、强大。那先来分析一下它灵活、强大在哪儿。
为什么说模式匹配是灵活、强大的？
在我前面写过的几篇随笔里面，有几次提到了模式匹配，比如它能够对简单值（整数、字符串）匹配，也可以对.NET类型进行匹配，看下面两个简单的例子：
F# Code - 对简单值和.NET类型进行匹配
// 对简单值进行匹配。
let rec fibonacci x =
match x with
| x when x <= 0 -> failwith "x必须是正整数。"
| 1 -> 1
| 2 -> 1
| x -> fibonacci(x - 1) + fibonacci(x - 2)
printfn "%i" (fibonacci 2) // -> 1
printfn "%i" (fibonacci 4) // -> 3
// 对.NET类型进行匹配。
open System
let typeToString x =
match box x with
| :? Int32 -> "Int32"
| :? Double -> "Double"
| :? String -> "String"
| _ -> "Other Type"
可以看到，这里所用的模式匹配没有给人太多惊喜，不用费多大力气就可以将其转换为if…else或switch结构了。
先别急着离开，列表是FP中的典型数据结构，我们对它应用一下模式匹配看看。
// 对列表应用模式匹配。
let listOfList = [[2; 3; 5]; [7; 11; 13]; [17; 19; 23; 29]]
let rec concatenateList list =
match list with
| head :: tail -> head @ (concatenateList tail)
| [] -> []
let rec concatenateList2 list =
if List.nonempty list then
let head = List.hd list in
let tail = List.tl list in
head @ (concatenateList2 tail)
else
[]
let primes = concatenateList listOfList
print_any primes // [2; 3; 5; 7; 11; 13; 17; 19; 23; 29]
listOfList是一个列表的列表，两个函数concatenateList和concatenateList2的功能都是将listOfList的元素连接为一个大的列表，只不过一个用模式匹配方式实现，一个使用if…then…else结构实现。可以看到concatenateList的代码更为简洁，但仅仅如此吗？在concatenateList2中，我们按照传统的看待链表（F#中的列表以链表实现）的方式，将其中的节点一个一个取出来进行处理，这种处理方式是较为具体和细节的；而在concatenateList中我们通过两个简单的模式“head :: tail”和“[]”就覆盖了列表的所有可能，可以说，我们找到了更好地分解列表这种数据结构的方式，从而可以更为通用地处理列表。
类似的，再来看看Union类型的情况。Union类型，有时称为sum类型或discriminated union，可将一组具有不同含义或结构的数据组合在一起。它的一个典型应用是表示一颗树：
type BinaryTree<'a> =
| Leaf of 'a
| Node of BinaryTree<'a> * BinaryTree<'a>
let rec printBinaryTreeValues t =
match t with
| Leaf x -> printfn "%i" x
| Node (l, r) ->
printBinaryTreeValues l
printBinaryTreeValues r
printBinaryTreeValues (Node ((Node (Leaf 1, Leaf 2)), (Node (Leaf 3, Leaf 4))))
这里通过BinaryTree<'a>定义一个泛型二叉树类型，printBinaryTreeValues函数用于打印其节点的值，这里需要判断节点的类型（子树还是叶子），有趣的是，Leaf和Node自动抽象为“模式”，不需要任何额外的工作。这样就可以看到一些所谓“灵活、强大”的影子了，对于Union类型所表示的数据结构，模式匹配可以极为简单、自然地分解、处理它。
除了列表和Union类型，元组对于模式匹配的“自适应”也是类似的，这些已经够我们解决很多问题了。那对于其它的更复杂的场景或者更特殊的领域，F#还有什么大招呢？你一定能想得到，这就是活动模式。
活动模式（Active Pattern）
活动模式的思想就是把模式匹配语法用于其他更多的数据结构。可以把它分为Single-Case、Multi-Case、Partial这几种类型。我将逐一做出介绍。
Single-Case活动模式
Single-Case是最简单的活动模式形式，它将一个输入值转换为其它的值，比如：
let (|UpperCase|) (x:string) = x.ToUpper()
let result = match "foo" with
| UpperCase "FOO" -> true
| _ -> false
printfn "%b" result // -> true
这里的UpperCase就是一个模式，它的类型信息为：active recognizer UpperCase: string -> string，可以看到下面求result值的时候可以像前面一样使用模式匹配的语法了，UpperCase “FOO”可以理解为对于输入值”foo”，应用了UpperCase模式后，结果应当为”FOO”，如果确实如此，那么该模式就匹配了，所以result的值为true。
UpperCase模式看起来像是一个函数，不过对于函数来说，没法直接应用模式匹配的语法。
Multi-Case活动模式
let (|Odd|Even|) x = if x % 2 = 0 then Even else Odd
let isDivisibleByTwo x = match x with Even -> true | Odd -> false
print_any (isDivisibleByTwo 2) // -> true
print_any (isDivisibleByTwo 3) // -> false
这里(|Odd|Even|)就是Multi-Case模式了，Even的类型信息为：active recognizer Even: int -> unit，即它没有返回值，所以在匹配时，直接写Even或Odd就可以了。
Partial活动模式
简单来说，Partial模式就是那些并不总是返回值的模式。比如输入值的范围可能过于庞大，或者对于某些返回值我们并不感兴趣，可以将其忽略。比如，对于自然数来说，只有一小部分是完全平方数或者能够被7整除。
// Partial Active Patterns
open System
let (|DivisibleBySeven|_|) input = if input % 7 = 0 then Some() else None
let (|IsPerfectSquare|_|) (input : int) =
let sqrt = int (Math.Sqrt(float input))
if sqrt * sqrt = input then
Some()
else
None
let describeNumber x =
match x with
| DivisibleBySeven & IsPerfectSquare ->
printfn "x is divisible by 7 and is a perfect square."
| DivisibleBySeven -> printfn "x is divisible by seven."
| IsPerfectSquare -> printfn "x is a perfect square."
| _ -> printfn "x looks normal."
describeNumber 49 // x is divisible by 7 and is a perfect square.
describeNumber 35 // x is divisible by seven.
describeNumber 25 // x is a perfect square.
describeNumber 20 // x looks normal.
自然数有很多特性，而在函数describeNumber中，我们只关注它是否是完全平方数或者7的倍数，其它的就都舍弃不管了。
应用
我们来看看如何使用活动模式来操作XML文档。
// 定义针对XML节点的模式
let (|Node|Leaf|) (node : #System.Xml.XmlNode) =
if node.HasChildNodes then
Node (node.Name, { for x in node.ChildNodes -> x })
else
Leaf (node.InnerText)
// 打印XML节点的函数
let printXml node =
let rec printXml indent node =
match node with
| Leaf (text) -> printfn "%s%s" indent text
| Node (name, nodes) ->
printfn "%s%s:" indent name
nodes |> Seq.iter (printXml (indent + " "))
printXml "" node
// 定义XML节点
let doc =
let temp = new System.Xml.XmlDocument()
let text = "<fruit>
<apples>
<gannySmiths>1</gannySmiths>
<coxsOrangePippin>3</coxsOrangePippin>
</apples>
<organges>2</organges>
<bananas>4</bananas>
</fruit>"
temp.LoadXml(text)
temp
printXml (doc.DocumentElement :> System.Xml.XmlNode)
这里首先定义针对XML节点的模式，然后应用该模式来递归打印出一个XML节点及其子节点的信息。
可以看到使用活动模式，寥寥数语就可以描述出XML节点的通用数据结构来了，这为接下来对节点的操作提供了良好的基础，而且我们回归了问题本身——XML文档，而不需要关注具体的编程细节。
小结
这里先是介绍了F#中模式匹配的用法，这个可以理解为使用F#内置的模式，这样我们就可以处理F#中的值和特定的数据结构，比如列表、Union类型和元组等；接下来更进一步，活动模式把模式匹配的语法用到了其他更多的数据结构，这样模式的应用范围得到了很大的扩展。而且通过活动模式，我们可以将问题域转换为一套术语来表达，从而脱离编程细节回归到问题域本身，这也就有了一些LOP（Language-Oriented Programming）的特点，事实上，活动模式正是F#中LOP的实现方式之一。这个我将在后面的随笔做更深入的讨论。
（要了解本人所写的其它F#随笔请查看 F#系列随笔索引）
参考
超越F#基础——活动模式 by Robert Pickering；
Introduction to F# Active Patterns by Chris Smith；
本文转自一个程序员的自省博客园博客，原文链接：http://www.cnblogs.com/anderslly/archive/2008/11/25/fsharp-adventure-pattern-matching-and-active-pattern.html，如需转载请自行联系原作者。
