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


-- | Python-generators notation for creation of monadic lists
--   
--   Consumer and Generator monad transformers to create and iterate
--   <a>ListT</a>s in a manner similar to Python generators.
@package generator
@version 0.5.2


-- | A monad transformer for the [partial] consumption of <a>List</a>s. The
--   interface closely mimics iterators in languages such as Python.
--   
--   It is often nicer to avoid using Consumer and to use folds and
--   higher-order functions instead.
module Control.Monad.Consumer

-- | A monad tranformer for consuming <a>List</a>s.
data ConsumerT v m a

-- | Consume a <a>ListT</a>
evalConsumerT :: (List l) => ConsumerT v (ItemM l) a -> l v -> ItemM l a

-- | Consume/get the next value
next :: (Monad m) => ConsumerT v m (Maybe v)

-- | Return an instance of the underlying monad that will use the given
--   <a>ConsumerT</a> to consume the remaining values. After this action
--   there are no more items to consume (they belong to the given ConsumerT
--   now)
consumeRestM :: (Monad m) => ConsumerT a m b -> ConsumerT a m (m b)
instance (MonadIO m) => MonadIO (ConsumerT v m)
instance MonadTrans (ConsumerT v)
instance (Monad m) => Applicative (ConsumerT v m)
instance (Monad m) => Monad (ConsumerT v m)
instance (Monad m) => Functor (ConsumerT v m)


-- | A difference-list monad transformer / a monadic difference-list.
--   
--   Difference lists are lists with <i>O(1)</i> append (instead of
--   <i>O(N)</i>).
--   
--   Transforming a difference list to a list is <i>O(1)</i>, a must be
--   done to access a difference list. The transformation from a list to a
--   difference list is <i>O(N)</i>.
module Control.Monad.DList

-- | A monadic difference-list
newtype DListT m a
DListT :: (ListT m a -> ListT m a) -> DListT m a
runDListT :: DListT m a -> ListT m a -> ListT m a
instance MonadTrans DListT
instance (Monad m) => List (DListT m)
instance (Monad m) => MonadPlus (DListT m)
instance (Monad m) => Applicative (DListT m)
instance (Monad m) => Monad (DListT m)
instance (Monad m) => Functor (DListT m)
instance Monoid (DListT l a)


-- | A monad transformer for the creation of Lists. Similar to Python's
--   generators.
--   
--   <pre>
--   import Data.List.Class (convList)
--   
--   hanoi 0 _ _ _ = mempty
--   hanoi n from to other =
--     generate $ do
--       yields $ hanoi (n-1) from other to
--       yield (from, to)
--       yields $ hanoi (n-1) other to from
--   
--   &gt; convList (hanoi 3 'A' 'B' 'C') :: [(Char, Char)]
--   [('A','B'),('A','C'),('B','C'),('A','B'),('C','A'),('C','B'),('A','B')]
--   </pre>
module Control.Monad.Generator

-- | A monad transformer to create Lists. <a>generate</a> transforms a
--   <a>GeneratorT v m a</a> to a <a>DListT m a</a>.
data GeneratorT v m a

-- | <i>O(1)</i>, Transform a GeneratorT to a <a>DListT</a>
generate :: (Monad m) => GeneratorT v m () -> DListT m v

-- | <i>O(1)</i>, Output a result value
yield :: (Monad m) => v -> GeneratorT v m ()

-- | <i>O(1)</i>, Output all the values of a <a>DListT</a>.
yields :: (Monad m) => DListT m v -> GeneratorT v m ()
instance (MonadIO m) => MonadIO (GeneratorT v m)
instance MonadTrans (GeneratorT v)
instance (Monad m) => Applicative (GeneratorT v m)
instance (Monad m) => Monad (GeneratorT v m)
instance (Monad m) => Functor (GeneratorT v m)