Understanding continuations
原文地址http://fsharpforfunandprofit.com/posts/computation-expressions-continuations/
上一篇中我们看到复杂代码是如何通过使用computation expressions得到简化。
使用computation expression前的代码
let log p = printfn "expression is %A" p let loggedWorkflow = let x = 42 log x let y = 43 log y let z = x + y log z //return z
使用computation expression后的代码
let loggedWorkflow = logger { let! x = 42 let! y = 43 let! z = x + y return z }
这里使用的是let!(let bang)而非普通的let。我们是否可以自己来模拟let!从而深入理解这里面到底发生了什么?当然可以,不过我们首先需要搞懂什么是continuations
Continuations
命令式编程中,一个函数中有“returning”的概念。当调用一个函数时,先进入这个函数,然后退出,类似于入栈和出栈。
典型的C#代码
public int Divide(int top, int bottom) { if (bottom==0) { throw new InvalidOperationException("div by 0"); } else { return top/bottom; } } public bool IsEven(int aNumber) { var isEven = (aNumber % 2 == 0); return isEven; }
这样的函数我们已经很熟悉了,但是也许我们未曾考虑过这样一个问题:被调用的函数本身就决定了要做什么事情。
例如,函数Divide的实现就决定了可能会抛出一个异常,但如果我们不想得到一个异常呢?也许是想得到一个nullable<int>,又或者是将有关信息打印到屏幕如"#DIV/0"。简单来说,为什么不能由函数调用者而非函数自身来决定应该怎么处理。
IsEven函数也是如此,对于其返回的boolean类型的值我们将如何处理?对它进行分支讨论,还是打印到报告中?比起返回一个boolean类型的值让调用者来处理,为什么不考虑让调用者告诉被调用方下一步如何处理。
这就是continuation,它是一个简单的函数,你可以向其中传入另一个函数来指示下一步该做什么。
重写刚才的C#代码,由调用方传入一个函数,被调用方用这个函数来处理一些事情。
public T Divide<T>(int top, int bottom, Func<T> ifZero, Func<int,T> ifSuccess) { if (bottom==0) { return ifZero(); } else { return ifSuccess( top/bottom ); } } public T IsEven<T>(int aNumber, Func<int,T> ifOdd, Func<int,T> ifEven) { if (aNumber % 2 == 0) { return ifEven(aNumber); } else { return ifOdd(aNumber); } }
嗯,在C#中,传入太多的Func类型的参数会使代码丑陋,所以C#中这不常见,但是在F#中使用则非常简单。
使用continuations前的代码
let divide top bottom = if (bottom=0) then invalidOp "div by 0" else (top/bottom) let isEven aNumber = aNumber % 2 = 0
使用continuations后的代码
let divide ifZero ifSuccess top bottom = if (bottom=0) then ifZero() else ifSuccess (top/bottom) let isEven ifOdd ifEven aNumber = if (aNumber % 2 = 0) then aNumber |> ifEven else aNumber |> ifOdd
有几点说明。首先,函数参数靠前,如isZero作为第一个参数,isSuccess作为第二个参数。这会方便我们使用函数的部分应用 partial application。
其次,在isEven例子中,aNumber |> ifEven和aNumber |> ifOdd的写法表明我们将当前值加入到continuation的管道中,这篇文章的后面部分也会使用相同的模式。
Continuation的例子
采用推荐的Continuation方式,我们可以用三种不同的方式调用divide函数,这取决于调用者的意图。
以下是调用divide函数的三个应用场景:
1、将结果加入到消息管道并且打印
2、将结果转换成option,除法失败时返回None,除法成功时返回Some
3、除法失败时抛出异常,除法成功时返回结果值
// Scenario 1: pipe the result into a message // ---------------------------------------- // setup the functions to print a message let ifZero1 () = printfn "bad" let ifSuccess1 x = printfn "good %i" x // use partial application let divide1 = divide ifZero1 ifSuccess1 //test let good1 = divide1 6 3 let bad1 = divide1 6 0 // Scenario 2: convert the result to an option // ---------------------------------------- // setup the functions to return an Option let ifZero2() = None let ifSuccess2 x = Some x let divide2 = divide ifZero2 ifSuccess2 //test let good2 = divide2 6 3 let bad2 = divide2 6 0 // Scenario 3: throw an exception in the bad case // ---------------------------------------- // setup the functions to throw exception let ifZero3() = failwith "div by 0" let ifSuccess3 x = x let divide3 = divide ifZero3 ifSuccess3 //test let good3 = divide3 6 3 let bad3 = divide3 6 0
现在,调用者不需要到处对divide抓异常了。调用者决定一个异常是否被抛出,而不是被调用的函数决定是否抛出一个异常。即,如果调用者想对除法失败时抛出异常处理,则将isZero3函数传入到divide函数中。
同样的三个调用isEven的场景类似处理
// Scenario 1: pipe the result into a message // ---------------------------------------- // setup the functions to print a message let ifOdd1 x = printfn "isOdd %i" x let ifEven1 x = printfn "isEven %i" x // use partial application let isEven1 = isEven ifOdd1 ifEven1 //test let good1 = isEven1 6 let bad1 = isEven1 5 // Scenario 2: convert the result to an option // ---------------------------------------- // setup the functions to return an Option let ifOdd2 _ = None let ifEven2 x = Some x let isEven2 = isEven ifOdd2 ifEven2 //test let good2 = isEven2 6 let bad2 = isEven2 5 // Scenario 3: throw an exception in the bad case // ---------------------------------------- // setup the functions to throw exception let ifOdd3 _ = failwith "assert failed" let ifEven3 x = x let isEven3 = isEven ifOdd3 ifEven3 //test let good3 = isEven3 6 let bad3 = isEven3 5
此时,调用者不用到处对返回的boolean类型值使用if/then/else结构处理了,调用者想怎么处理,就将对应的处理函数作为参数传入divide函数中即可。
在 designing with types中,我们已经见识过continuations了。
type EmailAddress = EmailAddress of string let CreateEmailAddressWithContinuations success failure (s:string) = if System.Text.RegularExpressions.Regex.IsMatch(s,@"^\S+@\S+\.\S+$") then success (EmailAddress s) else failure "Email address must contain an @ sign"
测试代码如下
// setup the functions let success (EmailAddress s) = printfn "success creating email %s" s let failure msg = printfn "error creating email: %s" msg let createEmail = CreateEmailAddressWithContinuations success failure // test let goodEmail = createEmail "x@example.com" let badEmail = createEmail "example.com"
Continuation passing style
使用continuation将产生一种编程风格"continuation passing style" (CPS),其中,调用每个函数时,都有一个函数参数指示下一步做什么。
为了看到区别,我们首先看一个标准的直接风格的编程,进入和退出一个函数,如
call a function -> <- return from the function call another function -> <- return from the function call yet another function -> <- return from the function
在CPS中,则是用一个函数链
evaluate something and pass it into -> a function that evaluates something and passes it into -> another function that evaluates something and passes it into -> yet another function that evaluates something and passes it into -> ...etc...
直接风格的编程中,存在一个函数之间的层级关系。最顶层的函数类似于“主控制器”,调用一个分支,然后另一个,决定何时进行分支,何时进行循环等。
在CPS中,则不存在这样一个“主控制器”,而是有一个“管道”的控制流,负责单个任务的函数在其中按顺序依次执行。
如果你曾在GUI中附加一个事件句柄(event handler)到一个按钮单击,或者通过BeginInvoke使用回调,那你已经在无意中使用了CPS。事实上,这种风格是理解async工作流的关键,这一点会在以后的文章中讨论。
Continuations and 'let'
以上讨论的CPS等在let内部是如何组合的?
首先回顾(revisit)一下 let 的本质。
记住非顶级的let不能被外界访问,它总是作为其外层代码块的一部分存在。
let x = someExpression
真正含义是
let x = someExpression in [an expression involving x]
然后每次在第二个表达式(主体表达式)见到x,用第一个表达式(someExpression)替换。例如
let x = 42 let y = 43 let z = x + y
其实是指(使用in关键字)
let x = 42 in let y = 43 in let z = x + y in z // the result
有趣的是,有一个类似let的lambda
fun x -> [an expression involving x]
如果我们把x加入管道,则
someExpression |> (fun x -> [an expression involving x] )
是不是非常像let?下面是一个let和一个lambda
// let let x = someExpression in [an expression involving x] // pipe a value into a lambda someExpression |> (fun x -> [an expression involving x] )
两者都有x和someExpression,在lambda的主体的任何地方只有见到x就将它替换成someExpression。嗯,在lambda中,x和someExpression仅仅是位置反过来了,否则基本跟let基本一样了。
所以,我们也可以写成如下形式
42 |> (fun x -> 43 |> (fun y -> x + y |> (fun z -> z)))
当写成这种形式时,我们已经将let风格转变成CPS了。
代码说明:
- 第一行我们获取值42——如何处理?将它传入一个continuation,正如前面我们对isEven函数所做的一样。在此处的continuation上下文中,我们将42重写标为x
- 第二行我们有值43——如何处理?将它传入一个continuation,在这个上下文中,将它重新标为y
- 第三行我们把x和y加在一起创建一个新值——如何处理这个新值?再来一个continuation,并且再来一个标签z指示这个新值
- 最后完成并且整个表达式计算结果为z
包装continuation到一个函数中
我们想避开显式的管道操作(|>),而是用一个函数来包装这个逻辑。无法称这个函数为let因为let是一个保留字,更重要的是,let的参数位置是反过来的。注意,x在右边而someExpression在左边,所以现在称此函数为“pipeInto”,定义如下
let pipeInto (someExpression,lambda) = someExpression |> lambda
注意这里参数是一个元组而非两个独立的参数。使用pipeInto函数,我们可以重写上面的代码为
pipeInto (42, fun x -> pipeInto (43, fun y -> pipeInto (x + y, fun z -> z)))
去掉行首缩进则为
pipeInto (42, fun x -> pipeInto (43, fun y -> pipeInto (x + y, fun z -> z)))
也许你会认为:几个意思?为啥要包装管道符为一个函数咧?
答案是这样,我们可以添加额外的代码到pipeInto函数中来处理一些幕后事情,正如computation expression那样。
回顾“logging”例子
重新定义pipeInto,增加一个logging功能,如下
let pipeInto (someExpression,lambda) = printfn "expression is %A" someExpression someExpression |> lambda
如此,本篇一开始的代码则可重写为
pipeInto (42, fun x -> pipeInto (43, fun y -> pipeInto (x + y, fun z -> z )))
这段代码的输出
expression is 42 expression is 43 expression is 85
这跟早期的实现,输出结果相同。至此,我们已经实现了自己的小小的computation expression 工作流。
如果我们将这个pipeInto实现与computation expression版本比较,我们可以发现我们自己写的版本是非常接近let!的,除了将参数位置反过来了,还有就是有为了continuation而显式写的->符号。
回顾“安全除法”例子
先给出原先的代码
let divideBy bottom top = if bottom = 0 then None else Some(top/bottom) let divideByWorkflow x y w z = let a = x |> divideBy y match a with | None -> None // give up | Some a' -> // keep going let b = a' |> divideBy w match b with | None -> None // give up | Some b' -> // keep going let c = b' |> divideBy z match c with | None -> None // give up | Some c' -> // keep going //return Some c'
看看是否可以将额外的代码加入pipeInto函数。我们想要的逻辑是
如果someExpression参数为None,则不调用continuation lambda
如果someExpression参数是Some,则调用continuation lambda,传入Some的内容
逻辑实现如下
let pipeInto (someExpression,lambda) = match someExpression with | None -> None | Some x -> x |> lambda
使用这个版本的pipeInto函数,可以重写刚才的原始代码
let divideByWorkflow x y w z = let a = x |> divideBy y pipeInto (a, fun a' -> let b = a' |> divideBy w pipeInto (b, fun b' -> let c = b' |> divideBy z pipeInto (c, fun c' -> Some c' //return )))
可以将这段代码再简化一下。首先去除a,b,c,用divideBy表达式代替,即
let a = x |> divideBy y pipeInto (a, fun a' ->
变成
pipeInto (x |> divideBy y, fun a' ->
将a'重新标记为a,b和c类似处理,去除行首缩进,则代码变成
let divideByResult x y w z = pipeInto (x |> divideBy y, fun a -> pipeInto (a |> divideBy w, fun b -> pipeInto (b |> divideBy z, fun c -> Some c //return )))
最后,我们定义一个帮助函数return'用以包装一个值为一个option,全部代码如下
let divideBy bottom top = if bottom = 0 then None else Some(top/bottom) let pipeInto (someExpression,lambda) = match someExpression with | None -> None | Some x -> x |> lambda let return' c = Some c let divideByWorkflow x y w z = pipeInto (x |> divideBy y, fun a -> pipeInto (a |> divideBy w, fun b -> pipeInto (b |> divideBy z, fun c -> return' c ))) let good = divideByWorkflow 12 3 2 1 let bad = divideByWorkflow 12 3 0 1
比较我们自己实现的版本与computation expression版本,发现仅仅语法不同
总结
这篇文章中,我们讨论了continuation和continuation passing style(CPS),以及为什么认为let是一个优秀的语法,因为let在后台进行了continuation处理。
现在我们可以定义自己的let版本,下一篇我们将把这些付诸实际。