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


-- | rose trees
--   
--   <a>Rose Trees</a> are trees with an unbounded number of branches per
--   node. Each node contains a value and zero or more subtrees.
@package rose
@version 0.1


-- | <a>Rose Trees</a> are trees with an unbounded number of branches per
--   node. Each node contains a value and zero or more subtrees.
module Rose

-- | A Rose tree. This type can be produced and consumed using the
--   <tt>Rose</tt> pattern.
data Rose a
pattern Rose :: a -> [Rose a] -> Rose a

-- | Generate a singleton rose tree. It has no leaves and one shoot.
--   
--   <pre>
--   &gt;&gt;&gt; singleton @Int 3
--   Rose 3 []
--   </pre>
singleton :: a -> Rose a

-- | Use coiteration to generate a rose tree from a seed.
--   
--   The coiteration terminates when the generating function returns an
--   empty list:
--   
--   <pre>
--   &gt;&gt;&gt; 'coiter' (\i -&gt; if i &gt; 3 then [] else [i + 1]) 0
--   Rose 0 [Rose 1 [Rose 2 [Rose 3 [Rose 4 []]]]]
--   </pre>
--   
--   An infinite, lazy generator for the fibonacci sequence:
--   
--   <pre>
--   &gt;&gt;&gt; take 10 $ map fst $ 'Data.Foldable.toList' $ 'coiter' (\(a, b) -&gt; [(b, a + b)]) (0, 1)
--   </pre>
coiter :: (a -> [a]) -> a -> Rose a

-- | Like <a>coiter</a> for comonadic values.
coiterW :: Comonad w => (w a -> [w a]) -> w a -> Rose a

-- | Unfold a rose tree from a seed.
unfold :: (b -> (a, [b])) -> b -> Rose a

-- | Unfold a rose tree from a seed, monadically.
unfoldM :: Monad m => (b -> m (a, [b])) -> b -> m (Rose a)

-- | Construct an <tt>Lens</tt> into a rose tree given a list of lenses
--   into the base functor.
--   
--   When the input list is empty, this is equivalent to <a>_extract</a>.
--   When the input list is non-empty, this composes the input lenses with
--   <a>_unwrap</a> to walk through the rose tree before using
--   <a>_extract</a> to get the element at the final location.
--   
--   For more on lenses see the <tt>lens</tt> package on hackage.
--   
--   <pre>
--   telescoped :: [Lens' [<a>Rose</a> a] (<a>Rose</a> a)]      -&gt; Lens' (<a>Rose</a> a) a
--   </pre>
--   
--   <pre>
--   telescoped :: [Traversal' [<a>Rose</a> a] (<a>Rose</a> a)] -&gt; Traversal' (<a>Rose</a> a) a
--   </pre>
--   
--   <pre>
--   telescoped :: [Getter [<a>Rose</a> a] (<a>Rose</a> a)]     -&gt; Getter (<a>Rose</a> a) a
--   </pre>
--   
--   <pre>
--   telescoped :: [Fold [<a>Rose</a> a] (<a>Rose</a> a)]       -&gt; Fold (<a>Rose</a> a) a
--   </pre>
--   
--   <pre>
--   telescoped :: [Setter' [<a>Rose</a> a] (<a>Rose</a> a)]    -&gt; Setter' (<a>Rose</a> a) a
--   </pre>
telescoped :: Functor f => [(Rose a -> f (Rose a)) -> [Rose a] -> f [Rose a]] -> (a -> f a) -> Rose a -> f (Rose a)

-- | Construct an <tt>Lens</tt> into a rose tree given a list of lenses
--   into the base functor.
--   
--   The only difference between this and <a>telescoped</a> is that
--   <a>telescoped</a> focuses on a single value, but this focuses on the
--   entire remaining subtree. When the input list is empty, this is
--   equivalent to <a>id</a>. When the input list is non-empty, this
--   composes the input lenses with <a>_unwrap</a> to walk through the rose
--   tree.
--   
--   For more on lenses see the <tt>lens</tt> package on hackage.
--   
--   <pre>
--   telescoped :: [Lens' [<a>Rose</a> a] (<a>Rose</a> a)]      -&gt; Lens' (<a>Rose</a> a) (<a>Rose</a> a)
--   </pre>
--   
--   <pre>
--   telescoped :: [Traversal' [<a>Rose</a> a] (<a>Rose</a> a)] -&gt; Traversal' (<a>Rose</a> a) (<a>Rose</a> a)
--   </pre>
--   
--   <pre>
--   telescoped :: [Getter [<a>Rose</a> a] (<a>Rose</a> a)]     -&gt; Getter (<a>Rose</a> a) (<a>Rose</a> a)
--   </pre>
--   
--   <pre>
--   telescoped :: [Fold [<a>Rose</a> a] (<a>Rose</a> a)]       -&gt; Fold (<a>Rose</a> a) (<a>Rose</a> a)
--   </pre>
--   
--   <pre>
--   telescoped :: [Setter' [<a>Rose</a> a] (<a>Rose</a> a)]    -&gt; Setter' (<a>Rose</a> a) (<a>Rose</a> a)
--   </pre>
telescoped_ :: Functor f => [(Rose a -> f (Rose a)) -> [Rose a] -> f [Rose a]] -> (Rose a -> f (Rose a)) -> Rose a -> f (Rose a)

-- | A <tt>Traversal'</tt> that gives access to all non-leaf elements of a
--   rose tree, where non-leaf is defined as <tt>x</tt> from <tt>Rose x
--   xs</tt> where <tt>null xs</tt> is <tt>False</tt>.
--   
--   Because this doesn't give access to all values in the rose tree, it
--   cannot be used to change types (use <a>traverse</a> for that).
shoots :: Applicative f => (a -> f a) -> Rose a -> f (Rose a)

-- | A <tt>Traversal'</tt> that gives access to all leaf elements of a rose
--   tree, where leaf is defined as <tt>x</tt> from <tt>Rose x xs</tt>
--   where <tt>null xs</tt> is <tt>True</tt>.
--   
--   Because this doesn't give access to all values in the rose tree, it
--   cannot be used to change types (use <a>traverse</a> for that).
leaves :: Applicative f => (a -> f a) -> Rose a -> f (Rose a)
instance Data.Functor.Classes.Ord1 Rose.Rose
instance GHC.Classes.Ord a => GHC.Classes.Ord (Rose.Rose a)
instance Control.Monad.Zip.MonadZip Rose.Rose
instance GHC.Base.Monad Rose.Rose
instance GHC.Base.Functor Rose.Rose
instance Data.Foldable.Foldable Rose.Rose
instance Data.Functor.Classes.Eq1 Rose.Rose
instance GHC.Classes.Eq a => GHC.Classes.Eq (Rose.Rose a)
instance Control.Comonad.Cofree.Class.ComonadCofree [] Rose.Rose
instance GHC.Base.Applicative Rose.Rose
instance GHC.Generics.Generic1 Rose.Rose
instance GHC.Generics.Generic (Rose.Rose a)
instance GHC.Show.Show a => GHC.Show.Show (Rose.Rose a)
instance Data.Functor.Classes.Show1 Rose.Rose
instance GHC.Read.Read a => GHC.Read.Read (Rose.Rose a)
instance Data.Functor.Classes.Read1 Rose.Rose
instance Data.Traversable.Traversable Rose.Rose
instance Control.Comonad.Comonad Rose.Rose