Object Expression as Computation Builder

Given a generic interface declaration like

type IFoo<'T,'MT> =
    abstract Return : 'T -> 'MT
    abstract Bind : 'MT * ('T -> 'MT) -> 'MT

it's actually possible to use object expressions as computation builder expressions, which could provide for an interesting approach to the division between encapsulation and execution logic of monadic workflows.

let inline addOption mx my = 
    {   new IFoo<_,_> with
        member __.Return x = Some x
        member __.Bind(ma, f) = Option.bind f ma }
        {   let! x = mx
            let! y = my
            return x + y }
// val inline addOption :
//   mx: ^a option -> my: ^a option ->  ^a option
//     when  ^a : (static member ( + ) :  ^a *  ^a ->  ^a)

addOption (Some 1) (Some 2)
// val it : int option = Some 3
addOption None (Some 2)
// val it : int option = None

The compiler checks on the type of the expression if the expected methods are present. But it is only halfway there; because for real monads, I would need to get the method signature abstract Bind : 'MT * ('T -> 'MU) -> 'MU honoured, a projection to a different non-encapsulated type. Why can't this be done?

链接地址: http://www.djcxy.com/p/24426.html

上一篇: 撤消部分未分档的git变更

下一篇: 作为计算生成器的对象表达式