Modulemonadlist-0.0.2Haskell98

Control.Monad.ListM

Synopsis

value mapMP
value filterMP
value intersperseM
value intercalateM
value foldM1
value joinMap
value joinMapM
value anyM
value allM
value scanM
value mapAccumM
value iterateM
value takeM
value dropM
value splitAtM
value takeWhileM
value dropWhileM
value spanM
value breakM
value elemM
value notElemM
value lookupM
value findM
value partitionM
value elemIndexM
value elemIndicesM
value findIndexM
value findIndicesM
value zipWithM3
value zipWithM4
value zipWithM5
value zipWithM6
value nubM
value nubByM
value deleteM
value deleteByM
value deleteFirstsM
value deleteFirstsByM
value unionM
value unionByM
value intersectM
value intersectByM
value groupM
value groupByM
value sortM
value sortByM
value insertM
value insertByM
value maximumM
value maximumByM
value minimumM
value minimumByM

Packagemonadlist-0.0.2
Exports52
LanguageHaskell98
LicenceBSD-3-Clause

valuemapMP :: (Monad m, MonadPlus p) => (a -> m b) -> [a] -> m (p b)

valuefilterMP :: (Monad m, MonadPlus p) => (a -> m Bool) -> [a] -> m (p a)

valueintersperseM :: (Monad m, MonadPlus p) => m a -> [a] -> m (p a)

valueintercalateM :: (Monad m, MonadPlus p) => m (p a) -> [p a] -> m (p a)

valuefoldM1 :: Monad m => (a -> a -> m a) -> [a] -> m a

valuejoinMap :: Monad m => (a -> m b) -> m a -> m b

valuejoinMapM :: (Monad m, MonadPlus p) => (a -> m (p b)) -> [a] -> m (p b)

valueanyM :: (Monad m, Traversable t) => (a -> m Bool) -> t a -> m Bool

valueallM :: (Monad m, Traversable t) => (a -> m Bool) -> t a -> m Bool

valuescanM :: (Monad m, MonadPlus p) => (a -> b -> m a) -> a -> [b] -> m (p a)

valuemapAccumM

:: (Monad m, MonadPlus p)
=> acc -> x -> m (acc, y)
-> acc
-> [x]
-> m (acc, p y)

valueiterateM :: (Monad m, MonadPlus p) => (a -> m a) -> a -> m (p a)

valuetakeM :: (Integral i, Monad m, MonadPlus p) => i -> [m a] -> m (p a)

valuedropM :: (Integral i, Monad m) => i -> [m a] -> m [a]

valuesplitAtM :: (Integral i, Monad m, MonadPlus p) => i -> [m a] -> m (p a, [a])

valuetakeWhileM :: (Monad m, MonadPlus p) => (a -> m Bool) -> [a] -> m (p a)

valuedropWhileM :: Monad m => (a -> m Bool) -> [a] -> m [a]

valuespanM :: (Monad m, MonadPlus p) => (a -> m Bool) -> [a] -> m (p a, [a])

valuebreakM :: (Monad m, MonadPlus p) => (a -> m Bool) -> [a] -> m (p a, [a])

valueelemM :: (Eq a, Monad m) => a -> [a] -> m Bool

valuenotElemM :: (Eq a, Monad m) => a -> [a] -> m Bool

valuelookupM :: (Eq a, Monad m, MonadPlus p) => a -> [m (a, b)] -> m (p b)

valuefindM :: (Monad m, MonadPlus p) => (a -> m Bool) -> [a] -> m (p a)

valuepartitionM :: (Monad m, MonadPlus p) => (a -> m Bool) -> [a] -> m (p a, [a])

valueelemIndexM

:: (Eq a, Integral i, Monad m, MonadPlus p)
=> a
-> [a]
-> m (p i)

valueelemIndicesM

:: (Eq a, Integral i, Monad m, MonadPlus p)
=> a
-> [a]
-> m (p i)

valuefindIndexM

:: (Integral i, Monad m, MonadPlus p)
=> a -> m Bool
-> [a]
-> m (p i)

valuefindIndicesM

:: (Integral i, Monad m, MonadPlus p)
=> a -> m Bool
-> [a]
-> m (p i)

valuezipWithM3

:: (Monad m, MonadPlus p)
=> a -> b -> c -> m d
-> [a]
-> [b]
-> [c]
-> m (p d)

valuezipWithM4

:: (Monad m, MonadPlus p)
=> a -> b -> c -> d -> m e
-> [a]
-> [b]
-> [c]
-> [d]
-> m (p e)

valuezipWithM5

:: (Monad m, MonadPlus p)
=> a -> b -> c -> d -> e -> m f
-> [a]
-> [b]
-> [c]
-> [d]
-> [e]
-> m (p f)

valuezipWithM6

:: (Monad m, MonadPlus p)
=> a -> b -> c -> d -> e -> f -> m g
-> [a]
-> [b]
-> [c]
-> [d]
-> [e]
-> [f]
-> m (p g)

valuenubM :: (Eq a, Monad m, MonadPlus p) => [a] -> m (p a)

valuenubByM :: (Monad m, MonadPlus p) => (a -> a -> m Bool) -> [a] -> m (p a)

valuedeleteM :: (Eq a, Monad m) => a -> [a] -> m [a]

valuedeleteByM :: Monad m => (a -> a -> m Bool) -> a -> [a] -> m [a]

valuedeleteFirstsM :: (Eq a, Monad m) => [a] -> [a] -> m [a]

valuedeleteFirstsByM :: Monad m => (a -> a -> m Bool) -> [a] -> [a] -> m [a]

valueunionM :: (Eq a, Monad m) => [a] -> [a] -> m [a]

valueunionByM :: Monad m => (a -> a -> m Bool) -> [a] -> [a] -> m [a]

valueintersectM :: (Eq a, Monad m, MonadPlus p) => [a] -> [a] -> m (p a)

valueintersectByM

:: (Monad m, MonadPlus p)
=> a -> a -> m Bool
-> [a]
-> [a]
-> m (p a)

valuegroupM :: (Eq a, Monad m, MonadPlus p, MonadPlus q) => [a] -> m (p (q a))

valuegroupByM

:: (Monad m, MonadPlus p, MonadPlus q)
=> a -> a -> m Bool
-> [a]
-> m (p (q a))

valuesortM :: (Ord a, Monad m) => [a] -> m [a]

valuesortByM :: Monad m => (a -> a -> m Ordering) -> [a] -> m [a]

valueinsertM :: (Ord a, Monad m) => a -> [a] -> m [a]

valueinsertByM :: Monad m => (a -> a -> m Ordering) -> a -> [a] -> m [a]

valuemaximumM :: (Ord a, Monad m) => [a] -> m a

valuemaximumByM :: Monad m => (a -> a -> m Ordering) -> [a] -> m a

valueminimumM :: (Ord a, Monad m) => [a] -> m a

valueminimumByM :: Monad m => (a -> a -> m Ordering) -> [a] -> m a