Data.List.Class

The List class and actions for lists

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

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

Transform an action returning a list to the returned list

 > joinL $ Identity "hello"
 "hello"

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

foldr for Lists. the result and 'right side' values are monadic actions.

toListT :: l a -> ListT (ItemM l) a

Convert to a ListT.

Can be done with a foldrL but included in type-class for efficiency.

fromListT :: ListT (ItemM l) a -> l a

Convert from a ListT.

Can be done with a foldrL but included in type-class for efficiency.

Instances

List []

Monad m => List (ListT m)

Monad m => List (DListT m)

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

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

An action to do foldl for Lists

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

An action to transform a List to a list

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

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]

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'

Convert between List types

convList :: (ItemM l ~ ItemM k, List l, List k) => l a -> k a

Convert between lists with the same underlying monad

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"

liftListMonad :: (MonadTrans t, Monad (t (ItemM l)), List l) => l a -> ListT (t (ItemM l)) a

Lift the underlying monad of a list and transform it to a ListT.

Doing plain 'transformListMonad lift' instead doesn't give the compiler the same knowledge about the types.