这个问题haskell fold rose tree paths深入研究了将玫瑰树折叠到其路径的代码。我正在尝试无限的玫瑰树，我发现所提供的解决方案并不足以在宽度和宽度都无限的无限玫瑰树上工作。
考虑像玫瑰树一样：
data Rose a = Rose a [Rose a] deriving (Show, Functor)
这是一棵有限的玫瑰树：
finiteTree = Rose "root" [
Rose "a" [
Rose "d" [],
Rose "e" []
],
Rose "b" [
Rose "f" []
],
Rose "c" []
]
边缘路径列表的输出应为：
[["root","a","d"],["root","a","e"],["root","b","f"],["root","c"]]
这两个维度都是无限的玫瑰树：
infiniteRoseTree :: [[a]] -> Rose a
infiniteRoseTree ((root:_):breadthGens) = Rose root (infiniteRoseForest breadthGens)
infiniteRoseForest :: [[a]] -> [Rose a]
infiniteRoseForest (breadthGen:breadthGens) = [ Rose x (infiniteRoseForest breadthGens) | x <- breadthGen ]
infiniteTree = infiniteRoseTree depthIndexedBreadths where
depthIndexedBreadths = iterate (map (+1)) [0..]
树看起来像这样（它只是一个摘录，有无限的深度和无限的宽度）：
0
|
|
[1,2..]
/ \
/ \
/ \
[2,3..] [2,3..]
路径如下：
[[0,1,2..]..[0,2,2..]..]
这是我最近的尝试（在GHCi上执行此操作会导致无限循环，没有流输出）：
rosePathsLazy (Rose x []) = [[x]]
rosePathsLazy (Rose x children) =
concat [ map (x:) (rosePathsLazy child) | child <- children ]
rosePathsLazy infiniteTree
另一个答案中提供的解决方案也没有产生任何输出：
foldRose f z (Rose x []) = [f x z]
foldRose f z (Rose x ns) = [f x y | n <- ns, y <- foldRose f z n]
foldRose (:) [] infiniteTree
上述两种工作都适用于有限玫瑰树。
我尝试了许多变化，但我无法弄清楚使边缘折叠操作对于无限的二维玫瑰树来说是懒惰的。我觉得它与无限量的concat有关。
由于输出是二维列表。我可以同时运行2维take项目并设置深度限制或广度限制或两者兼而有之！
感谢任何帮助！
在这里回顾完答案后再考虑一下。我开始意识到这是可以展开的，因为结果列表无数无限。这是因为无限深度＆amp;广度玫瑰树不是二维数据结构，而是无限维数据结构。每个深度级别都赋予额外的维度。换句话说，它有点等同于无限维矩阵，想象一个矩阵，其中每个场是另一个矩阵.ad-infinitum。无限矩阵的基数是infinity ^ infinity，已被证明（我认为）无穷无尽。这意味着任何无限维数据结构在有用的意义上都不是真正可计算的。
要将此应用于玫瑰树，如果我们有无限深度，那么路径永远不会枚举玫瑰树的最左边。就是这棵树：
0
|
|
[1,2..]
/ \
/ \
/ \
[2,3..] [2,3..]
会产生类似：[[0,1,2..], [0,1,2..], [0,1,2..]..]的路径，我们永远不会过去[0,1,2..]。
或者换句话说，如果我们有一个包含ad-infinitum列表的列表。我们也可以永远不计算（枚举）它，因为代码会跳到无限量的维度。
这也与实数无关也有一些关系。在一个无限实数的惰性列表中，只能无限地产生0.000..并且永远不会枚举过去。
我不确定如何形式化上述解释，但那是我的直觉。 （有关参考资料，请参阅：https://en.wikipedia.org/wiki/Uncountable_set）如果有人将https://en.wikipedia.org/wiki/Cantor's_diagonal_argument应用于此问题，那就太酷了。
答案 0 :(得分：6)
出于某种原因，dfeuer删除了他的答案，其中包括一个非常好的洞察力，只有一个轻微的，容易解决的问题。下面我讨论他很好的见解，并解决容易解决的问题。
他的见解是原始代码挂起的原因是因为concat对其参数列表的任何元素都是非空的并不明显。既然我们可以证明这一点（在Haskell之外，用纸和笔），我们可以稍作作弊来说服编译器确实如此。
不幸的是，concat还不够好：如果您为concat提供[[1..], foo]这样的列表，它就永远不会从foo中提取元素。 universe包的集合可以在这里帮助diagonal函数，它可以从所有子列表中绘制元素。
这两个见解共同导致以下代码：
import Data.Tree
import Data.Universe.Helpers
paths (Node x []) = [[x]]
paths (Node x children) = map (x:) (p:ps) where
p:ps = diagonal (map paths children)
如果我们定义一个特定的无限树：
infTree x = Node x [infTree (x+i) | i <- [1..]]
我们可以看看它在ghci中的表现：
> let v = paths (infTree 0)
> take 5 (head v)
[0,1,2,3,4]
> take 5 (map head v)
[0,0,0,0,0]
看起来很不错！当然，正如ErikR所观察到的，我们不能在这里拥有所有路径。但是，给定通过p的无限路径的任何有限前缀t，paths t中有一个有限索引，其元素以前缀p开头。
答案 1 :(得分：5)
不是一个完整的答案，但您可能会对Haskell的permutations函数的编写方式感兴趣，以便它可以在无限列表中运行：
What does this list permutations implementation in Haskell exactly do?
<强>更新
这是创建无限Rose树的更简单方法：
iRose x = Rose x [ iRose (x+i) | i <- [1..] ]
rindex (Rose a rs) [] = a
rindex (Rose _ rs) (x:xs) = rindex (rs !! x) xs
示例：
rindex (iRose 0) [0,1,2,3,4,5,6] -- returns: 26
rindex infiniteTree [0,1,2,3,4,5,6] -- returns: 13
无限深度
如果Rose树具有无限深度和非平凡宽度（> 1），则不能使用计数参数列出所有路径的算法 - 总路径数不可数。
有限深度＆amp;无限广度
如果Rose树具有有限的深度，即使树具有无限宽度，路径的数量也是可数的，并且存在可以产生所有可能路径的算法。观看此空间以获取更新。
答案 2 :(得分：2)
ErikR解释了为什么你不能生成一个必须包含所有路径的列表，但是可以从左边懒洋洋地列出路径。最简单的技巧，虽然是一个肮脏的技巧，但是要认识到结果永远不会是空的并且强迫Haskell上的这个事实。
paths (Rose x []) = [[x]]
paths (Rose x children) = map (x :) (a : as)
where
a : as = concatMap paths children
-- Note that we know here that children is non-empty, and therefore
-- the result will not be empty.
为了制作非常无限的玫瑰树，请考虑
infTree labels = Rose labels (infForest labels)
infForest labels = [Rose labels' (infForest labels')
| labels' <- map (: labels) [0..]]
作为chi points out，虽然paths的这个定义很有效，但在某些情况下它会永远重复最左边的路径，而且永远不会再到达。哎呀！因此，一些公平或对角遍历的尝试是必要的，以提供有趣/有用的结果。