Implementing a builder: Combine

原文地址：点击这里

本篇我们继续讨论从一个使用Combine方法的computation expression中返回多值。

前面的故事

到现在为止，我们的表达式建造（builder）类如下

type TraceBuilder() =
    member this.Bind(m, f) =
        match m with
        | None ->
            printfn "Binding with None. Exiting."
        | Some a ->
            printfn "Binding with Some(%A). Continuing" a
        Option.bind f m
 
    member this.Return(x) =
        printfn "Returning a unwrapped %A as an option" x
        Some x
 
    member this.ReturnFrom(m) =
        printfn "Returning an option (%A) directly" m
        m
 
    member this.Zero() =
        printfn "Zero"
        None
 
    member this.Yield(x) =
        printfn "Yield an unwrapped %A as an option" x
        Some x
 
    member this.YieldFrom(m) =
        printfn "Yield an option (%A) directly" m
        m
 
// make an instance of the workflow
let trace = new TraceBuilder()

这个类到现在工作正常。但是，我们即将看到一个问题

两个‘yield’带来的问题

之前，我们看到yield可以像return一样返回值。

通常来说，yield不会只使用一次，而是使用多次，以便在一个过程中的不同阶段返回多个值，如枚举（enumeration）。如下代码所示

trace {
    yield
    yield
    } |> printfn "Result for yield then yield: %A" 

但是运行这段代码，我们获得一个错误

This control construct may only be used if the computation expression builder defines a 'Combine' method.

并且如果你使用return来代替yield，你会获得同样的错误

trace {
    return
    return
    } |> printfn "Result for return then return: %A" 

在其他上下文中，也同样会有这个错误，比如我们想在做某事后返回一个值，如下代码

trace {
    if true then printfn "hello"
    return
    } |> printfn "Result for if then return: %A" 

我们会获得同样的错误。

理解这个问题

那这里该怎么办呢？

为了帮助理解，我们回到computation expression的后台视角，我们能看到return和yield是一系列计算的最后一步，就比如

