如何实现具有注入功能的通用结构层次结构

Question

我想为树结构实现一个通用层次结构，以后可以以独立于实现的方式使用它来描述树上的通用算法。

我从这个层次结构开始：

interface BinaryTree<Node> {
    Node left(Node);
    bool hasLeft(Node);

    Node right(Node);
    bool hasRight(Node);
}

interface BinaryTreeWithRoot<Node> : BinaryTree<Node> {
    Node root();
}

interface BinaryTreeWithParent<Node> : BinaryTree<Node> {
    Node parent(Node);
    bool hasParent(Node);
}

现在，基本上我希望能够以一种通用的方式实现子树的概念： 对于每个类 T : BinaryTree，我想要一个“类” Subtree(T)，它提供与 T 相同的功能（因此它必须从它派生），并且还重写了 root() 功能。

类似这样的：

class Subtree<T, Node> : T, BinaryTreeWithRoot<Node> 
    where T : BinaryTree<Node>
{
    T reference;
    Node root;

    void setRoot(Node root) {
        this.root = root;
    }

    override Node BinaryTreeWithRoot<Node>::root() {
        return this.root;
    }

    // Now, inherit all the functionality of T, so an instance of this class can be used anywhere where T can.
    forall method(arguments) return reference.method(arguments);
}

现在有了这段代码，我不确定如何创建子树类型的对象，因为树对象应该以某种方式被注入。

一种方法是为我创建的每个树类创建一个子树类，但这意味着代码重复，而且毕竟是同一件事。

因此，一种方法是 mixins，它允许泛型类从其模板参数派生。

我也对如何在 Haskell 中实现这样的层次结构感兴趣，因为 Haskell 有一个很棒的类型系统，我认为注入这样的功能会更容易。

例如在 Haskell 中可能是这样的：

class BinaryTree tree node where
    left :: tree -> node -> node
    right :: tree -> node -> node

class BinaryTreeWithRoot node where
    left :: tree -> node -> node
    right :: tree -> node -> node -- but this is a duplication of the code of BinaryTree
    root :: tree -> node

instance BinaryTree (BinaryTreeWithRoot node) where
    left = left
    right = right

data (BinaryTree tree node) => Subtree tree node = 
 ...

instance BinaryTreeWithRoot (Subtree tree node) where ...

我很感兴趣是否以及如何在 oop 语言（c++、c#、d、java）中完成此操作，因为 c++ 和 d 提供开箱即用的 mixins（我不确定 d），出于对 Haskell 类型系统的好奇。

Answer 1

由于 D 有“真正的”模板，而不是泛型，所以让模板类从其模板参数继承是微不足道的：

class A {}
class B(T) : T {
    static assert(is(B!T : T));  // Passes.
}

就使Subtree 在 D 中工作而言，应该这样做，假设您还有一个模板类 Node：

class Subtree(T) : T, BinaryTreeWithRoot!(Node!(T))
{
    T reference;
    Node root;

    void setRoot(Node root) {
        this.root = root;
    }

    override Node root() {
        return this.root;
    }
}

但是，IIUC（如果我错了，请纠正我），T 是树的有效负载，因此可能是一个原语。如果是这种情况，您最好能够通过alias this 将Subtree!(T) 用作T，这允许在没有继承的情况下进行子类型化并使用原语：

class Subtree(T) : BinaryTreeWithRoot!(Node!(T))
{
    T reference;
    alias reference this;  // Make this implicitly convertible to reference.
    Node root;

    void setRoot(Node root) {
        this.root = root;
    }

    override Node root() {
        return this.root;
    }
}

Answer 2

在 Haskell 中创建这样的树形界面是……不寻常的。 Node 和 Subtree 都是多余的。这部分是由于代数类型，部分是因为 Haskell 数据是不可变的，因此需要不同的技术来完成某些事情（例如设置根节点）。可以这样做，界面看起来像：

class BinaryTree tree where
    left :: tree a -> Maybe (tree a)
    right :: tree a -> Maybe (tree a)

-- BinaryTreeWithRoot inherits the BinaryTree interface
class BinaryTree tree => BinaryTreeWithRoot tree where
    root :: tree a -> tree a

然后，使用非常标准的二叉树定义：

data Tree a =
  Leaf
  | Branch a (Tree a) (Tree a)

instance BinaryTree Tree where
  left Leaf = Nothing
  left (Branch _ l r) = Just l
  right Leaf = Nothing
  right (Branch _ l r) = Just r

data TreeWithRoot a =
  LeafR (TreeWithRoot a)
  | BranchR a (TreeWithRoot a) (TreeWithRoot a) (TreeWithRoot a)

instance BinaryTree TreeWithRoot where
-- BinaryTree definitions omitted

instance BinaryTreeWithRoot TreeWithRoot where
  root (LeafR rt) = rt
  root (BranchR _ rt l r) = rt

由于此接口返回Maybe (tree a)，因此您也可以使用left 和right 来检查分支是否存在，而不是使用单独的方法。

这并没有什么特别的问题，但我相信我从未见过有人真正实施过这种方法。更常用的技术是根据Foldable 和Traversable 定义遍历或创建zipper。拉链很容易手动派生，但有几种通用的拉链实现，例如zipper、pez 和syz。

Answer 3

在 C# 4 中，我会使用动态来实现这个目标。例如，您可以尝试将 SubtTree 类定义为：

