Facebook Twitter LinkedIn E-mail
magnify
Home F# F#开发教程(13):函数化编程(十二)
formats

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

Published on 2016 年 08 月 29 日

延迟计算

伴随函数化编程的是延迟计算。理论上认为,如果一个语言没有“副作用”的话,那么编译器或是程序运行时可以自由选择表达式的计算顺序。
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; ...]
 
Tags:
 Share on Facebook Share on Twitter Share on Reddit Share on LinkedIn