第三章 函数编程（四）
定义类型
F# 中提供了大量的功能用于自定义类型。所有 F#的类型定义可以分成两类：
一类是简单类型，称为记录（records），或元组（tuples），它是由几种类型形成复合类型（composite type，与 C 的结构或 C# 的类相似）；
第二种类型是和类型（sum types），有时也称为联合类型（union types）。
元组（tuples）和记录（records）类型
元组是一种快速、方便组合值的方法。这些值用逗号分隔，可以用一个标识符引用，如下面例子的第一行；然后，通过切换[doing the reverse ]再取得这些值，如示例中的第二、三行完成，
逗号分隔的标识符在等号的左边，每一个标识符接收元组中的一个值。如果想忽略元组中的一个值，可以使用下划线（_）告诉编译器你对这个值不感兴趣，在第二、三行中就是这样的。
let pair = true, false
let b1, _ = pair
let _, b2 = pair
元组不同于 F# 中大多数用户定义的类型，因为不必要显式地用关键字type 去声明。定义类型，用关键字type，后面是类型名字，等号，然后是定义的类型。最简单的形式，可以用这个方法给已有的类型定义一个别名，包括元组。通常，给类型定义别名用处不大，但是给元组定义别名则非常有用，特别是当准备元组用于类型约束时。下面的例子演示了为类型和元组定义别名，以及如何用别名进行类型约束。
type Name = string
type Fullname = string * string
let fullNameToSting (x : Fullname) =
letfirst, second = x in
first + " " + second
在把组合多个类型组合成一个类型方面，记录类型与元组很相似，也有不同，记录类型中每个字段（field）都有名字。下面的例子演示定义记录类型的语法。
// define an organization with uniquefields
type Organization1 = { boss: string;lackeys: string list }
// create an instance of this organization
let rainbow =
{boss = "Jeffrey";
lackeys= ["Zippy"; "George"; "Bungle"] }
// define two organizations withoverlapping fields
type Organization2 = { chief: string;underlings: string list }
type Organization3 = { chief: string;indians: string list }
// create an instance of Organization2
let (thePlayers: Organization2) =
{chief = "Peter Quince";
underlings= ["Francis Flute"; "Robin Starveling";
"Tom Snout";"Snug"; "Nick Bottom"] }
// create an instance of Organization3
let (wayneManor: Organization3) =
{chief = "Batman";
indians= ["Robin"; "Alfred"] }
把字段的定义放在大括号中，用分号隔开；字段定义由字段名，冒号，字段类型组成；类型定义Organization1 是记录类型，字段名是唯一的。就是说，可以用简单的语法创建这个类型的一个实例，在创建时不需要用到类型的名字。创建记录方法，在大括号中放字段名，等号，字段值，如标识符Rainbow 所示：
F# 并不强制字段名唯一，因此，有时候编译器不能单独从字段名推断出字段类型；这样，编译器也就不能推断出领导的类型。要创建字段不唯一的记录，编译器必须静态知道所要创建记录的类型。如果编译器不能推断出记录的类型，就必须使用类型注释，如前一节中所描述的。类型 Organization2 和 Organization3 演示了类型注释的使用，thePlayers 和wayneManor 是它们的实例。可以看到，标识符的类型显式放在字段名的后面。
访问记录中的字段相当简单，其语法为：记录标识符名字，加上点，再加上字段名。下面的示例演示如何访问记录Organization 中的字段 chief。
// define an organization type
type Organization = { chief: string;indians: string list }
// create an instance of this type
let wayneManor =
{chief = "Batman";
indians = ["Robin"; "Alfred"] }
// access a field from this type
printfn "wayneManor.chief = %s" wayneManor.chief
默认情况下，记录是不可变的，对于命令式程序员来说，会觉得这样来说，记录就不是很有用，因为，改变字段几乎是不可避免的。出于这个目的，F# 提供了一个简单的语法，用修改后的字段创建记录的副本。创建记录副本的方法，在大括号中放记录的名字，后面是关键字 with，后面是一组需要修改的字段和修改后的值。这种方法的好处是不需要重新输入没有变化的字段。下面的示例演示这种方法，首先创建了wayneManor 的原始版本，然后，又创建了wayneManor‘，其中没有"Robin"。
// define an organization type
type Organization = { chief: string;indians: string list }
// create an instance of this type
let wayneManor =
{chief = "Batman";
indians = ["Robin"; "Alfred"] }
// create a modified instance of this type
let wayneManor‘ =
{wayneManor with indians = [ "Alfred" ] }
// print out the two organizations
printfn "wayneManor = %A"wayneManor
printfn "wayneManor‘ = %A"wayneManor‘
示例的运行结果如下：
wayneManor = {chief = "Batman";
indians = ["Robin";"Alfred"];}
wayneManor‘ = {chief = "Batman";
indians = ["Alfred"];}
访问记录中字段的另一种方法是使用模式匹配，就是说，可以用模式匹配去匹配记录类型中的字段。如你所想，用模式匹配去检查字段的语法和构造它的语法相似。可以用常量比较字段，字段 = 常量；可以用标识符给字段赋值，字段 = 标识符；也可以忽略一个字段，字段 = _。下面的例子中的函数 findDavid 就是用模式匹配访问记录中字段。
// type representing a couple
type Couple = { him : string ; her : string}
// list of couples
let couples =
[ {him = "Brad" ; her = "Angelina" };
{him = "Becks" ; her = "Posh" };
{him = "Chris" ; her = "Gwyneth" };
{him = "Michael" ; her = "Catherine" } ]
// function to find "David" froma list of couples
let rec findDavid l =
match l with
| {him = x ; her = "Posh" } :: tail -> x
| _:: tail -> findDavid tail
|[] -> failwith "Couldn‘t find David"
// print the results
printfn "%A" (findDavid couples)
函数 FindDavid 中的第一个规则，是做了实际工作，检查记录的her字段，看它的值是不是"Posh"，David 的妻子。和标识符 x 关联的是him 字段，用于第二个规则的后半段。
示例的运行结果如下：
Becks
有一点十分重要，像这样针对记录进行模式匹配，只能使用文字值。因此，如果想让这个函数更通用一些，可以改变查找的对象，就需要在模式匹配中使用 when 子句：
let rec findPartner soughtHer l =
match l with
| {him = x ; her = her } :: tail when her = soughtHer -> x
| _:: tail -> findPartner soughtHer tail
|[] -> failwith "Couldn‘t find him"
字段值也可以是函数，因为这项技术主要用于连接可变状态，以形成类似于对象的值，我们会在第五章讨论。
联合（union）类型、和（sum）类型
联合类型，有时也称和类型，或差别联合（discriminated unions），它是将不同意义、结构的数据联合到一起的方法。
定义联合类型，如同所有的类型定义一样，使用关键字 type，加类型名，加等号，后面就是不同的构造器（constructors）定义，用竖线隔开；第一个竖线可以省略。
构造器的组成，名字必须以大写字母开头，是为了防止与标识符的名字相混淆，其后的关键字of是可选的；再后是组成构造器的类型。组成一个构造器的多个类型用星号隔开。类型中构造器的名字必须唯一。如果定义几个联合类型，它们构造器的名字也可以交叉。然而，这样做应该小心，因为在将来构造、使用联合类型时需要类型注释。
下面的例子定义一个类型Volume，它的值有三个不同的意义：liter（升）、USpint、imperial pint[ 都是我们不使用的计量单位，就不翻译了]。虽然数据结构相同，都是浮点数，但意义完全不同。在算法中混淆数据的意义通常会引起程序错误，从某种程度上讲，类型volume 就是为了避免这种错误。
type Volume =
|Liter of float
|UsPint of float
|ImperialPint of float
let vol1 = Liter 2.5
let vol2 = UsPint 2.5
let vol3 = ImperialPint (2.5)
构造联合类型的一个新实例的语法，构造器名，加这个类型的值；有多个值的，用逗号隔开；也可以把值放在括号中。用三个不同的构造器Volume 构造了三个不同的标识符 vol1、vol2 和 vol3。
把联合类型的值解构到它的基本部分，总是要用到模式匹配。针对联合类型的模式匹配，构造器组成模式匹配规则的前半部分。不一定要完整的规则；但是，如果规则不完整，就必须有一个默认规则，用标识符或通配符匹配所有剩余规则。构造器规则前面部分的组成，构造器名，加标识符或通配符去匹配其中的各种值。下面的函数convertVolumeToLiter、convertVolumeUsPint 和 convertVolumeImperialPint，演示了这个语法。
// type representing volumes
type Volume =
|Liter of float
|UsPint of float
|ImperialPint of float
// various kinds of volumes
let vol1 = Liter 2.5
let vol2 = UsPint 2.5
let vol3 = ImperialPint 2.5
// some functions to convert betweenvolumes
let convertVolumeToLiter x =
matchx with
|Liter x -> x
|UsPint x -> x * 0.473
|ImperialPint x -> x * 0.568
let convertVolumeUsPint x =
matchx with
|Liter x -> x * 2.113
|UsPint x -> x
|ImperialPint x -> x * 1.201
let convertVolumeImperialPint x =
matchx with
|Liter x -> x * 1.760
|UsPint x -> x * 0.833
|ImperialPint x -> x
// a function to print a volume
let printVolumes x =
printfn"Volume in liters = %f,
in us pints = %f,
in imperial pints = %f"
(convertVolumeToLiterx)
(convertVolumeUsPintx)
(convertVolumeImperialPintx)
// print the results
printVolumes vol1
printVolumes vol2
printVolumes vol3
示例的运行结果如下：
Volume in liters = 2.500000,
in us pints = 5.282500,
in imperial pints = 4.400000
Volume in liters = 1.182500,
in us pints = 2.500000,
in imperial pints = 2.082500
Volume in liters = 1.420000,
in us pints = 3.002500,
in imperial pints = 2.500000
解决这种问题的另一种办法是使用 F#（units of measure），在本章后面的“度量单位”一节讨论。
有类型参数的类型定义（Type Definitions with Type Parameters）
联合类型、记录类型都能参数化（parameterized）。类型参数化意思是保留这个类型定义中的一个或多个类型，以后由类型的使用者决定。这个概念与本章开始时讨论的可变类型相似，定义类型时，必须显式说明哪些类型是可变的。
F# 为类型参数化提供了两种语法。第一种，把要参数化的类型放在关键字 type 和类型的名字之间，如下所示：
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 Tree<‘a> =
| Node of Tree<‘a> list
| Value of ‘a
let tree2 =
Node( [ Node( [Value "one"; Value"two"] ) ;
Node( [Value "three"; Value"four"] ) ] )
像可变类型一样，类型参数的名字总是以单引号（‘）开头，后面是表示类型名字的字母、数字，通常只用一个字母。如果需要多个参数化的类型，用逗号隔开。以后，在整个类型定义期间都可以使用这个类型参数。前面的例子用了F# 提供的两种不同的语法，定义了两个参数化类型，
类型BinaryTree 使用的是OCaml 风格的语法，类型参数放在类型名字的前面；类型tree 使用了.NET 风格的语法，类型参数用尖括号放在类型名字的后面。
创建、使用参数化类型的实例，其语法与非参数化类型相同，这是因为编译器会自动推断参数化类型的类型参数。在下面的例子中，函数printBinaryTreeValues 和 printTreeValues 创建并使用 tree1、tree2：
// definition of a binary tree
type ‘a BinaryTree =
|BinaryNode of ‘a BinaryTree * ‘a BinaryTree
|BinaryValue of ‘a
// create an instance of a binary tree
let tree1 =
BinaryNode(
BinaryNode( BinaryValue 1, BinaryValue 2),
BinaryNode( BinaryValue 3, BinaryValue 4) )
// definition of a tree
type Tree<‘a> =
|Node of Tree<‘a> list
|Value of ‘a
// create an instance of a tree
let tree2 =
Node([ Node( [Value "one"; Value "two"] ) ;
Node([Value "three"; Value "four"] ) ] )
// function to print the binary tree
let rec printBinaryTreeValues x =
matchx with
|BinaryNode (node1, node2) ->
printBinaryTreeValuesnode1
printBinaryTreeValuesnode2
|BinaryValue x ->
printf"%A, " x
// function to print the tree
let rec printTreeValues x =
matchx with
|Node l -> List.iter printTreeValues l
|Value x ->
printf"%A, " x
// print the results
printBinaryTreeValues tree1
printfn ""
printTreeValues tree2
示例的运行结果如下：
1, 2, 3, 4,
"one", "two","three", "four",
你可能已经注意到了，虽然我们讨论了定义类型，创建类型的实例，查看实例，但并未讨论如何更新，更新这些类型是不可能的，这是因为值随时间变化违反了函数编程的思想。然而，F# 也提供了一些可以更新的类型，我们会在第四章中讨论。
递归类型定义（Recursive Type Definitions）
通常，类型的作用域是从它的声明开始，一直到声明它的这个源文件结束为止；如果有一个类型需要引用一个以后声明的类型，通常是做不到的，需要这样做的唯一原因是，这两个类型相互递归（mutually recursive）。
F# 有专门的语法定义相互递归的类型。这些类型必须，一起声明。在一块儿声明的类型必须彼此在一起声明，就是说，在它们之间不能有任何值的声明，在第一个类型定义之后，其他所有类型声明的关键字 type 用 and 替换。
以这种方式声明的类型不同任何常规方式声明的类型，它们可以引用这个块儿中任何其他的类型，甚至可以相互引用。
下面的示例演示了在 F# 中如何使用联合类型和记录类型表示 XML，在示例中，两个类型XmlElement 和 XmlTree 相互递归，在一块儿声明。如果它们单独声明，XmlElement 就不可能引用 XmlTree，因为XmlElement 在 XmlTree 之前声明；由于它们的声明用关键字 and 加在了一起，XmlElement 就有了一个类型为 XmlTree 的字段。
// represents an XML attribute
type XmlAttribute =
{AttribName: string;
AttribValue: string; }
// represents an XML element
type XmlElement =
{ElementName: string;
Attributes: list<XmlAttribute>;
InnerXml: XmlTree }
// represents an XML tree
and XmlTree =
|Element of XmlElement
|ElementList of list<XmlTree>
|Text of string
|Comment of string
|Empty
活动模式（Active Patterns）
活动模式提供了一种的方式使用 F# 的模式匹配，可以执行函数，看匹配是否发生，这就是为什么会称为活动（active）的原因。它设计的目的是能够在应用程序中更好地重用模式匹配逻辑。
所有的模式匹配都是有输入，然后用这些输入执行某种计算，决定匹配是否发生。有两种类型的活动模式：
完全活动模式（Complete active patterns），即，匹配可以分解成有限数量的情况；
散活动模式（Partial active patterns），即，既可能匹配，也可能失败。
首先，我们看一下完全活动模式。
完整的活动模式
定义活动模式的语法与定义函数相似，关键不同是表示活动模式的标识符用香蕉括号（banana brackets）括起来，它是由括号和竖线组成（(| |)）。放在香蕉括号中活动模式不同情况的名字用竖线分隔，活动模式的主体就是一个 F# 函数，必须返回在香蕉括号中给定的活动的每一种情况，每一种情况也可能返回额外的数据，就像联合类型一样。下面示例的第一部分演示了解析输入字符串的活动模式。
open System
// definitionof the active pattern
let(|Bool|Int|Float|String|) input =
// attempt to parse a bool
let success, res = Boolean.TryParse input
if success then Bool(res)
else
// attempt to parse an int
let success, res = Int32.TryParse input
if success then Int(res)
else
// attempt to parse a float (Double)
let success, res = Double.TryParse input
if success then Float(res)
else String(input)
//function to print the results by pattern
//matching over the active pattern
let printInputWithTypeinput =
match input with
| Bool b -> printfn "Boolean:%b" b
| Int i -> printfn "Integer:%i" i
| Float f -> printfn "Floatingpoint: %f" f
| String s -> printfn "String:%s" s
//print the results
printInputWithType"true"
printInputWithType"12"
printInputWithType"-12.1"
设计这个模式是用来确定输入的字符串是点面布尔型、整型、浮点型，或者字符串值，每一种情况的名字分别是Bool、Int、Float 和 String。示例依次使用由基本类库提供的方法 TryParse，确定输入值是否是布尔型、整型，或者浮点型；如果不是这几种类型，那么就是字符串；如果解析成功，则返回情况的名字连同解析的值。
在示例的第二部分，可以看到如何使用活动模式。活动模式可以把字符串看作就像是联合类型，可以匹配四种情况中的一种，并以强类型的方式由活动模式返回获得的数据。
下面是示例的运行结果：
Boolean: true
String: 12
Floating point: -12.100000
不完整的活动模式
定义不完整的活动模式的语法与完整的活动模式相似。不完整的活动模式只有一种情况，也放在香蕉括号中，如同完整的活动模式一样；不同的是，不完整的活动模式后面必须有一个竖线和一个下划线，说明它是不完整的（与完整的活动模式相对，只有一种情况）。
记住，完整与不完整的活动模式的关键不同是，完整的活动模式保证返回几种情况中的一种，而不管活动模式匹配成功与否；因此，不完整的活动模式是 option 类型，option 类型是简单的联合类型，它已经内置到 F# 的基本库，只有两种情况：Some 和 None。它的定义是这样的：
type option<‘a> =
| Some of ‘a
| None
这种类型，像它的名字所暗示的，用于表示一个值存在或者不存在。因此，不完整的活动模式既可以返回 Some，连同要返回的值一起，表示匹配；也可以返回 None，表示不匹配。
所有的活动匹配除了输入以处，可以有额外的参数；额外的参数放在活动模式的输入的前面。
下面的示例使用不完整的活动模式重新实现了前一个示例的内容，用 .NET 的正则表达式（regular expression）表示成功或失败。正则表达式是作为活动模式的参数给定的。
openSystem.Text.RegularExpressions
//the definition of the active pattern
let (|Regex|_|)regexPattern input =
// create and attempt to match a regular expression
let regex = new Regex(regexPattern)
let regexMatch = regex.Match(input)
// return either Some or None
if regexMatch.Success then
Some regexMatch.Value
else
None
//function to print the results by pattern
//matching over different instances of the
//active pattern
let printInputWithTypeinput =
match input with
| Regex "$true|false^" s-> printfn"Boolean:%s" s
| Regex @"$-?\d+^" s -> printfn "Integer: %s" s
| Regex "$-?\d+\.\d*^" s-> printfn"Floatingpoint: %s" s
| _ -> printfn "String: %s" input
//print the results
printInputWithType"true"
printInputWithType"12"
printInputWithType"-12.1"
因为完整的活动模式的行为与联合类型完全相同，就是说，如果有情况丢失，编译器会报错；而不完整的活动模式总是有一个兜底情况，就避免了编译错误。然而，不完整的活动模式的真正优势是可以把几个活动模式链接在一起，第一种匹配的情况将是被使用的。这可以从前面的示例中看到，它把三个正则表达式的活动模式在一起，每一种活动模式由不同的正则表达式模式参数化：一个匹配布尔输入，另一个匹配整型输入，第三个匹配浮点输入。
下面是示例的运行结果：
Boolean: true
String: 12
Floating point: -12.1
度量单位（Units of Measure）
度量单位是 F# 类型系统的一个有趣补充，它能够把数字值分类到不同的单位。它的思想是防止意外地错误使用数字值，例如，把表示英寸的值和表示的值在没有正确转换时就加起来。
为了定义度量单位，声明类型名，用属性 Measure 作为前缀。下面的示例创建了单位为米的类型（缩写 m）：
[<Measure>]type m
默认情况下，度量单位使用浮点值，即，System.Double。要创建一个带单位的值，简单地在值的后面加上放在尖括号中的单位名。因此，使用下面的语法可以创建一个 meters 类型的值：
let meters =1.0<m>
现在，我们再重新审视一下“定义类型”一节中的示例，它是用联合类型来保证各种不同单位的类型不会混用，这个示例使用度量单位实现一些相似的功能。首先，分别为 liters 和 pints 定义不同的单位；然后，定义两个标识符表示不同的容积：一个用 pint 作单位，另一个用 liter 作单位；最后，尝试把这两个值加起来，这个操作应该会出错，因为在没有进行转换之前，不能把 pints 和 liters 加到一起。
[<Measure>]type liter
[<Measure>]type pint
let vol1 = 2.5<liter>
let vol2 = 2.5<pint>
let newVol = vol1 + vol2
运行程序，会产生下面的错误：
Program.fs(7,21): error FS0001: The unit ofmeasure ‘pint‘ does not match the unit of measure
‘liter‘
不同度量单位的加法和减法是不允许的，但是，除法和除法是可以的，它会产生一个新的度量单位。例如，我们知道，把 pint 转换成 liter，需要乘以一个liters 到pints 的比例系数，一个 liter 东倒西歪相当于 1.76 个 pints，因此，可以用下面的程序计算正确的转换比例：
let ratio = 1.0<liter> /1.76056338<pint>
标识符 ratio 的类型为float<liter/pint>，它使 liters 到 pints 的比例更清晰；而且，当一个类型为 float<pint> 的值乘以类型为 float<liter/pint>的值，结果的类型自动是 float<liter>，正如我们所希望的一样。这样，我们现在就能用下面的程序保证 pints 在相加之前，案例地转换成 liters：
// define some units of measure
[<Measure>]type liter
[<Measure>]type pint
// define some volumes
let vol1 = 2.5<liter>
let vol2 = 2.5<pint>
// define the ratio of pints to liters
let ratio = 1.0<liter> /1.76056338<pint>
// a function to convert pints to liters
let convertPintToLiter pints =
pints * ratio
// perform the conversion and add thevalues
let newVol = vol1 + (convertPintToLitervol2)
异常与异常处理（Exceptions and Exception Handling）
在 F# 中，定义异常的语法与定义联合类型的构造器相似，而处理异常的语法与模式匹配相似。
定义异常，使用关键字 exception，加异常的名字，然后是关键字 of 和异常可能包含值的类型，有多个类型的用星号隔开，这一项是可选的。下面的示例定义了一个异常WrongSecond，它包含了一个整数。
exception WrongSecond of int
可以用关键字 raise 引发异常，就像下面函数 testSecond 中 else 子句所显示的；F# 还有另一个引发异常的关键字failwith 函数，如下面的 if 子句。如果这是一个很普通的情况，你引发的异常只想描述一下发生了什么错误，就可以用failwith 引发一个一般异常，它包含了你传递给这个函数的文本。
// define an exception type
exception WrongSecond of int
// list of prime numbers
let primes =
[2; 3; 5; 7; 11; 13; 17; 19; 23; 29; 31; 37; 41; 43; 47; 53; 59 ]
// function to test if current second isprime
let testSecond() =
try
let currentSecond = System.DateTime.Now.Second in
// test if current second is in the list of primes
if List.exists (fun x -> x = currentSecond) primes then
// use the failwith function to raise an exception
failwith "A prime second"
else
// raise the WrongSecond exception
raise (WrongSecond currentSecond)
with
//catch the wrong second exception
WrongSecond x ->
printf "The current was %i, which is not prime" x
// call the function
testSecond()
如 testSecond 所显示的，处理异常使用关键字 try 和 with，在 try 和 with 之间的是需要进行错误处理的原因的表达式；在 with 之后必须有一个或多个模式匹配的规则。当尝试匹配 F# 异常时，语法与匹配联合类型的构造器一样。前半部分的规则包含异常的名字，加标识符或者通配符，匹配异常包含的值；后半部分的规则是一个表达式，描述应该如何处理异常。它与常规的模式匹配构造之间的主要不同在于，如果模式匹配不完整，不会发出错误或警告，这是因为任何未经处理的异常会继续传播，直到到达顶层，并停止运行。这个示例处理了异常wrongSecond，而让由failwith 引发的异常继续传播。
F# 还提供了关键字 finally，与关键字 try 相对应，不能与关键字with 相连。不管异常是否发生，finally 表达式都会执行。下面的示例演示了用 finally 语句保证写文件结束后，被关闭并释放：
// function to write to a file
let writeToFile() =
//open a file
letfile = System.IO.File.CreateText("test.txt")
try
// write to it
file.WriteLine("Hello F# users")
finally
// close the file, this will happen even if
// an exception occurs writing to the file
file.Dispose()
// call the function
writeToFile()
警告
有OCaml 背景的程序员在使用地# 中的异常时要小心，由于通用语言运行时体系的原因，引发异常的代价是相当昂贵的，与 OCaml 相比，高出不少。因此，如果你打算引发许多异常，应该仔细评估你的代码，决定性能的代价是否值得；如果代价太高，最好适当地修改代码。
延迟计算（Lazy Evaluation）
延迟计算是与函数编程紧密结合的，其理论是这样的，如果在语言中没有副作用，编译器或运行时可以自由选择表达式的计算顺序。
如你所知，F# 的函数是可以有副作用的，因此，编译器或运行时想在函数计算上不受约束是不可能的；所以说，F# 必须有严格的计算顺序，或者称为严格语言（strict language）。不过，我们仍然可以利用延迟计算，只明必须明确哪些计算必须延迟计算，即，以延迟方式计算。
延迟计算使用关键字 lazy。在延迟表达式中的计算直到显式强制计算时才进行，使用 Lazy 模块中的 force 函数。当针对特定的延迟表达式应用 force 函数时，值才计算，结果被缓存起来；以后对这个 force 函数的调用，直接返回缓存的结果，不管什么时候，即使是引发异常。
下面的代码演示了延迟计算的简单应用：
let lazyValue = lazy ( 2 + 2 )
let actualValue = Lazy.force lazyValue
printfn "%i" actualValue
第一行简单地延迟表达式留着以后计算；第二行强制计算；最后，打印结果。
延迟计算的值已经被缓存起来了，因此，所有计算这个值时所发生的任何副作用，都只会在第一次强制计算时发生。这是很容易演示的，看下面的示例。
let lazySideEffect =
lazy
( let temp = 2 + 2
printfn "%i"temp
temp )
printfn "Force value the first time: "
let actualValue1 = Lazy.force lazySideEffect
printfn "Force value the second time: "
let actualValue2 = Lazy.force lazySideEffect
在这个示例中，有一个延迟值在计算时会有副作用：值会写到控制台。为了演示这个副作用只会发生一次，我们强制这个值计算两次。正如你从结果中所看到的，写到台只发生一次：
Force value the first time:
4
Force value the second time:
延迟计算在处理集合时也是有用的。延迟集合的思想是这样的：集合中的元素只在需要时才计算，一些集合也可以缓存这些计算，因此，不需要重新计算元素。F# 编程中，最常用的延迟计算的集合是 seq 类型，它是 BCL IEnumerable 类型的简写。创建和操作 seq 值，使用 Seq 模块中的函数。还有其他许多值也与 seq 类型兼容，例如，所有 F# 的列表和数组，以及 F# 库函数和 .NET BCL 中的大多数集合类型都与 seq 兼容。
创建延迟集合最重要的函数，也是最难于理解的，可能就是 unfold 了。这个函数可以创建延迟列表，它的难点在于，你必须提供一个函数，用于对列表中的所有元素进行重复计算。传递给 Seq.unfold 的这个函数的可以是任意类型，返回的结果是可选（option）类型。可选类型是联合类型，可能是 None，也可能是 Some(x)，这里的 x 是任意类型的值。None 列表的结尾；Some 构造器必须包含一个元组，元组中的第一个项表示将会成为这个列表中第一个值的值；元组中的第二项是将会传递到函数，用于下一次调用的值，可以把这个值看作是一个累加器。
下面的示例演示这个函数的工作原理。标识符 lazyList 将包含三个值.如果传递给函数的值小于13，它将把这个值追加到列表，形成列表的元素；然后，这个值再加1，传递给列表；这将成为传递给下次被调用的函数的值。如果这个值大于或等于 13，通过返回 None，终止列表。
// the lazy list definition
let lazyList =
Seq.unfold
(fun x ->
if x < 13 then
// if smaller than the limit return
// the current and next value
Some(x, x + 1)
else
// if great than the limit
// terminate the sequence
None)
10
// print the results
printfn "%A" lazyList
示例运行结果如下：
10
11
12
序列可以用来表示无穷列表，无穷列表不能用传统的列表表示，因为它受可用内存数量的限制。下面的示例通过创建 fibs 进行演示，斐波那契数的就是一个无穷列表。为了方便看到结果，示例使用了 Seq.take 函数，把序列的前 20 项转换成列表，但是，实际计算的斐波那契数远远不止这些，因为使用了 F# 的 bigint 整数，因此，不受 32 位整数的限制。
// create an infinite list of Fibonacci numbers
let fibs =
Seq.unfold
(fun (n0, n1) ->
Some(n0, (n1, n0 + n1)))
(1I,1I)
// take the first twenty items from the list
let first20 = Seq.take 20 fibs
// print the finite list
printfn "%A" first20
示例的运行结果如下：
[1I; 1I; 2I; 3I; 5I; 8I; 13I; 21I; 34I; 55I; 89I; 144I; 233I; 377I;610I; 987I;
1597I; 2584I; 4181I; 6765I]
注意，这两个序列也可以用本章介绍的列表推导进行创建，如果列表推导基于序列，那么，它自动就是延迟的。
第三章小结
在这一章，我们学习了 F#中主要的函数编程构造，它是语言的核心，至此，我们对如何用 F# 写算法和处理数据应该已经有一个良好的感觉。下一章我们要讨论命令式编程，学习如何把函数式和命令式编程技术结合起来，共同处理任务，比如输入和输出。
原文：http://blog.csdn.net/hadstj/article/details/21633885