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 =
    log x
    let y =
    log y
    let z = x + y
    log z
    //return
    z

使用computation expression后的代码

let loggedWorkflow =
    logger
        {
        let! x =
        let! y =
        let! z = x + y
        return z
        }

这里使用的是let!（let bang）而非普通的let。我们是否可以自己来模拟let!从而深入理解这里面到底发生了什么？当然可以，不过我们首先需要搞懂什么是continuations

Continuations

命令式编程中，一个函数中有“returning”的概念。当调用一个函数时，先进入这个函数，然后退出，类似于入栈和出栈。

典型的C#代码

public int Divide(int top, int bottom)
{
    if (bottom==)
    {
        throw new InvalidOperationException("div by 0");
    }
    else
    {
        return top/bottom;
    }
}

public bool IsEven(int aNumber)
{
    var isEven = (aNumber %  == );
    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==)
    {
        return ifZero();
    }
    else
    {
        return ifSuccess( top/bottom );
    }
}

public T IsEven<T>(int aNumber, Func<int,T> ifOdd, Func<int,T> ifEven)
{
    if (aNumber %  == )
    {
        return ifEven(aNumber);
    }
    else
    {   return ifOdd(aNumber);
    }
}

嗯，在C#中，传入太多的Func类型的参数会使代码丑陋，所以C#中这不常见，但是在F#中使用则非常简单。

使用continuations前的代码

let divide top bottom =
    if (bottom=)
    then invalidOp "div by 0"
    else (top/bottom)

let isEven aNumber =
    aNumber %  = 

使用continuations后的代码

let divide ifZero ifSuccess top bottom =
    if (bottom=)
    then ifZero()
    else ifSuccess (top/bottom)

let isEven ifOdd ifEven aNumber =
    if (aNumber %  = )
    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
let bad1 = divide1  

// 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
let bad2 = divide2  

// 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
let bad3 = divide3  

现在，调用者不需要到处对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
let bad1 = isEven1 

// 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
let bad2 = isEven2 

// 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
let bad3 = isEven3 

此时，调用者不用到处对返回的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 "[e-mail]"
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 =
let y =
let z = x + y

其实是指（使用in关键字）

let x =  in
  let y =  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基本一样了。

所以，我们也可以写成如下形式

 |> (fun x ->
   |> (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 (, fun x ->
  pipeInto (, fun y ->
    pipeInto (x + y, fun z ->
       z)))

去掉行首缩进则为

pipeInto (, fun x ->
pipeInto (, 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 (, fun x ->
pipeInto (, fun y ->
pipeInto (x + y, fun z ->
z
)))

这段代码的输出

expression is
expression is
expression is 

这跟早期的实现，输出结果相同。至此，我们已经实现了自己的小小的computation expression 工作流。

如果我们将这个pipeInto实现与computation expression版本比较，我们可以发现我们自己写的版本是非常接近let！的，除了将参数位置反过来了，还有就是有为了continuation而显式写的->符号。

回顾“安全除法”例子

先给出原先的代码

let divideBy bottom top =
    if bottom =
    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 =
    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
let bad = divideByWorkflow    

比较我们自己实现的版本与computation expression版本，发现仅仅语法不同

总结

这篇文章中，我们讨论了continuation和continuation passing style（CPS)，以及为什么认为let是一个优秀的语法，因为let在后台进行了continuation处理。

现在我们可以定义自己的let版本，下一篇我们将把这些付诸实际。