如何在可能的计算构建器中实现延迟？

Question

这是我目前所拥有的：

type Maybe<'a> = option<'a>

let succeed x = Some(x)

let fail = None

let bind rest p =
    match p with
        | None -> fail
        | Some r -> rest r

let rec whileLoop cond body =
    if cond() then
        match body() with
        | Some() ->
            whileLoop cond body
        | None ->
            fail
    else
        succeed()

let forLoop (xs : 'T seq) f =
    using (xs.GetEnumerator()) (fun it ->
            whileLoop
                (fun () -> it.MoveNext())
                (fun () -> it.Current |> f)
        )

whileLoop 可以很好地支持 for 循环，但我不知道如何获得支持的 while 循环。部分问题是while循环的翻译使用delay，在这种情况下我无法弄清楚。下面明显的实现可能是错误的，因为它不会延迟计算，而是运行它！

let delay f = f()

没有延迟也会阻碍try...with 和try...finally。

Answer 1

在 F# 中实现延续构建器实际上有两种不同的方式。一种是使用 monadic 类型表示延迟计算（如果它支持某种表示延迟计算的方式，如 Async<'T> 或 kkm 所示的 unit -> option<'T> 类型。

但是，您也可以使用 F# 计算表达式的灵活性，并使用不同的类型作为返回值 Delay。然后您需要相应地修改Combine 操作并实现Run 成员，但这一切都很好：

type OptionBuilder() = 
  member x.Bind(v, f) = Option.bind f v
  member x.Return(v) = Some v
  member x.Zero() = Some ()
  member x.Combine(v, f:unit -> _) = Option.bind f v
  member x.Delay(f : unit -> 'T) = f
  member x.Run(f) = f()
  member x.While(cond, f) =
    if cond() then x.Bind(f(), fun _ -> x.While(cond, f)) 
    else x.Zero()

let maybe = OptionBuilder()

诀窍是 F# 编译器在您有需要延迟的计算时使用 Delay - 即：1) 包装整个计算，2) 当您按顺序组合计算时，例如在计算中使用 if 和 3) 延迟 while 或 for 的主体。

在上面的定义中，Delay 成员返回unit -> M<'a> 而不是M<'a>，但这很好，因为Combine 和While 将unit -> M<'a> 作为第二个参数。此外，通过添加评估函数的Run，评估maybe { .. }块（延迟函数）的结果，因为整个块被传递给Run：

// As usual, the type of 'res' is 'Option<int>'
let res = maybe { 
    // The whole body is passed to `Delay` and then to `Run`
    let! a = Some 3
    let b = ref 0
    while !b < 10 do 
      let! n = Some () // This body will be delayed & passed to While
      incr b
    if a = 3 then printfn "got 3"
    else printfn "got something else"
    // Code following `if` is delayed and passed to Combine
    return a }

这是一种为非延迟类型定义计算构建器的方法，它很可能比在函数内包装类型更有效（如在 kkm 的解决方案中），并且不需要定义该类型的特殊延迟版本。

请注意，此问题不会发生在例如Haskell，因为那是一种惰性语言，所以它不需要显式地延迟计算。我认为 F# 翻译非常优雅，因为它允许处理延迟的类型（使用返回 M<'a> 的 Delay）和仅表示立即结果的类型（使用返回函数的 Delay 和 @987654345 @)。

Answer 2

根据一元身份，您的delay 应始终等价于

let delay f = bind (return ()) f

自从

val bind : M<'T> -> ('T -> M<'R>) -> M<'R>
val return : 'T -> M<'T>

delay 的签名是

val delay : (unit -> M<'R>) -> M<'R>

'T 被类型绑定到unit。请注意，您的 bind 函数的参数与习惯顺序 bind p rest 相反。这在技术上是相同的，但确实使阅读代码变得复杂。

由于您将一元类型定义为type Maybe<'a> = option<'a>，因此不会延迟计算，因为该类型根本不包含任何计算，只有一个值。因此，您将延迟定义为let delay f = f() 在理论上是正确的。但这对于 while 循环是不够的：循环的“主体”将在其“测试条件”之前计算，实际上是在绑定 bind 之前。为避免这种情况，您需要使用额外的延迟层重新定义 monad：您无需包装一个值，而是包装一个计算，该计算采用一个单位并计算该值。

type Maybe<'a> = unit -> option<'a>

let return x = fun () -> Some(x)

let fail = fun() -> None

let bind p rest =
    match p() with
    | None -> fail
    | Some r -> rest r

请注意，包裹的计算直到在 bind 函数内部才会运行，即。 e.直到 bind 的参数被绑定后才运行。

使用上面的表达式，delay 正确简化为

let delay f = fun () -> f()