用折叠映射任意 n 叉树

Question

我想要一些通用工具来处理树木。我正在使用 JavaScript，所以我可以强加的东西很少，而且我正在使用我无法更改的现有数据结构。我设法定义了以下内容：

reduceTree :: (T a -> [T a]) -> (b -> T a -> b) -> b -> T a -> b
reduceTree(getChildren, f, accumulator, tree)

（我使用 Haskell 类型签名是因为它们更容易阅读）

这个getChildren 函数是必需的，因为我的树是任意的，我不知道它是如何构造的。

reduceTree 运行良好。但我也想有一个mapTree 函数，最好重用我的reduceTree 函数，但我被卡住了。有什么不对劲，但我不知道是什么。

编辑

我的reduceTree 实现：

export function reduceTree(getChildren, f, accumulator, tree) {
  const children = getChildren(tree);
  if (!children || children.length === 0) {
    return f(accumulator, tree)
  } else {
    const childrenResult = children.reduce(
      (accumulator, subTree) => reduceTree(getChildren, f, accumulator, subTree),
      accumulator
    );
    return f(childrenResult, tree)
  }
}

它已经过测试并且可以工作。

（我用来构造/证明上面的javascript的伪Haskell实现：

reduceTree f a (Node val []) = f a val
reduceTree f a (Node val xs) = f (fold (reduceTree f) acc) val

)

Answer 1

TL;DR：您的伪代码已损坏。解决它的一种方法是

reduceTree :: (b -> a -> b) -> b -> T a -> b
reduceTree f acc (Node val []) = f acc val
reduceTree f acc (Node val ts) = 
    Data.List.foldl (\acc tree -> reduceTree f acc tree) (f acc val) ts

这意味着你的 Javascript 应该是

export function reduceTree(getChildren, f, accumulator, tree) {
  const children = getChildren(tree);
  if (!children || children.length === 0) {
    return f(accumulator, tree)
  } else {
    const childrenResult = children.reduce(
      (accumulator, subTree) => reduceTree(getChildren, f, accumulator, subTree),
      f(accumulator,tree)  // referring to `tree` only for its stored node value, yes?
    );
    return childrenResult;
  }
}

大概 Javascript 在列表中的 reduce 是 left 折叠（根据 Wikipedia 是这样）。

它执行前序树遍历，相当于本文底部的tfoldl 函数。用它来实现map 并不完全奏效，

tmap f t = reduceTree (\acc val -> Node (f val) ???) ??? t

因为Node :: a -> [T a] -> T a的类型不合适，所以不能适应上面的reducer类型b -> a -> b（需要a -> [b] -> b类型）。

这是因为这种线性折叠本质上是将结构扁平化，将其视为线性序列。

下面是一些无关紧要的细节。

---

Haskell has it the exact same way 作为Aadit's answer 中的reduceTree 函数。

约翰休斯在他的著名论文“为什么函数式编程很重要”中也有几乎相同的方式，因为

foldTree :: (a -> b -> r) -> (r -> b -> b) -> b -> Tree a -> r 
foldTree f g z (Node x t) = f x . foldr g z . map (foldTree f g z) $ t

他使用了一个等效但更冗长的公式，他称之为redtree，用于“减少树”。它认为

foldTree f g z = reduceTree (\a rs -> f a (foldr g z rs)) 

所以两者几乎是等价的。那么，

map h = reduceTree (Node . h) 
      = reduceTree (\a rs -> Node (h a) rs) 
      = foldTree (Node . h) (:) [] 

没有“零”，即初始累加器值来自于列表中数据定义中没有第二个子句data T a = Node a [T a]，而不是List a = Nil | Cons a (List a)。

后者的折叠缩减函数将Nil 或Cons a r 转换为r，因此它必须具有“零”，即提供给它的默认值；对于前者，它需要Node a [r] 到r，所以没有Nil 需要处理的情况（参见recursion-schemes）。

---

在 cmets 中从 user Bergi 到 a hint 之后，Haskell 包 containers 为这种类型定义了 a Foldable instance，

data T a = Node a [T a]

其等价于foldr（为方便起见，带有翻转的参数），是

tfoldr :: (a -> b -> b) -> T a -> b -> b 
tfoldr f (Node x ts) z = f x $ Data.List.foldr ($) z [tfoldr f t | t <- ts]

确实穿过状态/累加器！也可以写成

tfoldr :: (a -> b -> b) -> T a -> b -> b 
tfoldr f (Node x ts) z = f x . Data.List.foldr (.) id [tfoldr f t | t <- ts] $ z

以您更容易实施的为准。这是实现后序树遍历；对于通常的预购遍历使用

tfoldl :: (a -> b -> b) -> T a -> b -> b
tfoldl f (Node x ts) z = Data.List.foldr (>>>) id [tfoldl f t | t <- ts] $ f x z
                 -- // = tfoldl f tn (... (tfoldl f t2 (tfoldl f t1 (f x z))) ...)

(f >>> g) x = g (f x)，或者

tfoldl :: (b -> a -> b) -> T a -> b -> b
tfoldl f (Node x ts) z = Data.List.foldr (>>>) id [tfoldl f t | t <- ts] $ f z x
                 -- // = tfoldl f tn (... (tfoldl f t2 (tfoldl f t1 (f z x))) ...)

相当于本文开头的代码，直到参数的顺序。

• 另见：Variations of folds on Haskell Trees

Answer 2

我看到你的树数据结构定义如下：

data T a = Node a [T a]

如果是这样，那么你的树数据结构的折叠将是：

reduceTree :: (a -> [b] -> b) -> T a -> b
reduceTree f = let g (Node a xs) = f a (map g xs) in g

您现在可以使用reduceTree 定义mapTree，如下所示：

mapTree :: (a -> b) -> T a -> T b
mapTree f = reduceTree (Node . f)

将其全部转换为 JavaScript：

const Node = (a, xs) => ({a, xs});

const reduceTree = (f, node) => {
    const g = node => f(node.a, node.xs.map(g));
    return g(node);
};

const mapTree = (f, node) => reduceTree((a, xs) => Node(f(a), xs), node);

const tree = Node(2, [ Node(3, [ Node(11, [])
                               , Node(13, []) ])
                     , Node(5, [])
                     , Node(7, [ Node(17, [])
                               , Node(19, []) ]) ]);

console.log(mapTree(x => 2 * x, tree));

希望对您有所帮助。