Safe Haskell | Safe-Inferred |
---|

The `List`

class and actions for lists

- class (MonadPlus l, Monad (ItemM l)) => List l where
- data ListItem l a
- fromList :: List l => [a] -> l a
- filter :: MonadPlus m => (a -> Bool) -> m a -> m a
- repeat :: List l => a -> l a
- take :: List l => Int -> l a -> l 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
- scanl1 :: List l => (a -> a -> a) -> l a -> 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
- concat :: List l => l [a] -> l a
- concatMap :: List l => (a -> [b]) -> l a -> l b
- tail :: List l => l a -> l a
- enumFrom :: (List l, Enum a) => a -> l a
- enumFromTo :: (List l, Enum a) => a -> a -> l a
- catMaybes :: List l => l (Maybe a) -> l a
- mapMaybe :: List l => (a -> Maybe b) -> l a -> l b
- 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
- mapL :: List l => (a -> ItemM l b) -> l a -> l b
- filterL :: List l => (a -> ItemM l Bool) -> 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
- repeatM :: List l => ItemM l a -> l a
- splitAtM :: List l => Int -> l a -> ItemM l ([a], l a)
- splitWhenM :: List l => (a -> ItemM l Bool) -> l a -> ItemM l ([a], l a)
- sortOn :: Ord b => (a -> b) -> [a] -> [a]
- transformListMonad :: (List l, List k) => (ItemM l (k a) -> ItemM k (k a)) -> l a -> k a
- listStateJoin :: (List l, List k, ItemM l ~ StateT s (ItemM k)) => l a -> ItemM l (k a)

# Documentation

The List typeclass

class (MonadPlus l, Monad (ItemM l)) => List l whereSource

A class for list types. Every list has an underlying monad.

fromList :: List l => [a] -> l aSource

Convert a list to a `MonadPlus`

> fromList [] :: Maybe Int Nothing > fromList [5] :: Maybe Int Just 5

List operations for MonadPlus

filter :: MonadPlus m => (a -> Bool) -> m a -> m aSource

filter for any MonadPlus

> filter (> 5) (Just 3) Nothing

Standard list operations

genericTake :: (Integral i, List l) => i -> l a -> l aSource

enumFromTo :: (List l, Enum a) => a -> a -> l aSource

Non standard List operations

foldrL :: List l => (a -> ItemM l b -> ItemM l b) -> ItemM l b -> l a -> ItemM l bSource

foldr for `List`

s.
the result and 'right side' values are monadic actions.

toList :: List l => l a -> ItemM l [a]Source

An action to transform a `List`

to a list

> runIdentity $ toList "hello!" "hello!"

lengthL :: (Integral i, List l) => l a -> ItemM l iSource

Consume a list (execute its actions) and return its length

> runIdentity $ lengthL [1,2,3] 3

lastL :: List l => l a -> ItemM l aSource

Consume all items and return the last one

> runIdentity $ lastL "hello" 'o'

merge2On :: (Ord b, List l) => (a -> b) -> l a -> l a -> l aSource

Merge two lists sorted by a criteria given the criteria

> merge2On id "01568" "239" "01235689"

mergeOn :: (Ord b, List l) => (a -> b) -> l (l a) -> l aSource

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

joinM :: List l => l (ItemM l a) -> l aSource

Transform a list of actions to a list of their results

> joinM [Identity 4, Identity 7] [4,7]

iterateM :: List l => (a -> ItemM l a) -> ItemM l a -> l aSource

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]) [1] :: ListT [] Int) [[1],[2,3],[4,5,6,7]]

takeWhileM :: List l => (a -> ItemM l Bool) -> l a -> l aSource

splitAtM :: List l => Int -> l a -> ItemM l ([a], l a)Source

Monadic variant of splitAt. Consumes x items from the list and return them with the remaining monadic list.

splitWhenM :: List l => (a -> ItemM l Bool) -> l a -> ItemM l ([a], l a)Source

Monadic variant of break. Consumes items from the list until a condition holds.

Operations for non-monadic lists

Convert between List types

transformListMonad :: (List l, List k) => (ItemM l (k a) -> ItemM k (k a)) -> l a -> k aSource

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 :: (List l, List k, ItemM l ~ StateT s (ItemM k)) => l a -> ItemM l (k a)Source

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.