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