3

我遇到了这个关于 F# 中“末日金字塔”的问题。那里接受的答案涉及使用活动模式，但是我的理解是它也可以使用计算表达式来解决。

如何使用计算表达式从此代码中删除“厄运金字塔”？

match a.TryGetValue(key) with
| (true, v) -> v
| _ -> 
  match b.TryGetValue(key) with
  | (true, v) -> v
  | _ -> 
    match c.TryGetValue(key) with
    | (true, v) -> v
    | _ -> defaultValue
4

3 回答 3

7

F# for fun and profit有一个针对这种特定情况的示例：

type OrElseBuilder() =
    member this.ReturnFrom(x) = x
    member this.Combine (a,b) = 
        match a with
        | Some _ -> a  // a succeeds -- use it
        | None -> b    // a fails -- use b instead
    member this.Delay(f) = f()

let orElse = new OrElseBuilder()

但是如果你想使用它，IDictionary你需要一个返回选项的查找函数：

let tryGetValue key (d:System.Collections.Generic.IDictionary<_,_>) =
    match d.TryGetValue key with
    | true, v -> Some v
    | false, _ -> None

现在这里是一个修改后的例子，它从F# 中用于乐趣和利润：

let map1 = [ ("1","One"); ("2","Two") ] |> dict
let map2 = [ ("A","Alice"); ("B","Bob") ] |> dict
let map3 = [ ("CA","California"); ("NY","New York") ] |> dict

let multiLookup key = orElse {
    return! map1 |> tryGetValue key
    return! map2 |> tryGetValue key
    return! map3 |> tryGetValue key
    }

multiLookup "A" // Some "Alice"
于 2017-11-22T11:42:35.813 回答
5

如果我们颠覆该方法，则可以实现短路表达式Bind，在这种情况下，我们可以简单地忽略其余的计算并将其替换为成功的匹配。此外，我们可以满足bool*string标准字典查找的签名。

type OrElseBuilder() =
    member __.Return x = x
    member __.Bind(ma, f) =
        match ma with
        | true, v -> v
        | false, _ -> f ()

let key = 2 in OrElseBuilder() {
    do! dict[1, "1"].TryGetValue key
    do! dict[2, "2"].TryGetValue key
    do! dict[3, "3"].TryGetValue key
    return "Nothing found" }
// val it : string = "2"
于 2017-11-22T20:30:33.110 回答
5

我喜欢“末日金字塔”移除的模式是这样的：

1) 创建一个惰性输入集合 2) 使用计算函数映射它们 3) 跳过所有产生不可接受结果的计算 4) 选择第一个符合您的标准的计算。

但是，这种方法不使用计算表达式

open System.Collections

let a = dict [1, "hello1"]
let b = dict [2, "hello2"]
let c = dict [2, "hello3"]

let valueGetter (key:'TKey) (d:Generic.IDictionary<'TKey, 'TVal>) =
    (
        match d.TryGetValue(key) with
        | (true, v) -> Some(v)
        | _ -> None
    )

let dicts = Seq.ofList [a; b; c] // step 1

let computation data key =
    data
    |> (Seq.map (valueGetter key)) // step 2
    |> Seq.skipWhile(fun x -> x = None) // step 3
    |> Seq.head // step 4

computation dicts 2
于 2017-11-22T12:31:48.870 回答