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


-- | List monad transformer and class
--   
--   A List monad transformer and a List class. With standard list
--   operations for Lists
@package List
@version 0.2


-- | The <a>List</a> class and actions for lists
module Data.List.Class

-- | A class for list types. Every list has an underlying monad.
class (MonadPlus l, Monad (ItemM l)) => List l where { type family ItemM l :: * -> *; }
runList :: (List l) => l a -> ItemM l (ListItem l a)
joinL :: (List l) => ItemM l (l a) -> l a
data ListItem l a
Nil :: ListItem l a
Cons :: a -> l a -> ListItem l a
headL :: ListItem l a -> a
tailL :: ListItem l a -> l a

-- | Prepend an item to a <a>MonadPlus</a>
cons :: (MonadPlus m) => a -> m a -> m a

-- | Convert a list to a <a>MonadPlus</a>
--   
--   <pre>
--   &gt; fromList [] :: Maybe Int
--   Nothing
--   &gt; fromList [5] :: Maybe Int
--   Just 5
--   </pre>
fromList :: (MonadPlus m) => [a] -> m a

-- | filter for any MonadPlus
--   
--   <pre>
--   &gt; filter (&gt; 5) (Just 3)
--   Nothing
--   </pre>
filter :: (MonadPlus m) => (a -> Bool) -> m a -> m a
repeat :: (MonadPlus m) => a -> m a
takeWhile :: (List l) => (a -> Bool) -> l a -> l a
genericTake :: (Integral i, List l) => i -> l a -> l a
scanl :: (List l) => (a -> b -> a) -> a -> l b -> l a
transpose :: (List l) => l (l a) -> l (l a)
zip :: (List l) => l a -> l b -> l (a, b)
zipWith :: (List l) => (a -> b -> c) -> l a -> l b -> l c

-- | foldr for <a>List</a>s. the result and 'right side' values are monadic
--   actions.
foldrL :: (List l) => (a -> ItemM l b -> ItemM l b) -> ItemM l b -> l a -> ItemM l b

-- | An action to do foldl for <a>List</a>s
foldlL :: (List l) => (a -> b -> a) -> a -> l b -> ItemM l a

-- | An action to transform a <a>List</a> to a list
--   
--   <pre>
--   &gt; runIdentity $ toList "hello!"
--   "hello!"
--   </pre>
toList :: (List l) => l a -> ItemM l [a]

-- | Consume a list (execute its actions) and return its length
--   
--   <pre>
--   &gt; runIdentity $ lengthL [1,2,3]
--   3
--   </pre>
lengthL :: (Integral i, List l) => l a -> ItemM l i

-- | Consume all items and return the last one
--   
--   <pre>
--   &gt; runIdentity $ lastL "hello"
--   'o'
--   </pre>
lastL :: (List l) => l a -> ItemM l a

-- | Merge two lists sorted by a criteria given the criteria
--   
--   <pre>
--   &gt; merge2On id "01568" "239"
--   "01235689"
--   </pre>
merge2On :: (Ord b, List l) => (a -> b) -> l a -> l a -> l a

-- | Merge many lists sorted by a criteria given the criteria
--   
--   <pre>
--   &gt; mergeOn length [["hi", "hey", "hello"], ["cat", "falcon"], ["banana", "cucumber"]]
--   ["hi","cat","hey","hello","banana","falcon","cucumber"]
--   </pre>
mergeOn :: (Ord b, List l) => (a -> b) -> l (l a) -> l a

-- | Execute the monadic actions in a <a>List</a>
execute :: (List l) => l a -> ItemM l ()

-- | Transform a list of actions to a list of their results
--   
--   <pre>
--   &gt; joinM [Identity 4, Identity 7]
--   [4,7]
--   </pre>
joinM :: (List l) => l (ItemM l a) -> l a

-- | Transform the underlying monad of a list given a way to transform the
--   monad
--   
--   <pre>
--   &gt; import Data.List.Tree (bfs)
--   &gt; bfs (transformListMonad (\(Identity x) -&gt; [x, x]) "hey" :: ListT [] Char)
--   "hheeeeyyyyyyyy"
--   </pre>
transformListMonad :: (List l, List k) => (forall x. ItemM l x -> ItemM k x) -> l a -> k a
instance (Eq a, Eq (l a)) => Eq (ListItem l a)
instance (Ord a, Ord (l a)) => Ord (ListItem l a)
instance (Read a, Read (l a)) => Read (ListItem l a)
instance (Show a, Show (l a)) => Show (ListItem l a)
instance List []


-- | A list monad transformer / a monadic list.
--   
--   Monadic list example: A program which reads numbers from the user and
--   accumulates them.
--   
--   <pre>
--   import Control.Monad.ListT (ListT)
--   import Data.List.Class (execute, joinM, repeat, scanl, takeWhile)
--   import Prelude hiding (repeat, scanl, takeWhile)
--   
--   main =
--     execute . joinM . fmap print .
--     scanl (+) 0 .
--     fmap (fst . head) .
--     takeWhile (not . null) .
--     fmap reads .
--     joinM $ (repeat getLine :: ListT IO (IO String))
--   </pre>
module Control.Monad.ListT
data ListT m a
instance (Show (m (ListItem (ListT m) a))) => Show (ListT m a)
instance (Read (m (ListItem (ListT m) a))) => Read (ListT m a)
instance (Ord (m (ListItem (ListT m) a))) => Ord (ListT m a)
instance (Eq (m (ListItem (ListT m) a))) => Eq (ListT m a)
instance (MonadState s m) => MonadState s (ListT m)
instance (MonadReader s m) => MonadReader s (ListT m)
instance (MonadError e m) => MonadError e (ListT m)
instance (MonadIO m) => MonadIO (ListT m)
instance (Monad m) => List (ListT m)
instance MonadTrans ListT
instance (Monad m) => MonadPlus (ListT m)
instance (Monad m) => Applicative (ListT m)
instance (Monad m) => Monad (ListT m)
instance (Monad m) => Functor (ListT m)
instance (Monad m) => Monoid (ListT m a)