Data.List.Class

List-0.4.0: List monad transformer and class

Data.List.Class

Description

The `List` class and actions for lists

Synopsis

- class (MonadPlus l, Monad (ItemM l)) => List l where
  - type ItemM l :: * -> *
  - runList :: l a -> ItemM l (ListItem l a)
  - joinL :: ItemM l (l a) -> l a
- data ListItem l a
  - = Nil
  - | Cons {
    - headL :: a
    - tailL :: 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
- mapL :: List l => (a -> ItemM l b) -> l a -> l b
- 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)

# Documentation

The List typeclass

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

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

Associated Types

type ItemM l :: * -> *

Methods

runList :: l a -> ItemM l (ListItem l a)

joinL :: ItemM l (l a) -> l a

Transform an action returning a list to the returned list

     > joinL $ Identity "hello"
     "hello"

Instances

List [] |
Monad m => List (ListT m) |

data ListItem l a

Constructors

Nil |
Cons |
Fields headL :: a tailL :: l a

Instances

Functor m => Functor (ListItem m) |
(Eq a, Eq (l a)) => Eq (ListItem l a) |
(Ord a, Ord (l a)) => Ord (ListItem l a) |
(Read a, Read (l a)) => Read (ListItem l a) |
(Show a, Show (l a)) => Show (ListItem l a) |

List operations for MonadPlus

cons :: MonadPlus m => a -> m a -> m a

Prepend an item to a `MonadPlus`

fromList :: MonadPlus m => [a] -> m a

Convert a list to a `MonadPlus`

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

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

filter for any MonadPlus

     > filter (> 5) (Just 3)
     Nothing

repeat :: MonadPlus m => a -> m a

Standard list operations

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

Non standard List operations

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

foldr for `List`s. the result and 'right side' values are monadic actions.

foldlL :: List l => (a -> b -> a) -> a -> l b -> ItemM l a

An action to do foldl for `List`s

foldl1L :: List l => (a -> a -> a) -> l a -> ItemM l a

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

An action to transform a `List` to a list

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

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

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

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

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

Consume all items and return the last one

     > runIdentity $ lastL "hello"
     'o'

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

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 a

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

execute :: List l => l a -> ItemM l ()

Execute the monadic actions in a `List`

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

Transform a list of actions to a list of their results

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

mapL :: List l => (a -> ItemM l b) -> l a -> l b

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

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 a

Operations for non-monadic lists

sortOn :: Ord b => (a -> b) -> [a] -> [a]

Convert between List types

transformListMonad :: (List l, List k) => (forall x. ItemM l x -> ItemM k x) -> l a -> k a

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)

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.