-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | A simple multi-way tree data structure.
--   
--   In some contexts, forests (collections of zero or more trees) are more
--   important than trees. The <i>data-forest</i> library provides a
--   <tt>Tree</tt> type much like the one from the popular
--   <i>containers</i> library, but it also provides a <tt>Forest</tt> type
--   with its own <tt>Functor</tt> and <tt>Foldable</tt> instances.
@package data-forest
@version 0.1.0.9


-- | Multi-way trees (also known as <i>rose trees</i>) and forests, similar
--   to <tt>Data.Tree</tt> from the popular <i>containers</i> library.
module Data.Forest

-- | A forest is defined completely by its <a>trees</a>.
--   
--   To construct a forest, use <a>forest</a> or <a>leaves</a>.
data Forest a

-- | A tree is defined completely by its <a>root</a> and its
--   <a>subforest</a>.
--   
--   To construct a tree, use <a>tree</a> or <a>leaf</a>.
data Tree a

-- | Construct a forest from a list of trees.
--   
--   <i><tt><a>forest</a> []</tt> is equivalent to <a>mempty</a>.</i>
forest :: [Tree a] -> Forest a

-- | Construct a tree with a root and subforest.
tree :: a -> Forest a -> Tree a

-- | Construct a tree with a single root and no subforest.
--   
--   <i><tt><a>leaf</a> x</tt> is equivalent to <tt><a>tree</a> x
--   <a>mempty</a></tt>.</i>
leaf :: a -> Tree a

-- | Construct a forest of depth 1, where each tree contains only a root.
--   
--   <i><a>leaves</a> is equivalent to <tt><a>forest</a> . fmap
--   <a>leaf</a></tt></i>
leaves :: [a] -> Forest a

-- | The trees that constitute the forest.
trees :: Forest a -> [Tree a]

-- | The value at the root node of the tree.
root :: Tree a -> a

-- | The forest containing all descendants of the tree's <a>root</a>.
subforest :: Tree a -> Forest a

-- | The tree's immediate subtrees.
--   
--   <i><a>subtrees</a> is equivalent to <tt><a>trees</a> .
--   <a>subforest</a></tt>.</i>
subtrees :: Tree a -> [Tree a]

-- | Catamorphism on forests.
--   
--   <pre>
--   &gt;&gt;&gt; 
--   :{
--   example :: Forest Char
--   example = forest
--       [ tree 'a' $ leaves "bc"
--       , tree 'd' $ forest
--           [ leaf 'e'
--           , tree 'f' $ leaves "g"
--           ]
--      ]
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; foldForest (intercalate ", " . fmap (\(a, b) -&gt; [a] &lt;&gt; " [" &lt;&gt; b &lt;&gt; "]")) example
--   "a [b [], c []], d [e [], f [g []]]"
--   </pre>
foldForest :: ([(a, b)] -> b) -> Forest a -> b

-- | Catamorphism on trees.
--   
--   <pre>
--   &gt;&gt;&gt; 
--   :{
--   example :: Tree Char
--   example = tree 'a' $ forest
--       [ tree 'b' $ leaves "cd"
--       , tree 'e' $ forest
--           [ leaf 'f'
--           , tree 'g' $ leaves "h"
--           ]
--      ]
--   :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; foldTree (\a bs -&gt; [a] &lt;&gt; " [" &lt;&gt; intercalate ", " bs &lt;&gt; "]") example
--   "a [b [c [], d []], e [f [], g [h []]]]"
--   </pre>
foldTree :: (a -> [b] -> b) -> Tree a -> b
instance GHC.Base.Monoid (Data.Forest.Forest a)
instance GHC.Base.Semigroup (Data.Forest.Forest a)
instance Data.Traversable.Traversable Data.Forest.Forest
instance Data.Foldable.Foldable Data.Forest.Forest
instance GHC.Base.Functor Data.Forest.Forest
instance GHC.Show.Show a => GHC.Show.Show (Data.Forest.Forest a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Forest.Forest a)
instance Data.Traversable.Traversable Data.Forest.Tree
instance Data.Foldable.Foldable Data.Forest.Tree
instance GHC.Base.Functor Data.Forest.Tree
instance GHC.Show.Show a => GHC.Show.Show (Data.Forest.Tree a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Data.Forest.Tree a)