public class Subtree<T, Node> : DynamicObject, BinaryTreeWithRoot<Node> where T : BinaryTree<Node>
{
    private readonly T tree;

    public Subtree(T tree)
    {
        this.tree = tree;
    }
}

并使用树的方法/属性覆盖 DynamicObject 的适当方法。更多信息（和示例代码）可以在这篇关于 Using C# 4.0 dynamic to drastically simplify your private reflection code 的精彩博客文章中找到。

值得一提的是，由于使用了动态能力和反射，会引入小的性能开销以及降低安全性（因为它可能涉及违反封装）。

Answer 4

我认为通过“BinaryTree”的方法假设了太多的固定结构，并且不必要地以非通用方式定义了您的接口。当您的树扩展到非二进制形式时，这样做会使重用算法变得困难。相反，当没有必要或无用时，您需要为多种样式编写接口。

此外，使用 hasLeft/hasRight 检查进行编码意味着每次访问都是一个两步过程。检查固定位置的存在不会提供有效的算法。相反，我认为您会发现添加可能是二进制左/右或二进制红/黑或字符索引或其他任何东西的通用属性将允许更多地重用您的算法并检查数据是否只能由这些算法完成需要它（特定的二进制算法）。

从语义上看，你想先编码一些基本属性，然后再进行专业化。当您“位于”算法中的某个节点时，您希望能够首先找到子 边。这应该是边缘结构的容器范围，允许您导航到子节点。由于它可以是一个通用容器，它可以有 0、2、5、1 甚至 100 条边。许多算法并不关心。如果它为 0，则在该范围内迭代将无济于事 - 无需检查 hasX 或 hasY。对于每条边，您应该能够获取孩子的节点，并递归任何您想要的算法。

这基本上是 boost 在其 Graph 库中采用的方法，它允许将树算法扩展到适用的图形，以实现更好的通用算法重用。

所以你已经有了一个基本的界面

TreeNode:
  getChildEdges: () -> TreeEdgeRange

TreeEdge:
  getChildNode: () -> TreeNode

以及您喜欢的语言喜欢的任何范围到对象。例如，D 有一个特别有用的范围语法。

你会想要一些基本的树对象来给你节点。类似的东西

Tree:
  getTreeNodes: () -> TreeNodeRange

让你开始。

现在，如果您想支持 BinaryTrees，请将此作为对该接口的限制。请注意，您实际上并不需要任何新的接口方法，您只需要强制执行更多不变量 - 每个 TreeNode 都有 0、1 或 2 个 childEdge。只需创建一个指示此语义限制的接口类型：

BinaryTree : Tree

如果你想支持有根树，添加一个接口层

RootedTree : Tree:
  getRoot: () -> TreeNode

添加该功能。

基本思想是，如果您要使类在层次结构中更加具体，则不必添加接口方法来添加语义要求。仅当有需要访问的新语义行为时才添加接口方法。否则 - 在通用接口上强制执行新的不变量。

最终，您需要使用包含节点或边的数据的结构来装饰节点和边，这样您就可以构建 Tries 和红黑树以及所有高级算法的出色工具。所以你会想要拥有

PropertiedTreeNode<Property> : TreeNode:
  getProperty: () -> Property

PropertiedTreeEdge<Property> : TreeEdge:
  getProperty: () -> Property

由于这是您希望允许通用算法处理的事情，因此属性是否是树的一部分的类型信息应该是通用的，并且算法可以忽略。这使您进入了 boost 的设计轨道，这些问题已经得到了非常优雅的解决。如果您想了解如何构建通用树算法库，我建议您研究该库。

如果您遵循上述类型等同于语义描述的准则，那么您的子树应该是显而易见的 - 它与它所来自的树的类型完全相同！事实上，你真的根本不应该有 SubTree 类型。相反，您应该只拥有您正在处理的特定 TreeNode 类型的方法

PropertiedTreeNode<Property>:
  getSubTree: () -> PropertiedTree<Property>

而且，与 boost 一样，当您在 Tree 的通用属性中编码更多有关 Tree 功能的信息时，您可以获得具有更广泛接口协定的新 Tree 类型。

Answer 5

正如您所指出的，一种方法是为我创建的每个树类创建一个子树类， 这意味着代码重复，但可以使用反射和 T4 以某种方式“避免”，或者更好地自动化。我自己为过去的一个项目做的，效果很好！

您可以从 Oleg Synch 博客开始了解 T4 的概述。这里是自动生成类的一个很好的例子：http://www.olegsych.com/2007/12/how-to-use-t4-to-generate-decorator-classes/

Answer 6

你可以这样做：-

public class Node {
    public Node Left {get; set:}
    public Node Right {get; set;}
    public Node Parent {get; set;}  // if you want to be able to go up the tree
    public Node Root {get; set;}    // only if you want a direct link to root
}

子树只是一棵树，每棵树都可以表示为该树的根节点，然后该节点可以具有能够在树中导航的属性。

将其设为通用 Node<T> 并存储该值。如果您不喜欢公共设置器，请将它们设为私有并仅在构造函数或某些安全的AddLeft(...) 等方法中设置它们。

您也可以摆脱Root，只需遍历Parent 链接，直到找到一个空的Parent 值（或到达您的子树案例的顶部节点）。