F#开发教程(13):函数化编程(十二)

延迟计算

伴随函数化编程的是延迟计算。理论上认为，如果一个语言没有“副作用”的话，那么编译器或是程序运行时可以自由选择表达式的计算顺序。

F#允许函数有副作用，因此编译器或是运行时无法自由选择表达式的计算顺序。因此F#被认为具有严格的运算顺序。但是你仍然可以利用延迟计算，然而你必须指明哪些计算可以延后计算。也就是有有需要时才计算。

F#中使用lazy来定义一个延后计算。定义在延迟计算中的表达式只有在明确指明需要计算时才会计算。计算的结果保存在缓存中以后后续调用，而无需重新计算。

> let lazyValue = lazy ( 2+3);;

val lazyValue : Lazy<int> = Value is not created.

> lazyValue.Force();;
val it : int = 5

lazy 定义了一个延迟计算，后门一行强制计算，返回5. 要注意的是延迟表达式最多只会计算一次，计算后，结果被保存，即使结果抛出异常。比如下个例子

> let lazySideEffect = 
-     lazy 
-         (
-              let temp = 2 + 2
-              printfn "%i" temp
-              temp
-          );;

val lazySideEffect : Lazy<int> = Value is not created.

> lazySideEffect.Force();;
4
val it : int = 4
> lazySideEffect.Force();;
val it : int = 4

lazySideEffect表达式定义一个“副作用”，显示当前整数值，我们看以看到这段表达式只计算了一次，因此如果你依赖表达式的“副作用”来实现某些功能时，延迟计算可能就不太合适了。

延迟计算对于处理集合类型时比较有用，延迟集合类型的目的是只在需要集合的某个元素时才计算。F#中使用延迟计算的最常用的类型是序列Seq。

可能最重要也是最难理解的一个创建序列的函数是unfold。

// Signature:
Seq.unfold : ('State -> ('T * 'State) option) -> 'State -> seq<'T>

// Usage:
Seq.unfold generator state

如果我们联系起数列的递推公式，就可以比较容易的理解unfold。比如 Fibonacci数列的递推公式

S0=1; S1=1

Sn+2=Sn+ Sn+1

我们使用一个二元组作为参数（这里有两个初始值，二元组是个比较合适的类型）

> Seq.unfold ( fun state -> Some( fst state, ((snd state),(fst state)+(snd state)))) (1,1);;
val it : seq<int> = seq [1; 1; 2; 3; ...]

如果把state用二元组（ao,a1）的形式表示，可以简化为

> Seq.unfold ( fun (n0,n1) -> Some(n0,(n1,n0+n1))) (1,1);;
val it : seq<int> = seq [1; 1; 2; 3; ...]