24

我所说的扩展计算表达式是指具有通过CustomOperation属性定义的自定义关键字的计算表达式。

在阅读扩展计算表达式时，我遇到了@kvb 的非常酷的 IL DSL：

let il = ILBuilder()

// will return 42 when called
// val fortyTwoFn : (unit -> int)
let fortyTwoFn = 
    il {
        ldc_i4 6
        ldc_i4_0
        ldc_i4 7
        add
        mul
        ret
    }

我想知道在不使用for..in..do构造的情况下如何组成操作。我的直觉是它从x.Zero成员开始，但我没有找到任何参考来验证这一点。

如果上面的例子技术性太强，这里有一个类似的 DSL，其中幻灯片的组件没有列出for..in..do：

page {
      title "Happy New Year F# community"
      item "May F# continue to shine as it did in 2012"
      code @"…"
      button (…)
} |> SlideShow.show

我有几个密切相关的问题：

  • 如何定义或使用没有For成员的扩展计算表达式（即提供一个小的完整示例）？如果它们不再是 monad，我不会太担心，我对它们开发 DSL 很感兴趣。
  • 我们可以使用let!和的扩展计算表达式return!吗？如果是，有什么理由不这样做吗？我问这些问题是因为我没有遇到任何使用let!and的例子return!。
4

2 回答 2

14

很高兴您喜欢 IL 示例。了解表达式如何脱糖的最佳方法可能是查看规范（尽管它有点密集......）。

在那里我们可以看到类似的东西

C {
    op1
    op2
}

脱糖如下：

T([<CustomOperator>]op1; [<CustomOperator>]op2, [], fun v -> v, true) ⇒
CL([<CustomOperator>]op1; [<CustomOperator>]op2, [], C.Yield(), false) ⇒
CL([<CustomOperator>]op2, [], 〚 [<CustomOperator>]op1, C.Yield() |][], false) ⇒
CL([<CustomOperator>]op2, [], C.Op1(C.Yield()), false) ⇒
〚 [<CustomOperator>]op2, C.Op1(C.Yield()) 〛[] ⇒
C.Op2(C.Op1(C.Yield()))

至于为什么Yield()使用而不是Zero，这是因为如果范围内有变量（例如，因为您使用了 some lets，或者在 for 循环中等），那么您会得到Yield (v1,v2,...)但Zero显然不能这样使用。请注意，这意味着let x = 1在 Tomas 的lr示例中添加多余的内容将无法编译，因为Yield将使用类型参数int而不是unit.

还有另一个技巧可以帮助理解计算表达式的编译形式，即 (ab) 使用 F# 3 中计算表达式的自动引用支持。只需定义一个无操作Quote成员并Run返回其参数：

member __.Quote() = ()
member __.Run(q) = q

现在您的计算表达式将评估为其脱糖形式的报价。这在调试时非常方便。

于 2013-01-02T22:13:38.567 回答
9

我不得不承认，当您使用属性等查询表达式功能时，我并不完全理解计算表达式的工作原理CustomOperation。但这里有一些来自我的一些实验的评论，可能会有所帮助......

首先，我认为不可能将标准计算表达式功能（return!等）与自定义操作自由组合。某些组合显然是允许的，但不是全部。例如，如果我定义了自定义操作left，return!然后我只能使用之前 return!的自定义操作：

// Does not compile              // Compiles and works
moves { return! lr               moves { left 
        left }                           return! lr }

至于只使用自定义操作的计算，最常见的自定义操作（orderBy和reverse这种）都有一个类型M<'T> -> M<'T>，其中M<'T>一些（可能是通用的）类型代表我们正在构建的东西（例如列表）。

例如，如果我们想构建一个表示左/右移动序列的值，我们可以使用以下Commands类型：

type Command = Left | Right 
type Commands = Commands of Command list

自定义操作left和right然后可以转换Commands为Commands新步骤并将其附加到列表的末尾。就像是：

type MovesBuilder() =
  [<CustomOperation("left")>]
  member x.Left(Commands c) = Commands(c @ [Left])
  [<CustomOperation("right")>]
  member x.Right(Commands c) = Commands(c @ [Right])

请注意，这与yield仅返回单个操作（或命令）不同，因此如果您使用自定义操作，则yield需要组合多个单独的步骤，然后您永远不需要组合任何内容，因为自定义操作会逐渐将值构建为一个整体。它只需要一些在开始时使用的初始空值......CombineCommands Commands

现在，我希望看到Zero那里，但它实际上Yield以 unit 作为参数调用，所以你需要：

member x.Yield( () ) = 
  Commands[]

我不确定为什么会这样，但Zero经常被定义为Yield ()，所以也许目标是使用默认定义（但正如我所说，我也希望在Zero这里使用......）

我认为将自定义操作与计算表达式相结合是有意义的。虽然我对如何使用标准计算表达式有强烈的看法，但我对自定义操作的计算并没有任何好的直觉——我认为社区仍然需要弄清楚这一点:-)。但例如，您可以像这样扩展上述计算：

member x.Bind(Commands c1, f) = 
  let (Commands c2) = f () in Commands(c1 @ c2)
member x.For(c, f) = x.Bind(c, f)
member x.Return(a) = x.Yield(a)

（在某些时候，翻译将开始需要Forand Return，但在这里它们可以像Bindand一样定义Yield- 我不完全理解什么时候使用了哪个替代项）。

然后你可以写这样的东西：

let moves = MovesBuilder()

let lr = 
  moves { left
          right }    
let res =
  moves { left
          do! lr
          left 
          do! lr }
于 2013-01-01T15:53:37.830 回答