Question

我是F＃的新手并且学习了基础知识。

我有两个模块。树数据结构的通用名称Tree：

module Tree

let rec getDescendants getChildren node  = 
    seq { yield node
          for child in getChildren node do 
            yield! getDescendants getChildren child }

let isLeaf getChildren node = Seq.isEmpty (getChildren node)

let getLeaves getChildren node = getDescendants getChildren node  
                               |> Seq.filter (isLeaf getChildren)

如您所见，所有函数都有一个getChildren参数，这是一个函数枚举给定类型的节点的子节点。

第二个模块处理更具体的XML树案例：

module XmlTree

open System.Xml.Linq

let getXmlChildren (node : XElement) = node.Elements()

let getDescendants = Tree.getDescendants getXmlChildren 
let getLeaves = Tree.getLeaves getXmlChildren 
let isLeaf = Tree.isLeaf getXmlChildren

定义并传递XML节点的特定getXmlChildren函数咖喱Tree函数。

现在有很多代码重复。

以某种方式可以做到这一点吗？（伪代码）

module XmlTree = Tree with getChildren = fun (node : XElement) -> node.Elements()

Answer 1

F＃不支持functors，因此您无法将参数传递给F＃模块。在您的示例中，将生成节点子节点的函数传递给对象构造函数就足够了：

type Tree<'T>(childFn: 'T -> 'T seq) =
    let getChildren = childFn

    member x.getDescendants node  = 
        seq { yield node
              for child in getChildren node do 
                yield! x.getDescendants child }

    member x.isLeaf node = node |> getChildren |> Seq.isEmpty
    member x.getLeaves node = node |> x.getDescendants |> Seq.filter x.isLeaf

// Type usage
open System.Xml.Linq
let xmlTree = new Tree<XElement>(fun x -> x.Elements())

对于更复杂的案例，inheritance是可行的方法。特别是，您可以将Tree<'T>声明为具有抽象成员getChildren的抽象类，并在XmlTree子类中重写该方法。

Answer 2

您不是使用模块执行此操作，而是使用泛型，例如

修改：

type tree<'t>(Children:seq<tree<'t>>)= member x.isLeaf() = Seq.isEmpty (Children ) member x.getLeaves() = getDescendants Children |> Seq.filter (fun x -> x.isLeaf())

我遗漏了后代，但这应该足够了。此外，某些类型注释不是必需的，但显示正在发生的事情

是否可以将参数传递给F＃模块？

2 个答案: