模式匹配（Pattern Matching）
模式匹配允许你根据标识符值的不同进行不同的运算。有点像一连串的if...else结构，也像C++和C#中的switch，但是它更为强大和灵活。
看下面Lucas序列的例子，Lucas序列定义跟Fibonacci序列一样，只不过起始值不同：
let rec luc x =
match x with
| x when x <= 0 -> failwith "value must be greater than zero"
| 1 -> 1
| 2 -> 3
| x -> luc(x - 1) + luc(x - 2)
printfn "(luc 2) = %i" (luc 2)
printfn "(luc 6) = %i" (luc 6)
这里可以看到模式匹配的简单应用，使用关键字match和with，不同的模式规则间用“|”隔开，而“->”表示如果该模式匹配，运算结果是什么。
这个例子的打印结果为：
Output
(luc 2) = 3
(luc 6) = 18
匹配规则时按照它们定义的顺序，而且模式匹配必须完整定义，也就是说，对于任意一个可能的输入值，都有至少一个模式能够满足它（即能处理它）；否则编译器会报告一个错误信息。另外，排在前面的规则不应比后面的更为“一般”，否则后面的规则永远不会得到匹配，编译器会报告一个警告信息，这种方式很像C#中的异常处理方式，在捕获异常时，我们不能先不会“一般”的Exception异常，然后再捕获“更具体”的NullReferenceException异常。
可以为某个模式规则添加一个when卫语句（guard），可将when语句理解为对当前规则的更强的约束，只有when语句的值为true时，该模式规则才算匹配。在上例的第一个规则中，如果没有when语句，那么任意整数都能够匹配模式，加了when语句后，就只能匹配非正整数了。对于最简单的情况，我们可以省略第一个“|”：
let boolToString x =
match x with false -> "False" | _ -> "True"
这个例子中包含两个模式规则，“_”可以匹配任意值，因此当x值为false时匹配第一个规则，否则就匹配第二个规则。
另一个有用的特性是，我们可以合并两个模式规则，对它们采取相同的处理方式，这个就像C#中的switch…case结构中可以合并两个case一样。
let stringToBool x =
match x with
| "T" | "True" | "true" -> true
| "F" | "False" | "false" -> false
| _ -> failwith "Invalid input."
在本例中，我们把三种模式规则合并在了一起，将字符串值转换为相应的布尔值。
可以对大多数F#中定义的类型进行模式匹配，下面的例子就展示了对元组进行匹配。
let myOr b1 b2 =
match b1, b2 with
| true, _ -> true
| _, true -> true
| _ -> false
let myAnd p =
match p with
| true, true -> true
| _ -> false
这两个函数说明了如何对元组应用模式匹配，它们的功能是求两个布尔值“或”和“且”运算的结果。在myOr中，从第一、二两个模式规则可以知道b1、b2只要有一个为true，计算结果就是true，否则为false。myOr true false的结果为true，myAnd(true, false)结果为false。
模式匹配的常见用法是对列表进行匹配，事实上，对列表来说，较之if…then…else结构，模式匹配的方式更好。看下面的例子：
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
listOfList是一个列表的列表，两个函数concatenateList和concatenateList2的功能都是将listOfList的元素连接为一个大的列表，只不过一个用模式匹配方式实现，一个使用if…then…else结构实现。可以看到使用模式匹配的代码更为简洁明了。观察concatenateList函数，它处理列表的方式是先取出列表的头元素（head），处理它，然后递归地处理剩余元素，这其实是通过模式匹配方式处理列表的最常见的方式（但不是唯一的方式）。
在F#中，模式匹配还可用在其它地方，在后面的文章中将陆续介绍。
定义类型（Defining Types）
F#的类型系统提供了若干特性，可用来创建自定义类型。所有的类型可分为两类，一是元组（Tuple）或记录（Record），它们类似于C#中的类；二是Union类型，有时称为Sum类型。下面分别来看一下它们的特点。
元组是任意对象的有序集合，通过它我们可以快速、方便地将一组值组合在一起。创建之后，就可以引用元组中的值。
let pair = true, false
let b1, b2 = pair
let _, b3 = pair
let b4, _ = pair
第一行代码创建了一个元组，其类型为bool * bool, 说明pair元组包含两个值，它们的类型都是bool。通过第二、三、四行这样的代码，可以访问元组的值，“_”告诉编译器，我们对该值不感兴趣，将其忽略。这里b1的值为true，b3的值为false。
进一步分析，元组是一种类型，但是我们并没有显式地使用type关键字来声明类型，pair本质上是F#中Tuple类的一个实例，而不是自定义类型。如果需要声明自定义类型，就要使用type关键字了，最简单的情况是给已有类型起个别名：
type Name = string
// FirstName, LastName
type FullName = string * string
对于Name类型来说，它仅仅是string类型的别名，FullName则是元组类型的别名。
记录（Record）类型与元组有相似之处，它也是将多个类型的值组合为同一类型，不同之处在于记录类型中的字段都是有名称的。看下面的例子：
type Organization = { Boss : string; Lackeys : string list }
let family =
{ Boss = "Children";
Lackeys = ["Wife"; "Husband"] }
第一行是创建Organization类型，第二行则是创建它的实例，令人惊奇的是不需要声明实例的类型，F#编译器能够根据字段名推导出它的类型。这个功能是很强大，但是F#不强求每个类型的字段都是不同的，如果两个类型的各个字段名都一样怎么办呢？这时可以显式地声明类型：
type Company = { Boss : string; Lackeys : string list }
let myCom =
{ new Company
with Boss = "Bill"
and Lackeys = ["Emp1"; "Emp2"] }
一般情况下，类型的作用域从声明处至所在源文件的结束。如果一个类型要使用在它后面声明的类型，可将这两个类型声明在同一个代码块中。类型间用and分隔，看下面食谱的例子：
type recipe =
{ recipeName : string;
ingredients : ingredient list;
instructions : string }
and ingredient =
{ ingredientName : string;
quantity : int }
let greenBeansPineNuts =
{ recipeName = "Green Beans & Pine Nuts";
ingredients =
[{ingredientName = "Green beans"; quantity = 200};
{ingredientName = "Pine nuts"; quantity = 200}];
instructions = "Parboil the green beans for about 7 minutes." }
let name = greenBeansPineNuts.recipeName
let toBuy =
List.fold_left
(fun acc x ->
acc + (Printf.sprintf "\t%s - %i\r\n" x.ingredientName x.quantity))
"" greenBeansPineNuts.ingredients
let instructions = greenBeansPineNuts.instructions
printf "%s\r\n%s\r\n\r\n\t%s" name toBuy instructions
本例不仅展示了如何将两个类型声明在“一块”，还显示了如何访问记录的字段值。可以看到访问记录的字段要比访问元组的值更为方便。
也可以对记录类型应用模式匹配：
type couple = { him : string; her : string }
let couples =
[ { him = "Brad"; her = "Angelina" };
{ him = "Becks"; her = "Posh" };
{ him = "Chris"; her = "Gwyneth" } ]
let rec findDavid list =
match list with
| { him = x; her = "Posh" } :: tail -> x
| _ :: tail -> findDavid tail
| [] -> failwith "Couldn't find David"
print_string(findDavid couples)
首先创建了couple类型的列表，findDavid函数将对该列表进行模式匹配，可以将字段与常量值比较，如her = “Posh”；将字段值赋给标识符，如him = x；还可以使用“_”忽略某个字段的值。最后上面例子的打印结果：Becks。
字段值也可以是函数，这种技术将在本系列文章的第三部分介绍。
Union类型，有时称为sum类型或discriminated union，可将一组具有不同含义或结构的数据组合在一起。可与C语言中的联合或C#中的枚举类比。先来看个例子：
type Volume =
| Liter of float
| UsPint of float
| ImperialPint of float
Volume类型属于Union类型，包含3个数据构造器（Data Constructor），每个构造器都包含单一的float值。声明其实例非常简单：
let vol1 = Liter 2.5
let vol2 = UsPint 2.5
let vol3 = ImperialPint 2.5
事实上，通过Reflector可以看到，Liter、UsPint和ImperialPint是Volume类型的派生类。在将Union类型解析为其基本类型时，我们需要模式匹配。
let convertVolumeToLiter x =
match x with
| Liter x -> x
| UsPint x -> x * 0.473
| ImperialPint x -> x * 0.568
记录类型和Union类型都可以被参数化（Parameterized）。参数化的意思是在一个类型的定义中，它使用了一个或多个其它类型，这些类型不是在定义中确定的，而是在该代码的客户代码中确定。这与前面提及的可变类型是类似的概念。
对于类型参数化，F#中有两种语法予以支持。来看第一种：
type 'a BinaryTree =
| BinaryNode of 'a BinaryTree * 'a BinaryTree
| BinaryValue of 'a
let tree1 =
BinaryNode(
BinaryNode(BinaryValue 1, BinaryValue 2),
BinaryNode(BinaryValue 3, BinaryValue 4))
在type关键字和类型名称BinaryTree之家添加了’a，而’a就是可变的类型，它的确切类型将在使用它的代码中确定，这是OCaml风格的语法。在标识符tree1中，定义BinaryValue时用的值是1，编译器将’a解析为int类型。再看看第二种语法：
type Tree<'a> =
| Node of Tree<'a> list
| Value of 'a
let tree2 =
Node( [Node([Value "One"; Value "Two"]);
Node([Value "Three"; Value "Four"])])
这种语法更接近于C#中的泛型定义，是.NET风格的语法。在tree2中，’a被解析为string类型。不管哪种语法，都是单引号后跟着字母，我们一般只使用单个字母。
创建和使用参数化类型的实例跟非参数化类型的过程是一样的，因为编译器会自动推导参数化的类型。
在本节中，我们逐一讨论了元组、记录和Union类型。通过Reflector可以看到，元组值是Tuple类型的实例，而Tuple实现了Microsoft.FSharp.Core.IStructuralHash和System.IComparable接口；记录和Union则直接实现了这两个接口。要了解IStructualHash接口的更多内容，请参考Jome Fisher的文章。
到这里，我们讨论完了如何定义类型、创建和使用它们的实例，却未提及对它们的修改。那是因为我们没法修改这些类型的值，这是函数式编程的特性之一。但F#提供了多种编程范式，对某些类型来说，它们是可修改的，这将在下一部分（命令式编程）进行介绍。
异常处理（Exception Handling）
在F#中，异常的定义类似于Union类型的定义，而异常处理的语法则类似于模式匹配。使用exception关键字来定义异常，可选地，如果异常包含了数据我们应当声明数据的类型，注意是可以包含多种类型数据的：
exception SimpleException
exception WrongSecond of int
// Hour, MInute, Second
exception WrongTime of int * int * int
要抛出一个异常，可使用raise关键字。F#还提供了另一种方法，如果仅仅想抛出一个包含文本信息的异常，可以使用failwith函数，该函数抛出一个FailureException类型的异常。
let testTime() =
try
let now = System.DateTime.Now in
if now.Second < 10 then
raise SimpleException
elif now.Second < 30 then
raise (WrongSecond now.Second)
elif now.Second < 50 then
raise (WrongTime (now.Hour, now.Minute, now.Second))
else
failwith "Invalid Second"
with
| SimpleException ->
printf "Simple exception"
| WrongSecond s ->
printf "Wrong second: %i" s
| WrongTime(h, m, s) ->
printf "Wrong time: %i:%i:%i" h m s
| Failure str ->
printf "Error msg: %s" str
testTime()
这个例子展示了如何抛出和捕获各种异常，如果你熟悉C#中的异常处理，对此应该不会感到陌生。
与C#类似，F#也支持finally关键字，它当然要与try关键字一起使用。不管是否有异常抛出，finally块中的代码都会执行，在下面的例子中使用finally块来保证文件得以正确地关闭和释放：
let writeToFile() =
let file = System.IO.File.CreateText("test.txt") in
try
file.WriteLine("Hello F# Fans")
finally
file.Dispose()
writeToFile()
需要注意的是，由于CLR架构的原因，抛出异常的代价是很昂贵的，因此要谨慎使用。
延迟求值（或惰性求值，Lazy Evaluation）
第一次接触Lazy的东西是iBATIS中的LazyLoad，也就是延迟加载，它并不是在开始时加载所有数据，而是在必要时才进行读取。延迟求值与此类似，除了性能的提升外，还可用于创建无限的数据结构。
延迟求值与函数式编程语言关系密切，其原理是如果一种语言没有副作用，编译器或运行时可随意选择表达式的求值顺序。F#允许函数具有副作用，因此编译器或运行时不能够按随意地顺序对函数求值，可以说F#具有严格的求值顺序或 F#是一种严格的语言。
如果要利用延迟求值的特性，必须要显式地声明哪些表达式的求值需要延迟，这个要使用lazy关键字。如果需要对该表达式求值，则要调用Lazy模块的force函数。在调用force函数的时候，它会计算表达式的值，而所求得的值会被缓存起来，再次对表达式应用force函数时，所得的值其实是缓存中的值。
let sixtyWithSideEffect = lazy(printfn "Hello, sixty!"; 30 + 30)
print_endline "Force value the first time:"
let actualValue1 = Lazy.force sixtyWithSideEffect
print_endline "Force value the second time:"
let actualValue2 = Lazy.force sixtyWithSideEffect
打印结果为：
Force value the first time:
Hello, sixty!
Force value the second time:
小节
本文继续讨论F#函数式编程范式的核心内容，主要是模式匹配、自定义类型、异常处理和延迟求值等内容，至此，F#的函数式编程的相关内容就介绍完了。模式匹配可以很大程度上简化我们的程序；自定义类型则可以帮助我们更好地组织程序；延迟求值不仅能够提升性能，还可用于创建无限的数据结构，比如自然数序列。另外，在开发F#程序时，建议常用Reflector来看看编译后代码的样子，来了解它优雅的函数式编程背后到底是什么。在下一站，我们将看看命令式编程的风景。
参考：
《Foundations of F#》 by Robert Pickering
《Expert F#》 by Don Syme , Adam Granicz , Antonio Cisternino
《F# Specs》
