有没有办法做不同的实现呢!让!在计算表达式中

Question

我需要一个不同的行为做!让!在我的自定义计算表达式。

我试图通过以下方式实现这一点:

type FooBuilder() = class
    member b.Bind<'T, 'U>(x:'T, f:unit->'U):'U = failwith "not implemented" //do! implementation
    member b.Bind<'T, 'U>(x:'T, f:'T->'U):'U = failwith "not implemented" //let! implementation
    member b.Return<'T>(x:'T):'T = failwith "not implemented" //return implementation
end
let foo = FooBuilder()
let x = foo {
    do! ()
    return 2
}

但是编译器给了我一个错误:

在此程序点之前，无法根据类型信息确定方法'Bind'的唯一重载。可用的重载如下所示(或在Error List窗口中)。可能需要类型注释。

是否有一种方法可以有不同的实现do!并让! ?

Answer 1

如果你想在let!中使用Bind操作，那么就没有办法说f#在转换do!时应该使用不同的实现(重载必须重叠)。

一般来说，如果您想获得let!和do!的不同行为，那么它表明您的计算表达式可能定义不正确。这个概念是非常灵活的，它可以用于更多的事情，而不仅仅是声明单子，但你可能会把它扩展得太远。如果你能写更多关于你想要达到的目标的信息，那将会很有用。无论如何，这里有一些可能的解决方法…

您可以添加一些额外的包装，并编写类似do! wrap <| expr的内容。

type Wrapped<'T> = W of 'T
type WrappedDo<'T> = WD of 'T
type FooBuilder() = 
  member b.Bind<'T, 'U>(x:Wrapped<'T>, f:'T->'U):'U = failwith "let!" 
  member b.Bind<'T, 'U>(x:WrappedDo<unit>, f:unit->'U):'U = failwith "do!"
  member b.Return<'T>(x:'T):Wrapped<'T> = failwith "return"
let wrap (W a) = WD a
let bar arg = W arg
let foo = FooBuilder()
// Thanks to the added `wrap` call, this will use the second overload
foo { do! wrap <| bar()
      return 1 }
// But if you forget to add `wrap` then you still get the usual `let!` implementation
foo { do! wrap <| bar()
      return 1 }

另一个选择是使用动态类型测试。这有点低效(也有点不美观)，但它可能会达到目的，这取决于您的场景:

member b.Bind<'T, 'U>(x:Wrapped<'T>, f:'T->'U):'U = 
  if typeof<'T> = typeof<unit> then 
    failwith "do!" 
  else 
    failwith "let!" 

但是，当您编写let! () = bar时，这仍然会使用do!过载。

Answer 2

您可以尝试其他方法，有点难看，但应该可以工作:

let bindU (x, f) = f x // you must use x, or it'll make the Bind method less generic.
let bindG (x, f) = f x
member b.Bind(x : 'a, f : 'a -> 'b) =
    match box x with
    | :? unit -> bindU (x, f)
    | _ -> bindG (x, f)

它将a(转换为obj)并检查它是否为unit类型，然后重定向到正确的过载