无法重用在计算表达式中分配的变量

Question

我正在尝试使用计算表达式来创建类似构建器的 DSL，但是当我尝试使用 let 分配来帮助组合事物时，我收到一个编译错误，即无法找到此类分配。这是一个例子：

type Node = 
    {
        Key: Option<string>
        Children: List<Node>
        XPathFromParent: string
    }


let defaultNode = 
    {
        Key = None; 
        Children = [];
        XPathFromParent = ".//somePath"
    }


type NodeBuilder(xpath: string) =
    member self.Yield(item: 'a): Node =  defaultNode

    member this.xpath = xpath

    [<CustomOperation("xpath_from_parent")>]
    member __.XPathFromParent (node, x) = {node with XPathFromParent = x}

    [<CustomOperation("nodes")>]
    member __.Nodes (node, x) = {node with Children = x}

    [<CustomOperation("key")>]
    member __.MidasMeasurementKey (node, x) = {node with Key = x}

    member this.Bind(x, f) = f x


let node xpath = NodeBuilder(xpath)


let rootNode = node ".//somePath" {
    let! childNodes = 
        [
            node "somepath" {
                nodes []
            };

            node "someOtherPath" {
                nodes []
            }
        ]

    nodes childNodes  // The value or constructor 'childNodes' is not defined.
}

如何更改此代码，以便我可以引用 childNodes 赋值以将其传递给 nodes 自定义运算符？

Answer 1

您的直接问题是您需要将[<ProjectionParameter>] 属性放在您希望能够访问计算表达式的变量空间的自定义运算符的任何参数上。然而，一旦你添加了这个，你会发现你有一些类型不匹配的问题。总的来说，我同意rmunn：计算表达式不一定适合您的问题，因此您应该强烈考虑使用不同的机制。

但是，如果您坚持向前推进，这里有一个技巧可以帮助您进行调试。看起来你希望能够写作

node "something" {
    let! childNodes = ([some expression]:Node list)
    nodes childNodes
}

所以像这样创建一个 dummy builder（看似无用的Quote 方法是关键）：

type DummyNodeBuilder(xpath:string) = 
    [<CustomOperation("nodes")>]
    member __.Nodes (node:Node, [<ProjectionParameter>]x) = node // Note: ignore x for now and pass node through unchanged
    member __.Yield(_) = Unchecked.defaultof<_> // Note: don't constrain types at all
    member __.Bind(_,_) = Unchecked.defaultof<_> // Note: don't constrain types at all
    member __.Quote() = ()

let node xpath = DummyNodeBuilder xpath

let expr = 
    node "something" {
        let! childNodes = [] : Node list
        nodes childNodes
    }

您会看到expr 包含一个大致相当于：

builder.Nodes(
    builder.Bind([], 
                 fun childNodes -> builder.Yield childNodes),
    fun childNodes -> childNodes)

因此，在您的真实构建器中，您需要具有具有兼容签名的方法（例如，Nodes 的第二个参数必须接受一个函数，并且第一个参数必须与 Bind 的返回类型兼容，等等.)。当您尝试使用虚拟构建器启用的其他工作流程时，您可以看到它们如何脱糖并发现其他约束。

Answer 2

在您完全了解它们的工作原理之前，可能很难使用计算表达式。如果您对 F# 比较陌生，我建议您不要使用计算表达式，而是使用普通函数调用和列表来构建您的节点。类似于以下内容：

type Node = 
    {
        Key: Option<string>
        Children: List<Node>
        XPathFromParent: string
    }

let defaultNode = 
    {
        Key = None; 
        Children = [];
        XPathFromParent = ".//somePath"
    }

let withNodes children node = { node with Children = children }
let withXpathFromParent xpath node = { node with XPathFromParent = xpath }
let withKey key node = { node with Key = Some key }

let mkNode xpath children = { Key = None
                              Children = children
                              XPathFromParent = xpath }

// Usage example

let rootNode =
    mkNode ".//somePath" [
        mkNode "somepath" [] |> withKey "childkey1"
        mkNode "someOtherPath" [] // No key specified, so this one will be None
    ] |> withKey "parentKey"

这会产生一个看起来像这样的rootNode：

val rootNode : Node =
  {Key = Some "parentKey";
   Children =
    [{Key = Some "childkey1";
      Children = [];
      XPathFromParent = "somepath";}; {Key = null;
                                       Children = [];
                                       XPathFromParent = "someOtherPath";}];
   XPathFromParent = ".//somePath";}