如何在不可变的树状结构上实现堆栈安全操作？

Question

我有一个不可变的树状结构类型：

type Data<A> = Empty | Node<A> | Both<A>

type Empty = { tag: Tag.Empty };
type Node<A> = { tag: Tag.Node, value: A };
type Both<A> = { tag: Tag.Both, left: Data<A>, right: Data<A> };

在此数据结构上实现fold 、 map甚至flatMap等堆栈安全操作的良好起点是什么？

Answer 1

让我们从数据构造函数开始。

// data Data a = Empty | Node a | Both (Data a) (Data a)
const Empty = { tag: "Empty" };
const Node = value => ({ tag: "Node", value });
const Both = left => right => ({ tag: "Both", left, right });

// data Cont a b = Left (Data a) (Cont a b) | Right b (Cont a b) | Done
const Left = rightQ => next => ({ tag: "Left", rightQ, next });
const Right = leftA => next => ({ tag: "Right", leftA, next });
const Done = { tag: "Done" };

// data Frame a b = Fold (Data a) (Cont a b) | Apply (Cont a b) b
const Fold = data => cont => ({ tag: true, data, cont });
const Apply = cont => result => ({ tag: false, cont, result });

接下来，我们定义一个堆栈安全fold function。

// fold :: (b -> b -> b) -> (a -> b) -> b -> Data a -> b
const fold = both => node => empty => data => {
    let frame = Fold(data)(Done);

    while (true) {
        const { data, cont, result } = frame;
        const { value, left, right } = data || {};
        const { leftA, rightQ, next } = cont;

        switch (frame.tag ? data.tag : cont.tag) {
        case "Empty":
            frame = Apply(cont)(empty);
            continue;
        case "Node":
            frame = Apply(cont)(node(value));
            continue;
        case "Both":
            frame = Fold(left)(Left(right)(cont));
            continue;
        case "Left":
            frame = Fold(rightQ)(Right(result)(next));
            continue;
        case "Right":
            frame = Apply(next)(both(leftA)(result));
            continue;
        case "Done":
            return result;
        }
    }
};

注意fold是一个结构折叠，但我们可以用它来定义foldr ，它是一个遍历折叠。

// id :: a -> a
const id = x => x;

// compose :: (b -> c) -> (a -> b) -> a -> c
const compose = g => f => x => g(f(x));

// flip :: (a -> b -> c) -> b -> a -> c
const flip = f => y => x => f(x)(y);

// foldr :: (a -> b -> b) -> b -> Data a -> b
const foldr = func => flip(fold(compose)(func)(id));

最后，我们可以使用fold来定义map和flatMap 。

// map :: (a -> b) -> Data a -> Data b
const map = func => fold(Both)(compose(Node)(func))(Empty);

// flatMap :: (Data a) -> (a -> Data b) -> Data b
const flatMap = flip(func => fold(Both)(func)(Empty));

Answer 2

正如评论中提到的，您显然需要一个迭代树遍历算法，该算法执行一些标准的函数式编程操作，如map和fold （又名reduce ）。 链接文章中提到的迭代算法涉及构建一个节点父节点堆栈，或者通过维护从每个节点到其父节点的映射。

这是您Data<T>上fold的一种可能（未经过广泛测试，所以要小心）实现，它维护从节点到其父节点的映射，同时构建所需的 output 结构。 请记住，肯定还有其他算法。 我之所以选择这个，是因为它最清楚地表达了我对穿过树的设想：

function fold<T, U>(inData: Data<T>, f: (acc: U, t: T) => U, init: U) {
  const parents: Map<Data<T>, Data<T> | undefined> = new Map();
  let cur: Data<T> | undefined = inData;
  let acc = init;
  while (cur) {
    if ((cur.tag === Tag.Both) && (!parents.has(cur.left))) {
      parents.set(cur.left, cur);
      cur = cur.left;
    } else if ((cur.tag === Tag.Both) && (!parents.has(cur.right))) {
      parents.set(cur.right, cur);
      cur = cur.right;
    } else {
      if (cur.tag === Tag.Node) {
        acc = f(acc, cur.value);
      }
      cur = parents.get(cur);
    }
  }
  return acc;
}

如果您的当前节点是一个Both并且您还没有处理left节点，则将当前节点添加到他的parents映射中作为left节点的父节点，然后沿着树向左走。 否则，如果节点是Both并且您尚未处理right的节点，请执行相同的操作但向右。 否则，您要么处理Empty或Node节点，要么处理left节点已被处理right Both节点......这意味着您可以处理 output 的当前节点，然后返回父节点。 最终，您将尝试走到树根的父节点，然后就完成了。

造成这种fold的部分是我们在处理Node节点时运行累加器回调。 同样重要的是要注意fold通常取决于遍历的顺序（例如，对于列表，左折叠和右折叠是不同的），所以上面的实现可能不是你想要的（你想要预购？按序？后购？广度优先？还有别的？）。

---

这是一个类似的map实现：

function map<T, U>(inData: Data<T>, f: (t: T) => U) {
  const parents: Map<Data<T>, Data<T> | undefined> = new Map();
  const mapped: Map<Data<T>, Data<U>> = new Map();
  let cur: Data<T> | undefined = inData;
  while (cur) {
    if ((cur.tag === Tag.Both) && (!parents.has(cur.left))) {
      parents.set(cur.left, cur);
      cur = cur.left;
    } else if ((cur.tag === Tag.Both) && (!parents.has(cur.right))) {
      parents.set(cur.right, cur);
      cur = cur.right;
    } else {
      mapped.set(cur,
        cur.tag === Tag.Both ? ({
          tag: Tag.Both,
          left: mapped.get(cur.left)!,
          right: mapped.get(cur.right)!
        }) : cur.tag === Tag.Empty ? ({
          tag: Tag.Empty
        }) : ({
          tag: Tag.Node, value: f(cur.value)
        })
      );
      cur = parents.get(cur);
    }
  }
  return mapped.get(inData)!;
}

它类似于fold ，但 output 处理不同。 Building an output node for a Both involves using the output nodes already build for each subtree, so this implementation stores a mapped map from input nodes to output nodes also, so that can be retrieved later.

---

我不会介绍flatMap() ，但它类似于map ，除了用于Node输入的 output 节点是由回调 function 直接生成的，而不是需要直接构建。 您可以验证这些对合理的树木做了合理的事情（底部的游乐场链接有一些示例）。

---

Playground 代码链接