Traversing a rosetree to generate a new rosetree - f#

Question

I have a data type that is very close to a rosetree
type RoseTree<'T> =
{
Root: 'T
Children: LazyList<RoseTree<'T>>
}
I want to take instances of this tree and map it to a new tree but where the calculation in a specific node is dependent on values in other nodes, a simple example would be take a RoseTree and "count" the nodes in some traversal and map it to a RoseTree
so
()
-> ()
->()
-> ()
->()
->()
and get
0
-> 1
-> 2
-> 3
-> 4
-> 5
I can hand write out a specific recursive function to do this, but I was hoping i could use some off the shelf functions to do this sort of thing simply by passing a function that accumulates the 'count'.
(the actual traversal path probably doesnt massively matter)
The usual suspects don't seem to fit though.
map : ('a->'b) -> RoseTree<'a> -> RoseTree<'b>
this maps isolated nodes, with no reference to other nodes.
If this were a List then fold would work, an accumator being folded through each element could generate a new List whilst counting, but folding a tree doesnt seem to work like this (this is the Haskell data-tree implementation)
foldTree :: (a -> [b] -> b) -> Tree a -> b
this seems to process each child by mapping the subtrees over the fold in isolation to each other, there is no accumulator that gets passed around each node in turn.
If we take unfold
unfold : ('a -> 'b * LazyList<'a>) -> 'a -> RoseTree<'a>
then the seed would be something like
int * RoseTree<unit>
but it seems that the unfolder function generates each subtree effectively in isolation to every other subtree by generating a list of new seeds.
(this is quite surprising, I felt that 'unfold' was the goto function to generate any tree).
So out of the standard set of funtional patterns/typeclasses, is there one that can be used for this sort of traveral + accumulator type processing?
(I do know about Zippers, but they seem to be overkill for this sort of general desire to process each node in turn and accumulate.
I can handwrite something that does specifically what i want, something like:
let foldish : ('accum -> 'a -> 'accum * 'b) -> RoseTree<'a> -> 'accum -> RoseTree<'b> =
maybe doing something like a depth first search and traversing the Tree and recording the path I take, then use list.fold to label the nodes with numbers and then unfold a new tree from it, seems a bit mechanical and i'd rather use 'standard' idioms/patterns if one exists).

Answer 1

If you want the output tree to have the same shape as the input tree, this sounds a lot like mapFold:
let rec mapFold (mapping : 'State -> 'T -> 'Result * 'State) (state : 'State) (tree : RoseTree<'T>) : RoseTree<'Result> * 'State =
let result, state' = mapping state tree.Root
let children, state'' =
List.mapFold (mapFold mapping) state' tree.Children
let tree' =
{
Root = result
Children = children
}
tree', state''
Note that I made the children non-lazy for simplicity:
type RoseTree<'T> =
{
Root: 'T
Children: List<RoseTree<'T>>
}
Test case:
let tree =
{
Root = ()
Children =
[
{
Root = ()
Children =
[ { Root = (); Children = [] } ]
}
{
Root = ()
Children =
[
{ Root = (); Children = [] }
{ Root = (); Children = [] }
]
}
]
}
(0, tree)
||> mapFold (fun count _ ->
count, count + 1)
|> fst
|> printfn "%A"
Output:
{ Root = 0
Children =
[{ Root = 1
Children = [{ Root = 2
Children = [] }] };
{ Root = 3
Children = [{ Root = 4
Children = [] }; { Root = 5
Children = [] }] }] }