遍历一棵玫瑰树直到满足某个条件，然后修改树

Question

我在 Haskell 中有两棵玫瑰树，分别有m和n 个节点。 我想用第二棵树的第j个节点替换第一棵树的第i个节点。

例如

树 1：

           R                                                           
  _________|____________                 
  |        |           |
  A        B           C
 / \      / \         / \
D   E    F   G       H   I

树 2：

       r
  _____|____
  |         |       
  P         Q       
 / \      / | \      
S   T    U  V  W     

那么树 1 节点 7 (C) 替换为树 2 节点 4 (Q) 的结果树应该是（假设索引是预先排序并从 0 开始）

           R                                                           
  _________|____________                 
  |        |           |
  A        B           Q
 / \      / \        / | \
D   E    F   G      U  V  W

我试过使用拉链，但我的问题是我无法锻炼如何将拉链焦点放在第 ith 个元素上，

即我如何实现 function 类型：

someFunc:: Tree a -> Int -> Zipper a

获取树的根并（按某种顺序）遍历它以返回集中在第 i 个预排序节点和上下文的拉链。

从树库中，我可以使用展平将树展平为预先排序的值列表，我可以稍微更改它以给我一个树列表，例如

flattenToTreeList :: Tree a -> [Tree a]
flattenToTreeList t = squish t []
  where squish (Node x ts) xs = Node x ts : foldr squish xs ts

如果我能用拉链做到这一点，那么这个列表中的第 i 个元素就会让我满意，但我迷路了，现在在兜圈子。

Answer 1

好吧，我的评论有点偏离。 我有点误读了需求，但实际上是在某种程度上减少了依赖性。

-- lens
import Control.Lens ((^?), contexts, cosmos, elementOf, ix)

-- containers
import Data.Tree (Tree(..))

-- adjunctions
import Control.Comonad.Representable.Store (peeks)

tree1 :: Tree Char
tree1 = Node 'R' [ Node 'A' [Node 'D' [], Node 'E' []]
                 , Node 'B' [Node 'F' [], Node 'G' []]
                 , Node 'C' [Node 'H' [], Node 'I' []]
                 ]

tree2 :: Tree Char
tree2 = Node 'R' [ Node 'P' [Node 'S' [], Node 'T' []]
                 , Node 'Q' [Node 'U' [], Node 'V' [], Node 'W' []]
                 ]

-- Replace subtree i in t1 with subtree j in t2
-- returns Nothing if either index doesn't exist
replace :: Int -> Tree a -> Int -> Tree a -> Maybe (Tree a)
replace i t1 j t2 = update =<< replacement
  where
    update u = peeks (const u) <$> contexts t1 ^? ix i
    replacement = t2 ^? elementOf cosmos j

main :: IO ()
main = print $ replace 7 tree1 4 tree2

这增加了对adjunctions package 的依赖，但它是 lens 的依赖。 所以这是一个额外的导入，但没有额外的必需包。 作为交换，它根本不需要使用树遍历。

这与通常的lens代码有点不同，因为cosmos和contexts都不是特别常见，但它们是操纵自相似数据类型的子结构的好工具。 这是替换子树的完美描述。

这在概念上使用了相当繁重的工具，但我认为含义很好。