Bind(,fun x ->
   Bind(,fun y ->
     Bind(x + y,fun z -> 

        Return(z)  // or Yield

可以将return（或yield）看成是对行首缩进的复位，那样当我们再次return/yield时，我们可以这么写代码

Bind(,fun x ->
   Bind(,fun y ->
     Bind(x + y,fun z ->
        Yield(z)
// start a new expression
Bind(,fun w ->
   Bind(,fun u ->
     Bind(w + u,fun v ->
        Yield(v)

然而这段代码可以被简化成

let value1 = some expression
let value2 = some other expression

也就是说，我们在computation expression中有两个值，现在问题很明显，如何让这两个值结合成一个值作为整个computation expression的返回结果？

这是一个关键点。对单个computation expression，return和yield不提前返回。Computation expression的每个部分总是被计算——不会有短路。如果我们想短路并提前返回，我们必须写代码来实现。

回到刚才提出的问题。我们有两个表达式，这两个表达式有两个结果值：如何将多个值结合到一个值里面？

介绍"Combine"

上面问题的答案就是使用“combine”方法，这个方法输入参数为两个包装类型值，然后将这两个值结合生成另外一个包装值。

在我们的例子中，我们使用int option，故一个简单的实现就是将数字加起来。每个参数是一个option类型，需要考虑四种情况，代码如下

type TraceBuilder() =
    // other members as before
 
    member this.Combine (a,b) =
        match a,b with
        | Some a', Some b' ->
            printfn "combining %A and %A" a' b'
            Some (a' + b')
        | Some a', None ->
            printfn "combining %A with None" a'
            Some a'
        | None, Some b' ->
            printfn "combining None with %A" b'
            Some b'
        | None, None ->
            printfn "combining None with None"
            None
 
// make a new instance
let trace = new TraceBuilder()

运行测试代码

trace {
    yield
    yield
    } |> printfn "Result for yield then yield: %A" 

然而，这次却获得了一个不同的错误

This control construct may only be used if the computation expression builder defines a 'Delay' method

Delay方法类似一个钩子，使computation expression延迟计算，直到需要用到其值时才进行计算。一会我们将讨论这其中的细节。现在，我们创建一个默认实现

type TraceBuilder() =
    // other members as before
 
    member this.Delay(f) =
        printfn "Delay"
        f()
 
// make a new instance
let trace = new TraceBuilder()

再次运行测试代码

trace {
    yield
    yield
    } |> printfn "Result for yield then yield: %A" 

最后我们获得结果如下

Delay
Yield an unwrapped  as an option
Delay
Yield an unwrapped  as an option
combining  and
Result for yield then yield: Some 

整个工作流的结果为所有yield的和，即3。

如果在工作流中发生一个“错误”（例如，None），那第二个yield不发生，总的结果为Some 1

trace {
    yield
    let! x = None
    yield
    } |> printfn "Result for yield then None: %A" 

使用三个yield

trace {
    yield
    yield
    yield
    } |> printfn "Result for yield x 3: %A" 

结果如期望，为Some 6

我们甚至可以混用yield和return。除了语法不同，结果是相同的

trace {
    yield
    return
    } |> printfn "Result for yield then return: %A" 
 
trace {
    return
    return
    } |> printfn "Result for return then return: %A" 

使用Combine实现顺序产生结果

将数值加起来不是yield真正的目的，尽管你也可以使用yield类似地将字符串连接起来，就像StringBuilder一样。

yield更一般地是用来顺序产生结果，现在我们已经知道Combine，我们可以使用Combine和Delay方法来扩展“ListBuilder”工作流

• Combine方法是连接list
• Delay方法使用默认的实现

整个建造类如下

type ListBuilder() =
    member this.Bind(m, f) =
        m |> List.collect f
 
    member this.Zero() =
        printfn "Zero"
        []
 
    member this.Yield(x) =
        printfn "Yield an unwrapped %A as a list" x
        [x]
 
    member this.YieldFrom(m) =
        printfn "Yield a list (%A) directly" m
        m
 
    member this.For(m,f) =
        printfn "For %A" m
        this.Bind(m,f)
 
    member this.Combine (a,b) =
        printfn "combining %A and %A" a b
        List.concat [a;b]
 
    member this.Delay(f) =
        printfn "Delay"
        f()
 
// make an instance of the workflow
let listbuilder = new ListBuilder()

下面使用它的代码

listbuilder {
    yield
    yield
    } |> printfn "Result for yield then yield: %A" 
 
listbuilder {
    yield
    yield! [;]
    } |> printfn "Result for yield then yield! : %A" 

以下是一个更为复杂的例子，这个例子使用了for循环和一些yield

listbuilder {
    for i in ["red";"blue"] do
        yield i
        for j in ["hat";"tie"] do
            yield! [i + " " + j;"-"]
    } |> printfn "Result for for..in..do : %A" 

然后结果为

["red"; "red hat"; "-"; "red tie"; "-"; "blue"; "blue hat"; "-"; "blue tie"; "-"]

可以看到，结合for..in..do和yield，我们已经很接近内建的seq表达式语法了（当然，除了不像seq那样的延迟特性）。

我强烈建议你再回味一下以上那些内容，直到非常清楚在那些语法的背后发生了什么。正如你在上面的例子中看到的一样，你创造性地可以使用yeild产生各种不规则list，而不仅仅是简单的list

说明：如果想知道while，我们将延后一些，直到我们在下一篇中讲完了Delay之后再来讨论while。

"Combine"处理顺序

Combine方法只有两个输入参数，那如果组合多个两个的值呢？例如，下面代码组合4个值

listbuilder {
    yield
    yield
    yield
    yield
    } |> printfn "Result for yield x 4: %A" 

如果你看输出，你将会知道是成对地组合值

combining [] and []
combining [] and [; ]
combining [] and [; ; ]
Result for yield x : [; ; ; ]

更准确地说，它们是从最后一个值开始，向后被组合起来。“3”和“4”组合，结果再与“2”组合，如此类推。

无序的Combine

在之前的第二个有问题的例子中，表达式是无序的，我们只是让两个独立的表达式处于同一行中

trace {
    if true then printfn "hello"  //expression 1
    return                       //expression 2
    } |> printfn "Result for combine: %A"

此时，如何组合组合表达式？

有很多通用的方法，具体是哪种方法还依赖于工作流想实现什么目的。

为有“success”或“failure”的工作流实现combine

如果工作流有“success”或者“failure”的概念，则一个标准的方法是：

• 如果第一个表达式“succeeds”（执行成功），则使用表达式的值
• 否则，使用第二个表达式的值

在本例中，我们通常对Zero使用“failure”值。

在将一系列的“or else”表达式链接起来时，这个方法非常有用，第一个成功的表达式的值将成为整体的返回值。

if (do first expression)
or else (do second expression)
or else (do third expression)

例如对maybe工作流，如果第一个表达式结果是Some，则返回第一个表达式的值，否则返回第二个表达式的值，如下所示

type TraceBuilder() =
    // other members as before
 
    member this.Zero() =
        printfn "Zero"
        None  // failure
 
    member this.Combine (a,b) =
        printfn "Combining %A with %A" a b
        match a with
        | Some _ -> a  // a succeeds -- use it
        | None -> b    // a fails -- use b instead
 
// make a new instance
let trace = new TraceBuilder()

例子：解析

试试一个有解析功能的例子，其实现如下

type IntOrBool = I of int | B of bool
 
let parseInt s =
    match System.Int32.TryParse(s) with
    | true,i -> Some (I i)
    | false,_ -> None
 
let parseBool s =
    match System.Boolean.TryParse(s) with
    | true,i -> Some (B i)
    | false,_ -> None
 
trace {
    return! parseBool ""  // fails
    return! parseInt ""
    } |> printfn "Result for parsing: %A"

结果如下

Some (I )

可以看到第一个return！表达式结果为None，它被忽略掉，所以整个表达式结果为第二个表达式的值，Some (I 42)

例子：查字典

在这个例子中，我们在一些字典中查询一些键，并在找到对应的值的时候返回

let map1 = [ ("","One"); ("","Two") ] |> Map.ofList
let map2 = [ ("A","Alice"); ("B","Bob") ] |> Map.ofList
 
trace {
    return! map1.TryFind "A"
    return! map2.TryFind "A"
    } |> printfn "Result for map lookup: %A" 

结果如下

Result for map lookup: Some "Alice"

可以看到，第一个查询结果为None，它被忽略掉，故整个语句结果为第二次查询结果值

从上面的讨论可见，这个技术在解析或者计算一系列操作（可能不成功）时非常方便。

为带有顺序步骤的工作流实现“combine”

如果工作流的操作步骤是顺序的，那整体的结果就是最后一步的值，而前面步骤的计算仅是为了获得边界效应（副作用，如改变某些变量的值）。

通常在F#中，顺序步骤可能会写成这样

do some expression
do some other expression
final expression

或者使用分号语法，即

some expression; some other expression; final expression

在普通的F#语句中，最后一个表达式除外的每个表达式的计算结果值均为unit。

Computation expression的等效顺序操作是将每个表达式（最后一个表达式除外）看成一个unit的包装类型值，然后将这个值传入下一个表达式，如此类推，直到最后一个表达式。

这就跟bind所做的事情差不多，所以最简单的实现就是再次利用Bind方法。当然，这里Zero就是unit的包装值

type TraceBuilder() =
    // other members as before
 
    member this.Zero() =
        printfn "Zero"
        this.Return ()  // unit not None
 
    member this.Combine (a,b) =
        printfn "Combining %A with %A" a b
        this.Bind( a, fun ()-> b )
 
// make a new instance
let trace = new TraceBuilder()

与普通的bind不同的是，这个continuation有一个unit类型的输入，然后计算b。这反过来要求a是WrapperType<unit>类型，或者更具体地，如我们这里例子中的unit option

以下是一个顺序过程的例子，实现了Combine

trace {
    if true then printfn "hello......."
    if false then printfn ".......world"
    return
    } |> printfn "Result for sequential combine: %A" 

输出结果为

hello.......
Zero
Returning a unwrapped <null> as an option
Zero
Returning a unwrapped <null> as an option
Returning a unwrapped  as an option
Combining Some null with Some
Combining Some null with Some
Result for sequential combine: Some 

注意整个语句的结果是最后一个表达式的值。

为创建数据结构的工作流实现“combine”

最后，还有一个工作流的常见模式是创建数据结构。在这种情况下，Combine应该合并两个数据结构，并且如果需要的话（如果可能），Zero方法应该创建一个空数据结构。

在前面的“list builder”例子中，我们使用的就是这个方法。Combine结合两个列表，并且Zero是空列表。

混合“Combine”与“Zero”的说明

我们已经看到关于option类型的两种不同的Combine实现。

• 第一个使用options指示“success/failure”，第一个成功的表达式结果即为最终的结果值，在这个情况下，Zero被定义成None。
• 第二个是顺序步骤操作的例子，在这种情况下，Zero被定义成Some ()

两种情况均能良好的工作，但是这两个例子是否只是侥幸能正常工作？有没有关于正确实现Combine和Zero的指导说明？

首先，如果输入参数交换位置，Combine不必返回相同的结果值，即，Combine(a,b)和Combine(b,a)不需要相同。“list builder”就是一个很好的例子

另外，把Zero与Combine连接起来是很有用的。

规则：Combine(a,Zero)应该与Combine(Zero,a)相同，而Combine(Zero,a)应该与a相同。

为了使用算法的类比，你可以把Combine看成加法（这不是一个差劲的类比——它确实将两个值相加）。当然，Zero就是数字0，故上面的这条规则可以表述成：

规则：a+0与0+a相同，与a相同，而+表示Combine，0表示Zero。

如果你观察有关option类型的第一个Combine实现（“success/failure”），你会发现它确实与这条规则符合，第二个实现（“bind” with Some()）也是如此。

另外一方面，如果我们已经使用“bind”来实现Combine，将Zero定义成None，则它不遵循这个规则，这意味着我们已经碰到一些错误。

不带bind的“Combine”

关于其他的builder方法，如果不需要它们，则不必实现这些方法。故对一个严格顺序的工作流而言，可以简单地创建一个包含Combine、Zero和Yield方法的建造类（builder class），也就是，不用实现Bind和Return。

以下是一个最简单的实现

type TraceBuilder() =
 
    member this.ReturnFrom(x) = x
 
    member this.Zero() = Some ()
 
    member this.Combine (a,b) =
        a |> Option.bind (fun ()-> b )
 
    member this.Delay(f) = f()
 
// make an instance of the workflow
let trace = new TraceBuilder()

使用方法如下

trace {
    if true then printfn "hello......."
    if false then printfn ".......world"
    return! Some
    } |> printfn "Result for minimal combine: %A" 

类似地，如果你有一个面向数据结构的工作流，可以只实现Combine和其他一些帮助方法。例如，以下为一个list builder类的简单实现

type ListBuilder() =
 
    member this.Yield(x) = [x]
 
    member this.For(m,f) =
        m |> List.collect f
 
    member this.Combine (a,b) =
        List.concat [a;b]
 
    member this.Delay(f) = f()
 
// make an instance of the workflow
let listbuilder = new ListBuilder()

尽管这是最简单的实现，我们依然可以如下写使用代码

listbuilder {
    yield
    yield
    } |> printfn "Result: %A" 
 
listbuilder {
    for i in [..] do yield i +
    yield
    } |> printfn "Result: %A"

独立的Combine函数

在上一篇中，我们看到“bind”函数通常被当成一个独立函数来使用，并用操作符 >>= 来表示。

Combine函数亦是如此，常被当成一个独立函数来使用。跟bind不同的是，Combine没有一个标准符号——它可以变化，取决于combine函数的用途。

一个符号化的combination操作通常写成 ++ 或者 <+>。我们之前对options使用的“左倾”的combination（即，如果第一个表达式失败，则只执行第二个表达式）有时候写成 <++。

以下是一个关于options的独立的左倾combination，跟上面那个查询字典的例子类似。

module StandaloneCombine = 
 
    let combine a b =
        match a with
        | Some _ -> a  // a succeeds -- use it
        | None -> b    // a fails -- use b instead
 
    // create an infix version
    let ( <++ ) = combine
 
    let map1 = [ ("","One"); ("","Two") ] |> Map.ofList
    let map2 = [ ("A","Alice"); ("B","Bob") ] |> Map.ofList
 
    let result =
        (map1.TryFind "A")
        <++ (map1.TryFind "B")
        <++ (map2.TryFind "A")
        <++ (map2.TryFind "B")
        |> printfn "Result of adding options is: %A"

总结

这篇文章中我们学到Combine的哪些内容？

• 如果在一个computation expression中需要combine或者“add”不止一个的包装类型值，则需要实现Combine（和Delay）
• Combine方法从后往前地将值成对地结合起来
• 没有一个通用的Combine实现能处理所有情况——需要根据工作流具体的需要定义不同的Combine实现
• 有将Combine关系到Zero的敏感规则
• Combine不依赖Bind的实现
• Combine可以被当成一个独立的函数暴露出来

下一篇中，当计算内部的表达式时，我们增加一些逻辑控制，并引入正确的短路和延迟计算。