Copyright  (c) Dominik Schrempf 2021 

License  GPL3.0orlater 
Maintainer  dominik.schrempf@gmail.com 
Stability  unstable 
Portability  portable 
Safe Haskell  None 
Language  Haskell2010 
Creation date: Thu Jan 17 09:57:29 2019.
Rooted Tree
s differs from a classical rose Tree
s in that they
have labeled branches.
For rooted topologies, please see Rooted
.
A Tree
is defined as:
data Tree e a = Node { branch :: e, label :: a, forest :: Forest e a }
where
type Forest e a = [Tree e a]
This means, that the word Node
is reserved for the constructor of a tree,
and that a Node
has an attached branch
, a label
, and a subforest
.
The terms Node and label referring to the value constructor Node
and
the record function label
, respectively, are not to be confused. The
elements of the subforest are often called children.
In mathematical terms: A Tree
is a directed acyclic graph without loops,
with vertex labels, and with edge labels.
A short recap of recursive tree traversals:
 Preorder: Root first, then sub trees from left to right. Also called depth first.
 Inorder: Only valid for bifurcating trees. Left sub tree first, then root, then right sub tree.
 Postorder: Sub trees from left to right, then the root. Also called breadth first.
Here, preorder traversals are used exclusively, for example, by accessor
functions such as branches
, or labels
which is the same as toList
.
Please let me know, if postorder algorithms are required.
Synopsis
 data Tree e a = Node {}
 type Forest e a = [Tree e a]
 fromRoseTree :: Tree a > Tree () a
 toTreeBranchLabels :: Tree e a > Tree e
 toTreeNodeLabels :: Tree e a > Tree a
 leaves :: Tree e a > [a]
 duplicateLeaves :: Ord a => Tree e a > Bool
 setStem :: e > Tree e a > Tree e a
 modifyStem :: (e > e) > Tree e a > Tree e a
 branches :: Tree e a > [e]
 setBranches :: Bitraversable t => [f] > t e a > Maybe (t f a)
 setLabel :: a > Tree e a > Tree e a
 modifyLabel :: (a > a) > Tree e a > Tree e a
 labels :: Tree e a > [a]
 setLabels :: Traversable t => [b] > t a > Maybe (t b)
 identify :: Traversable t => t a > t Int
 degree :: Tree e a > Int
 depth :: Tree e a > Int
 prune :: Semigroup e => Tree e a > Tree e a
 dropNodesWith :: (a > Bool) > Tree e a > Maybe (Tree e a)
 dropLeavesWith :: (a > Bool) > Tree e a > Maybe (Tree e a)
 zipTreesWith :: (e1 > e2 > e) > (a1 > a2 > a) > Tree e1 a1 > Tree e2 a2 > Maybe (Tree e a)
 zipTrees :: Tree e1 a1 > Tree e2 a2 > Maybe (Tree (e1, e2) (a1, a2))
 flipLabels :: Tree e a > Tree a e
 newtype ZipTree e a = ZipTree {
 getZipTree :: Tree e a
 newtype BranchTree a e = BranchTree {
 getBranchTree :: Tree e a
 newtype ZipBranchTree a e = ZipBranchTree {
 getZipBranchTree :: Tree e a
Tree with branch labels
Rooted rose trees with branch labels.
Unary instances such as Functor
act on node labels, and not on branch
labels. Binary instances such as Bifunctor
act on both labels (first
acts
on branches, second
on node labels).
Instances
Bifunctor Tree Source #  The function 
Bitraversable Tree Source #  
Defined in ELynx.Tree.Rooted bitraverse :: Applicative f => (a > f c) > (b > f d) > Tree a b > f (Tree c d) #  
Bifoldable Tree Source #  
(Semigroup e, Monoid e) => Monad (Tree e) Source #  The The 
Functor (Tree e) Source #  Map over node labels. 
(Semigroup e, Monoid e) => Applicative (Tree e) Source #  The The This instance is similar to the one provided by 
Foldable (Tree e) Source #  Combine node labels in preorder. 
Defined in ELynx.Tree.Rooted fold :: Monoid m => Tree e m > m # foldMap :: Monoid m => (a > m) > Tree e a > m # foldMap' :: Monoid m => (a > m) > Tree e a > m # foldr :: (a > b > b) > b > Tree e a > b # foldr' :: (a > b > b) > b > Tree e a > b # foldl :: (b > a > b) > b > Tree e a > b # foldl' :: (b > a > b) > b > Tree e a > b # foldr1 :: (a > a > a) > Tree e a > a # foldl1 :: (a > a > a) > Tree e a > a # elem :: Eq a => a > Tree e a > Bool # maximum :: Ord a => Tree e a > a # minimum :: Ord a => Tree e a > a #  
Traversable (Tree e) Source #  
Comonad (Tree e) Source #  
(Eq e, Eq a) => Eq (Tree e a) Source #  
(Data e, Data a) => Data (Tree e a) Source #  
Defined in ELynx.Tree.Rooted gfoldl :: (forall d b. Data d => c (d > b) > d > c b) > (forall g. g > c g) > Tree e a > c (Tree e a) # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c (Tree e a) # toConstr :: Tree e a > Constr # dataTypeOf :: Tree e a > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c (Tree e a)) # dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) > Maybe (c (Tree e a)) # gmapT :: (forall b. Data b => b > b) > Tree e a > Tree e a # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > Tree e a > r # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > Tree e a > r # gmapQ :: (forall d. Data d => d > u) > Tree e a > [u] # gmapQi :: Int > (forall d. Data d => d > u) > Tree e a > u # gmapM :: Monad m => (forall d. Data d => d > m d) > Tree e a > m (Tree e a) # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > Tree e a > m (Tree e a) # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > Tree e a > m (Tree e a) #  
(Read e, Read a) => Read (Tree e a) Source #  
(Show e, Show a) => Show (Tree e a) Source #  
Generic (Tree e a) Source #  
(NFData e, NFData a) => NFData (Tree e a) Source #  
Defined in ELynx.Tree.Rooted  
(ToJSON e, ToJSON a) => ToJSON (Tree e a) Source #  
Defined in ELynx.Tree.Rooted  
(FromJSON e, FromJSON a) => FromJSON (Tree e a) Source #  
type Rep (Tree e a) Source #  
Defined in ELynx.Tree.Rooted type Rep (Tree e a) = D1 ('MetaData "Tree" "ELynx.Tree.Rooted" "elynxtree0.6.0.0FQkEU9t6m33732ommPyIXg" 'False) (C1 ('MetaCons "Node" 'PrefixI 'True) (S1 ('MetaSel ('Just "branch") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 e) :*: (S1 ('MetaSel ('Just "label") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "forest") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Forest e a))))) 
Access leaves, branches and labels
modifyStem :: (e > e) > Tree e a > Tree e a Source #
Modify the stem of a tree.
setBranches :: Bitraversable t => [f] > t e a > Maybe (t f a) Source #
Set branch labels in preorder.
Return Nothing
if the provided list of branch labels is too short.
modifyLabel :: (a > a) > Tree e a > Tree e a Source #
Modify the root label of a tree.
setLabels :: Traversable t => [b] > t a > Maybe (t b) Source #
Set node labels in preorder.
Return Nothing
if the provided list of node labels is too short.
identify :: Traversable t => t a > t Int Source #
Label the nodes in preorder with unique indices starting at 0.
Structure
degree :: Tree e a > Int Source #
Degree of the root node.
The degree of a node is the number of branches attached to the node.
depth :: Tree e a > Int Source #
Depth of a tree.
The depth of a tree is the largest number of nodes traversed on a path from the root to a leaf.
By convention, the depth is larger equal 1. That is, the depth of a leaf tree is 1.
prune :: Semigroup e => Tree e a > Tree e a Source #
Prune degree two nodes.
The label of a pruned node is lost. The branches are combined according to
their Semigroup
instance of the form
daughterBranch parentBranch > combinedBranch
.
dropNodesWith :: (a > Bool) > Tree e a > Maybe (Tree e a) Source #
Drop nodes satisfying predicate.
Degree two nodes may arise.
Also drop nodes of which all daughter nodes are dropped.
Return Nothing
if
 The root node satisfies the predicate.
 All daughter nodes of the root are dropped.
dropLeavesWith :: (a > Bool) > Tree e a > Maybe (Tree e a) Source #
Drop leaves satisfying predicate.
Degree two nodes may arise.
Also drop nodes of which all daughter nodes are dropped.
Return Nothing
if all leaves satisfy the predicate.
zipTreesWith :: (e1 > e2 > e) > (a1 > a2 > a) > Tree e1 a1 > Tree e2 a2 > Maybe (Tree e a) Source #
Zip two trees with the same topology.
This function differs from the Applicative
instance of ZipTree
in that it
fails when the topologies don't match. Further, it allows specification of a
zipping function for the branches.
Return Nothing
if the topologies are different.
flipLabels :: Tree e a > Tree a e Source #
Flip the branch and node lables.
Newtypes with specific instances
This newtype provides a ziplike applicative instance, similar to
ZipList
.
The default applicative instance of Tree
is not ziplike, because the
ziplike instance makes the Monad instance meaningless (similar to the
behavior observed with lists).
ZipTree  

Instances
Functor (ZipTree e) Source #  
Monoid e => Applicative (ZipTree e) Source #  The
ZipTree {getZipTree = Node {branch = "+3", label = 3, forest = [Node {branch = "*5", label = 5, forest = []},Node {branch = "+10", label = 12, forest = []}]}} 
Foldable (ZipTree e) Source #  
Defined in ELynx.Tree.Rooted fold :: Monoid m => ZipTree e m > m # foldMap :: Monoid m => (a > m) > ZipTree e a > m # foldMap' :: Monoid m => (a > m) > ZipTree e a > m # foldr :: (a > b > b) > b > ZipTree e a > b # foldr' :: (a > b > b) > b > ZipTree e a > b # foldl :: (b > a > b) > b > ZipTree e a > b # foldl' :: (b > a > b) > b > ZipTree e a > b # foldr1 :: (a > a > a) > ZipTree e a > a # foldl1 :: (a > a > a) > ZipTree e a > a # toList :: ZipTree e a > [a] # length :: ZipTree e a > Int # elem :: Eq a => a > ZipTree e a > Bool # maximum :: Ord a => ZipTree e a > a # minimum :: Ord a => ZipTree e a > a #  
Traversable (ZipTree e) Source #  
Comonad (ZipTree e) Source #  
(Eq e, Eq a) => Eq (ZipTree e a) Source #  
(Data e, Data a) => Data (ZipTree e a) Source #  
Defined in ELynx.Tree.Rooted gfoldl :: (forall d b. Data d => c (d > b) > d > c b) > (forall g. g > c g) > ZipTree e a > c (ZipTree e a) # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c (ZipTree e a) # toConstr :: ZipTree e a > Constr # dataTypeOf :: ZipTree e a > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c (ZipTree e a)) # dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) > Maybe (c (ZipTree e a)) # gmapT :: (forall b. Data b => b > b) > ZipTree e a > ZipTree e a # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > ZipTree e a > r # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > ZipTree e a > r # gmapQ :: (forall d. Data d => d > u) > ZipTree e a > [u] # gmapQi :: Int > (forall d. Data d => d > u) > ZipTree e a > u # gmapM :: Monad m => (forall d. Data d => d > m d) > ZipTree e a > m (ZipTree e a) # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > ZipTree e a > m (ZipTree e a) # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > ZipTree e a > m (ZipTree e a) #  
(Read e, Read a) => Read (ZipTree e a) Source #  
(Show e, Show a) => Show (ZipTree e a) Source #  
Generic (ZipTree e a) Source #  
type Rep (ZipTree e a) Source #  
Defined in ELynx.Tree.Rooted 
newtype BranchTree a e Source #
This newtype provides instances acting on the branch labels, and not on the
node labels as it is the case in Tree
.
BranchTree  

Instances
Functor (BranchTree a) Source #  Map over branch labels. 
Defined in ELynx.Tree.Rooted fmap :: (a0 > b) > BranchTree a a0 > BranchTree a b # (<$) :: a0 > BranchTree a b > BranchTree a a0 #  
Monoid a => Applicative (BranchTree a) Source #  
Defined in ELynx.Tree.Rooted pure :: a0 > BranchTree a a0 # (<*>) :: BranchTree a (a0 > b) > BranchTree a a0 > BranchTree a b # liftA2 :: (a0 > b > c) > BranchTree a a0 > BranchTree a b > BranchTree a c # (*>) :: BranchTree a a0 > BranchTree a b > BranchTree a b # (<*) :: BranchTree a a0 > BranchTree a b > BranchTree a a0 #  
Foldable (BranchTree a) Source #  Combine branch labels in preorder. 
Defined in ELynx.Tree.Rooted fold :: Monoid m => BranchTree a m > m # foldMap :: Monoid m => (a0 > m) > BranchTree a a0 > m # foldMap' :: Monoid m => (a0 > m) > BranchTree a a0 > m # foldr :: (a0 > b > b) > b > BranchTree a a0 > b # foldr' :: (a0 > b > b) > b > BranchTree a a0 > b # foldl :: (b > a0 > b) > b > BranchTree a a0 > b # foldl' :: (b > a0 > b) > b > BranchTree a a0 > b # foldr1 :: (a0 > a0 > a0) > BranchTree a a0 > a0 # foldl1 :: (a0 > a0 > a0) > BranchTree a a0 > a0 # toList :: BranchTree a a0 > [a0] # null :: BranchTree a a0 > Bool # length :: BranchTree a a0 > Int # elem :: Eq a0 => a0 > BranchTree a a0 > Bool # maximum :: Ord a0 => BranchTree a a0 > a0 # minimum :: Ord a0 => BranchTree a a0 > a0 # sum :: Num a0 => BranchTree a a0 > a0 # product :: Num a0 => BranchTree a a0 > a0 #  
Traversable (BranchTree a) Source #  
Defined in ELynx.Tree.Rooted traverse :: Applicative f => (a0 > f b) > BranchTree a a0 > f (BranchTree a b) # sequenceA :: Applicative f => BranchTree a (f a0) > f (BranchTree a a0) # mapM :: Monad m => (a0 > m b) > BranchTree a a0 > m (BranchTree a b) # sequence :: Monad m => BranchTree a (m a0) > m (BranchTree a a0) #  
Comonad (BranchTree a) Source #  
Defined in ELynx.Tree.Rooted extract :: BranchTree a a0 > a0 # duplicate :: BranchTree a a0 > BranchTree a (BranchTree a a0) # extend :: (BranchTree a a0 > b) > BranchTree a a0 > BranchTree a b #  
(Eq e, Eq a) => Eq (BranchTree a e) Source #  
Defined in ELynx.Tree.Rooted (==) :: BranchTree a e > BranchTree a e > Bool # (/=) :: BranchTree a e > BranchTree a e > Bool #  
(Data a, Data e) => Data (BranchTree a e) Source #  
Defined in ELynx.Tree.Rooted gfoldl :: (forall d b. Data d => c (d > b) > d > c b) > (forall g. g > c g) > BranchTree a e > c (BranchTree a e) # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c (BranchTree a e) # toConstr :: BranchTree a e > Constr # dataTypeOf :: BranchTree a e > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c (BranchTree a e)) # dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) > Maybe (c (BranchTree a e)) # gmapT :: (forall b. Data b => b > b) > BranchTree a e > BranchTree a e # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > BranchTree a e > r # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > BranchTree a e > r # gmapQ :: (forall d. Data d => d > u) > BranchTree a e > [u] # gmapQi :: Int > (forall d. Data d => d > u) > BranchTree a e > u # gmapM :: Monad m => (forall d. Data d => d > m d) > BranchTree a e > m (BranchTree a e) # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > BranchTree a e > m (BranchTree a e) # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > BranchTree a e > m (BranchTree a e) #  
(Read e, Read a) => Read (BranchTree a e) Source #  
Defined in ELynx.Tree.Rooted readsPrec :: Int > ReadS (BranchTree a e) # readList :: ReadS [BranchTree a e] # readPrec :: ReadPrec (BranchTree a e) # readListPrec :: ReadPrec [BranchTree a e] #  
(Show e, Show a) => Show (BranchTree a e) Source #  
Defined in ELynx.Tree.Rooted showsPrec :: Int > BranchTree a e > ShowS # show :: BranchTree a e > String # showList :: [BranchTree a e] > ShowS #  
Generic (BranchTree a e) Source #  
Defined in ELynx.Tree.Rooted type Rep (BranchTree a e) :: Type > Type # from :: BranchTree a e > Rep (BranchTree a e) x # to :: Rep (BranchTree a e) x > BranchTree a e #  
type Rep (BranchTree a e) Source #  
Defined in ELynx.Tree.Rooted type Rep (BranchTree a e) = D1 ('MetaData "BranchTree" "ELynx.Tree.Rooted" "elynxtree0.6.0.0FQkEU9t6m33732ommPyIXg" 'True) (C1 ('MetaCons "BranchTree" 'PrefixI 'True) (S1 ('MetaSel ('Just "getBranchTree") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Tree e a)))) 
newtype ZipBranchTree a e Source #
Like ZipTree
but act on branch labels; see BranchTree
.
ZipBranchTree  

Instances
Functor (ZipBranchTree a) Source #  Map over branch labels. 
Defined in ELynx.Tree.Rooted fmap :: (a0 > b) > ZipBranchTree a a0 > ZipBranchTree a b # (<$) :: a0 > ZipBranchTree a b > ZipBranchTree a a0 #  
Monoid a => Applicative (ZipBranchTree a) Source #  See the 
Defined in ELynx.Tree.Rooted pure :: a0 > ZipBranchTree a a0 # (<*>) :: ZipBranchTree a (a0 > b) > ZipBranchTree a a0 > ZipBranchTree a b # liftA2 :: (a0 > b > c) > ZipBranchTree a a0 > ZipBranchTree a b > ZipBranchTree a c # (*>) :: ZipBranchTree a a0 > ZipBranchTree a b > ZipBranchTree a b # (<*) :: ZipBranchTree a a0 > ZipBranchTree a b > ZipBranchTree a a0 #  
Foldable (ZipBranchTree a) Source #  Combine branch labels in preorder. 
Defined in ELynx.Tree.Rooted fold :: Monoid m => ZipBranchTree a m > m # foldMap :: Monoid m => (a0 > m) > ZipBranchTree a a0 > m # foldMap' :: Monoid m => (a0 > m) > ZipBranchTree a a0 > m # foldr :: (a0 > b > b) > b > ZipBranchTree a a0 > b # foldr' :: (a0 > b > b) > b > ZipBranchTree a a0 > b # foldl :: (b > a0 > b) > b > ZipBranchTree a a0 > b # foldl' :: (b > a0 > b) > b > ZipBranchTree a a0 > b # foldr1 :: (a0 > a0 > a0) > ZipBranchTree a a0 > a0 # foldl1 :: (a0 > a0 > a0) > ZipBranchTree a a0 > a0 # toList :: ZipBranchTree a a0 > [a0] # null :: ZipBranchTree a a0 > Bool # length :: ZipBranchTree a a0 > Int # elem :: Eq a0 => a0 > ZipBranchTree a a0 > Bool # maximum :: Ord a0 => ZipBranchTree a a0 > a0 # minimum :: Ord a0 => ZipBranchTree a a0 > a0 # sum :: Num a0 => ZipBranchTree a a0 > a0 # product :: Num a0 => ZipBranchTree a a0 > a0 #  
Traversable (ZipBranchTree a) Source #  
Defined in ELynx.Tree.Rooted traverse :: Applicative f => (a0 > f b) > ZipBranchTree a a0 > f (ZipBranchTree a b) # sequenceA :: Applicative f => ZipBranchTree a (f a0) > f (ZipBranchTree a a0) # mapM :: Monad m => (a0 > m b) > ZipBranchTree a a0 > m (ZipBranchTree a b) # sequence :: Monad m => ZipBranchTree a (m a0) > m (ZipBranchTree a a0) #  
Comonad (ZipBranchTree a) Source #  
Defined in ELynx.Tree.Rooted extract :: ZipBranchTree a a0 > a0 # duplicate :: ZipBranchTree a a0 > ZipBranchTree a (ZipBranchTree a a0) # extend :: (ZipBranchTree a a0 > b) > ZipBranchTree a a0 > ZipBranchTree a b #  
(Eq e, Eq a) => Eq (ZipBranchTree a e) Source #  
Defined in ELynx.Tree.Rooted (==) :: ZipBranchTree a e > ZipBranchTree a e > Bool # (/=) :: ZipBranchTree a e > ZipBranchTree a e > Bool #  
(Data a, Data e) => Data (ZipBranchTree a e) Source #  
Defined in ELynx.Tree.Rooted gfoldl :: (forall d b. Data d => c (d > b) > d > c b) > (forall g. g > c g) > ZipBranchTree a e > c (ZipBranchTree a e) # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c (ZipBranchTree a e) # toConstr :: ZipBranchTree a e > Constr # dataTypeOf :: ZipBranchTree a e > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c (ZipBranchTree a e)) # dataCast2 :: Typeable t => (forall d e0. (Data d, Data e0) => c (t d e0)) > Maybe (c (ZipBranchTree a e)) # gmapT :: (forall b. Data b => b > b) > ZipBranchTree a e > ZipBranchTree a e # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > ZipBranchTree a e > r # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > ZipBranchTree a e > r # gmapQ :: (forall d. Data d => d > u) > ZipBranchTree a e > [u] # gmapQi :: Int > (forall d. Data d => d > u) > ZipBranchTree a e > u # gmapM :: Monad m => (forall d. Data d => d > m d) > ZipBranchTree a e > m (ZipBranchTree a e) # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > ZipBranchTree a e > m (ZipBranchTree a e) # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > ZipBranchTree a e > m (ZipBranchTree a e) #  
(Read e, Read a) => Read (ZipBranchTree a e) Source #  
Defined in ELynx.Tree.Rooted readsPrec :: Int > ReadS (ZipBranchTree a e) # readList :: ReadS [ZipBranchTree a e] # readPrec :: ReadPrec (ZipBranchTree a e) # readListPrec :: ReadPrec [ZipBranchTree a e] #  
(Show e, Show a) => Show (ZipBranchTree a e) Source #  
Defined in ELynx.Tree.Rooted showsPrec :: Int > ZipBranchTree a e > ShowS # show :: ZipBranchTree a e > String # showList :: [ZipBranchTree a e] > ShowS #  
Generic (ZipBranchTree a e) Source #  
Defined in ELynx.Tree.Rooted type Rep (ZipBranchTree a e) :: Type > Type # from :: ZipBranchTree a e > Rep (ZipBranchTree a e) x # to :: Rep (ZipBranchTree a e) x > ZipBranchTree a e #  
type Rep (ZipBranchTree a e) Source #  
Defined in ELynx.Tree.Rooted type Rep (ZipBranchTree a e) = D1 ('MetaData "ZipBranchTree" "ELynx.Tree.Rooted" "elynxtree0.6.0.0FQkEU9t6m33732ommPyIXg" 'True) (C1 ('MetaCons "ZipBranchTree" 'PrefixI 'True) (S1 ('MetaSel ('Just "getZipBranchTree") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Tree e a)))) 