9

我试图通过实现我自己的一个来更多地了解 F# 的计算表达式。Bind但是，我遇到了与该方法相关的绊脚石。这是我到目前为止所得到的：

type public op<'a> = Op of ('a list -> 'a list)

let inline (>>) (Op a) (Op b) = Op (a >> b)

module Op =
    let id = Op id
    let bind (b : 'b -> op<'a>) (v : 'b) = b v
    let call (Op f) = f
    let push v = Op (fun t -> v :: t)
    // .. snip  ..

type OpBuilder() =
    member __.Bind (v, b) = Op.bind b v
    member __.Yield (()) = Op.id
    member __.Return (m) = Op.call m

    [<CustomOperation("push")>]
    member __.Push (m : op<'a>, v : 'a) = m >> Op.push v
    // .. snip  ..

let op = new OpBuilder()

现在，我的理解是以下所有内容应该大致等效：

// Use only the Op module methods
let f1 = Op.call(Op.bind (fun x -> Op.push x) 1)

// Use op builder with external closure
let f2 = Op.call(let x = 2 in op { push x })

// Use op builder bind explicitly
let f3 = op.Return(op.Bind(3, fun x -> op.Push(op.Yield(), x)))

// Use op builder with let! binding
let f4 = op { let! x = 4 in push x }

前 3 个似乎工作正常，但是，f4给出了这个错误：

这个表达式应该有
  单位类型
，但这里有
  int类型

如果我使用let而不是let!. 我读过的所有内容都表明这是实现的正确方法Bind，但显然我遗漏了一些东西。谁能指出我做错了什么？

4

2 回答 2

6

虽然为您提供喘息空间的适当解决方案包括使用评论中讨论的成熟状态单子，但您仍然可以从定义的 Op 类型中获得一些里程。您需要为它定义一种退化的构建器——它不是一个 monad，它本质上是一个“函数组合”构建器，但它对于do!.

因此，假设您有这样的 Op 类型：

type Op<'a> = 'a list -> 'a list

您像这样定义您的构建器 - 在 bind 和 return 中使用一个单元代替“正确”的未包装值 - 将其视为 state monad 类型中缺少的部分：

type OpBuilder() =
    member __.Bind (ma, f) = ma >> f ()
    member __.Return (_) = id

let op = new OpBuilder()

然后是操作：

[<AutoOpen>]
module Ops =

    let push (x:'a) : Op<'a> =  fun st -> x::st

    let dup: Op<'a> = fun st ->
        match st with
        | h::t -> h::h::t
        | [] -> []  

    let add: Op<int> = fun st ->
        match st with
        | a::b::t -> (a+b)::t
        | _ -> failwith "not enough operands"

最后：

let comp : Op<_> =
    op {
        do! push 2
        do! dup
        do! add
    }

comp []
于 2016-07-15T23:44:26.237 回答
6

如果您尝试实现类似基于堆栈的 DSL 之类的东西，那么计算表达式就不是一个很好的选择。您可以仅通过操作列表完美地表示这一点：

 type Op = 
  | Push of int
  | Dup
  | Add

let sample = 
  [ Push 2
    Dup
    Add ]

我也忍不住写了一个简单的评估器：

let rec eval stack ops = 
  match ops, stack with
  | (Push n)::ops, stack -> eval (n::stack) ops
  | Dup::ops, s::stack -> eval (s::s::stack) ops
  | Add::ops, s1::s2::stack -> eval ((s1+s2)::stack) ops
  | [], stack -> stack
  | _ -> failwith "Wrong arguments"

eval [] sample

如果您想为普通语言结构（如变量绑定let!、其他结构（如forand ）赋予一些特殊含义，则计算表达式很有用，或返回由ortry捕获的值。尽管您可以实现一些 Haskell monad，但这些在 F# 中并不是很有用 - 所以要找到一个有用的玩具示例来玩有点棘手。yieldreturn

于 2016-07-16T00:18:41.757 回答