List class and actions for lists
- class (MonadPlus l, Monad (ItemM l)) => List l where
- data ListItem l a
- cons :: MonadPlus m => a -> m a -> m a
- fromList :: MonadPlus m => [a] -> m a
- 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
- foldrL :: List l => (a -> ItemM l b -> ItemM l b) -> ItemM l b -> l a -> ItemM l b
- foldlL :: List l => (a -> b -> a) -> a -> l b -> ItemM l a
- foldl1L :: List l => (a -> a -> a) -> l a -> ItemM l a
- toList :: List l => l a -> ItemM l [a]
- lengthL :: (Integral i, List l) => l a -> ItemM l i
- lastL :: List l => l a -> ItemM l a
- merge2On :: (Ord b, List l) => (a -> b) -> l a -> l a -> l a
- mergeOn :: (Ord b, List l) => (a -> b) -> l (l a) -> l a
- execute :: List l => l a -> ItemM l ()
- joinM :: List l => l (ItemM l a) -> l a
- iterateM :: List l => (a -> ItemM l a) -> ItemM l a -> l a
- takeWhileM :: List l => (a -> ItemM l Bool) -> l a -> l a
- sortOn :: Ord b => (a -> b) -> [a] -> [a]
- transformListMonad :: (List l, List k) => (forall x. ItemM l x -> ItemM k x) -> l a -> k a
- listStateJoin :: (List l, List k, ItemM l ~ StateT s (ItemM k)) => l a -> ItemM l (k a)
The List typeclass
A class for list types. Every list has an underlying monad.
Transform an action returning a list to the returned list
> joinL $ Identity "hello" "hello"
List operations for MonadPlus
Convert a list to a
> fromList  :: Maybe Int Nothing > fromList  :: Maybe Int Just 5
filter for any MonadPlus
> filter (> 5) (Just 3) Nothing
Standard list operations
Non standard List operations
the result and 'right side' values are monadic actions.
An action to transform a
List to a list
> runIdentity $ toList "hello!" "hello!"
Consume a list (execute its actions) and return its length
> runIdentity $ lengthL [1,2,3] 3
Consume all items and return the last one
> runIdentity $ lastL "hello" 'o'
Merge two lists sorted by a criteria given the criteria
> merge2On id "01568" "239" "01235689"
Merge many lists sorted by a criteria given the criteria
> mergeOn length [["hi", "hey", "hello"], ["cat", "falcon"], ["banana", "cucumber"]] ["hi","cat","hey","hello","banana","falcon","cucumber"]
Operations useful for monadic lists
Transform a list of actions to a list of their results
> joinM [Identity 4, Identity 7] [4,7]
Monadic version of iterate. Can be used to produce trees given a children of node function.
import Data.List.Tree (bfsLayers) take 3 $ bfsLayers (iterateM (\i -> [i*2, i*2+1])  :: ListT  Int) [,[2,3],[4,5,6,7]]
Operations for non-monadic lists
Convert between List types
Transform the underlying monad of a list given a way to transform the monad
> import Data.List.Tree (bfs) > bfs (transformListMonad (\(Identity x) -> [x, x]) "hey" :: ListT  Char) "hheeeeyyyyyyyy"
listStateJoin can transform a
ListT (StateT s m) a to a
StateT s m (ListT m a).
When iterating a list, a state is already maintained and passed along
in the form of the location along the list.
This joins the inner
StateT s into the list.
The list will fork the state given to it and won't share its changes.