折叠多项式解析树的最有效方法

Question

我正在研究一个符号代数系统。我目前正在研究如何从二叉解析树执行多项式加法/乘法。我稍后会认为这是一个通用的戒指。

解析与此处不相关——这旨在成为解析的输出。形成的分析树。如果这里有什么可以改进的地方，我当然也很高兴知道这一点。

我“感觉”这个树形结构可以折叠/压碎，但我不太清楚如何去做。我相信我可以一起破解一些东西，但是由于我还在学习 Haskell，所以我想了解更高级的用户会做什么。

以下是相关代码背景。

我的两个相关数据声明是：

data Op = Add | Mul
data Tree a = Leaf a | Node Op [Tree a] [Tree a]

这是我的一个测试示例：

-- 3*(x+2)*(x+(5*4))
test = Node Mul [
         Node Mul 
          [Leaf "3"] 
          [Node Add 
            [Leaf "x"] 
            [Leaf "2"]
          ]
         ] 
         [Node Add 
           [Leaf "x"] 
           [Node Mul 
             [Leaf "5"] 
             [Leaf "4"] 
           ]
         ]

这是一种典型的递归树类型，一个节点包含一个操作以及左右树的列表。计算通过以下操作进行。注意：它们现在都是字符串操作。我需要它们尽可能通用（但稍后会添加进一步的结构，例如乘法交换性）。

prod :: [Tree [a]] -> [Tree [a]] -> [Tree [a]]
prod ls rs = [Leaf (l ++ r) | (Leaf l) <- ls, (Leaf r) <- rs]

add :: [Tree [a]] -> [Tree [a]] -> [Tree [a]]
add l r = l ++ r

opOnLeaf :: Op -> [Tree [a]] -> [Tree [a]] -> [Tree [a]]
opOnLeaf op l r  
  | op == Add = add l r
  | op == Mul = prod l r

operate :: Tree [a] -> [Tree [a]]
operate (Node op [Node op2 l2 r2] [Node op3 l3 r3]) = operate (Node op (operate (Node op2 l2 r2)) (operate (Node op3 l3 r3)))
operate (Node op [Node op2 l2 r2] r) = operate (Node op (operate (Node op2 l2 r2)) r)
operate (Node op l [Node op2 l2 r2]) = operate (Node op l (operate (Node op2 l2 r2)))
operate (Node op l r) = opOnLeaf op l r

我认为我在operate 中的变量名很可怕，但我想确保它首先起作用。让它变得丑陋也使它更加突出。它实际上是在对我大喊大叫，以找到更好的方法。

现在，我想使用 fold 或 foldMap，但我遇到了一个问题，即我在每个操作中都有不同的幺半群（即 (*) 和 (+)。这只是开始——我将添加其他几个操作。所以我需要类似“变量幺半群”的东西，或者可能是其他一些地图，其操作是首先获取幺半群。我不确定。

查询：给定这棵二叉树，以及每个节点上的多个操作，如何继续折叠结构？有没有更好的方法把它写成可折叠的实例或其他结构？我还打算添加其他几个二进制操作。理想情况下，我想要一个可以无限扩展的结构。我假设一旦解决了 2，我们就可以有效地解决 n。

Tree drawing corresponding to test example

Answer 1

“Fold”在常用语中具有两个相关但截然不同的含义。

1. Fold 与 Foldable 相同。将数据类型视为容器，Foldable 让您可以访问容器的元素，同时丢弃有关容器本身形状的任何信息。 （这也是lens 的Fold 使用该术语的意义。）并非所有数据类型都是Foldable — 只有那些可以被视为容器的数据类型。
2. “Fold”也可以表示“catamorphism”，这是一种编写高阶函数的技术，可将结构简化为汇总值。每个数据类型都有相应的变态，但变态的签名取决于数据类型。

当您谈论的数据类型是[] 时，“折叠”的两个含义恰好重合（这部分解释了对这两个含义的混淆），但通常它们不会。您的Tree 恰好是任何一种弃牌的合适人选，从您的问题来看，我无法完全确定您要的是哪一种，所以我将向您展示如何同时做到这一点。

---

编写Foldable 实例的最简单方法是打开DeriveFoldable。

{-# LANGUAGE DeriveFoldable #-}
data Tree a = Leaf a | Node Op [Tree a] [Tree a]
  deriving (Foldable)

但为了便于理解，我将在此处写出实例：

instance Foldable Tree where
    -- foldr :: (a -> b -> b) -> b -> Tree a -> b
    foldr f z (Leaf x) = f x z
    foldr f z (Node _ ls rs) = foldr foldTree z (ls ++ rs)
        where foldTree t z' = foldr f z' t

这个想法是遍历树到底部，将f 应用于每个Leaf 中的值。关于这段代码需要注意的几点：

• foldr 是一个重载函数（它是Foldable 的一个方法），在第二个子句中，我将它用于两种不同的类型。 foldTree 中的foldr 是对Tree 的foldr :: (a -> b -> b) -> b -> Tree a -> b 定义的递归调用。上面一行中的foldr 是对通常列表foldr :: (a -> b -> b) -> b -> [a] -> b 的调用。
• foldr 丢弃信息！在Node 的情况下，您可以从_ 中看到Op 掉在了地板上。我们还将ls 和rs 合并到一个列表中，忘记了它们曾经在两个列表中。

所以Foldable 就是要找到容器内的物品，同时丢弃有关容器本身的任何信息。说白了，Foldable 就是“toList-as-a-class”。

Foldable 非常适合容器类型和其他抽象数据类型，您希望在其中公开类似集合的接口，同时隐藏数据结构的内部表示。在您的情况下，您提到您想根据树内的Op 应用操作+ 或*，但Op 被Foldable丢弃。所以看起来Foldable 不是你想要做的事情的正确工具。

---

如果你想将你的数据类型减少到一个汇总值而不丢弃任何关于结构的信息，你需要一个catamorphism。

要导出变质的特征，请遵循这个秘诀。

1. cata 采用您的数据类型的值并返回摘要值 b。
2. 数据类型的每个构造函数都对应于cata 的一个参数。这些参数中的每一个都是一个返回b的函数。
3. 数据类型构造函数的每个字段都对应于相应函数的参数之一。
4. 数据类型本身的递归提及成为汇总值b。

让我们为您的Tree 执行以下步骤。首先，cataTree 接受一个Tree 并返回一个汇总值b。

cataTree :: ??? -> Tree a -> b

查看Tree 的定义，我们看到两个构造函数。所以cataTree 将有两个函数参数，一个用于Leaf，一个用于Node。

cataTree :: ({- Leaf -} ??? -> b) -> ({- Node -} ??? -> b) -> Tree a -> b

查看Leaf 构造函数，我们看到一个字段。所以Leaf 函数只有一个参数。

cataTree :: (a -> b) -> ({- Node -} ??? -> b) -> Tree a -> b

现在让我们看看Node。 Node 有三个参数，但其中两个是 Trees 的列表。我们想用相应的汇总值替换每个Trees。所以cataTree 的最终签名是

cataTree :: (a -> b) -> (Op -> [b] -> [b] -> b) -> Tree a -> b

实现cataTree 是遵循类型的问题。

cataTree leaf _ (Leaf x) = leaf x
cataTree leaf node (Node op ls rs) =
    node op (fmap (cataTree leaf node) ls) (fmap (cataTree leaf node) rs)