Hi Haskell Helpers,
For a hobby projet to learn haskell, I'm trying to use this kind of interleaved
tree structure (simplified):
> data ANode a b = ANode a [BNode a b] [BNode a b]
> data BNode a b = BNode b [ANode a b] [ANode a b]
The first list of each node is for links "up", the second for "down".
I can navigate with functions like:
> type UpRank = Int -- index in the list of nodes
> type DownRank = Int
>
> upA :: UpRank -> ANode a b -> Maybe (BNode a b, DownRank)
> downB :: DownRank -> BNode a b -> Maybe (ANode a b, UpRank)
Such as going first up then down leads me to the same point (actually
this simplified structure is not enough to do this, but is enough to
show my problem simply). Thee are also of course upB and downA.
>From this idea I have devised a kind of zipper to navigate the tree,
add nodes, and be able to step back. However, with this pattern of
interleaving a and b values, I could not help but duplicating in a way
every data or function declaration, to apply from an A or a B, and
often code is very similar (like for upA and downB).
Also, I want to go through the tree and modify it keeping the same
structure, applying different functions to A and B nodes, like a "map"
involving a pair of functions that will be applied alternatively. I
also want a kind of "fold". This leads very often to pairs or Either:
> (a -> a, b -> b)
> (ANode a b -> ANode a b, BNode a b -> BNode a b)
> Either (ANode a b) (BNode a b)
Out of curiosity, is all this (duplicating functions for alternating type
variables, using pairs) a known pattern ? Does it have a name ? Are
there well known (and less tedious) alternatives, or higher-level
workarounds ?
Thanks for any hint,
Eric
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe