Manatee.Toolkit.General.List

Documentation

(?!) :: [a] -> Int -> Maybe a

Return element of list with given index.

intersectEnd :: Ord a => [a] -> [a] -> [a]

Intersect element with list from end, don't including front or middle element. Return null if haven't intersection element.

intersectFront :: Ord a => [a] -> [a] -> [a]

Intersect element with list from front, don't including end or middle element. Return null if haven't intersection element.

delay :: Int -> [a] -> [Int]

Delay list with given start index.

listIndex :: [a] -> [Int]

Index of list

pairPred :: [a] -> [(a, Int)]

Pair with list index.

different :: Ord a => [a] -> [a] -> [a]

Different two list, and two lists must have same length. otherwise throw a error.

unlessNull :: [a] -> IO () -> IO ()

Do action when list not empty.

has :: [a] -> Bool

not . null

headM :: Monad m => m [a] -> m a

Head monad list.

lastM :: Monad m => m [a] -> m a

Last monad list.

concatM :: Monad m => m [a] -> m [a] -> m [a]

ConcatM.

replaceAt :: Int -> [a] -> a -> [a]

Replace n'th element (count from 0) in xs to x

splitWith :: (a -> Bool) -> [a] -> [[a]]

Split list with given condition.

concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b]

concatMapM.

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

Like find, but works with monadic computation instead of pure function. In expression `find FUNCTION list`, if FUNCTION is IO Bool, you can use `findM FUNCTION list` to instead.

apply2M :: Monad m => [a] -> (a -> m b) -> (a -> m c) -> m [(b, c)]

Apply two monad function with list. And return new monad tuples list.

apply2 :: [a] -> (a -> b) -> (a -> c) -> [(b, c)]

Apply two function with list. And return new tuples list.

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

Partition list.

findNext :: (a -> Bool) -> [a] -> Maybe a

Like init, but accept empty list.

Like foldl1, but accept empty list.

Find next element.

findNextCycle :: (a -> Bool) -> [a] -> Maybe a

Find next cycle.

findPrevCycle :: (a -> Bool) -> [a] -> Maybe a

Find previous cycle.

deleteAt :: Int -> [a] -> [a]

Delete at.

getLast :: [a] -> Maybe a

Get last one.

getFirst :: [a] -> Maybe a

Get first one.

zipWithIndex :: [a] -> (a -> Int -> c) -> [c]

Zip with list index.

zipWithIndexM :: Monad m => [a] -> (a -> Int -> m c) -> m [c]

Zip with list index.

zipWithIndexM_ :: Monad m => [a] -> (a -> Int -> m c) -> m ()

Zip with list index.

addMap :: ([a] -> [a]) -> [[a]] -> [a]

Like concatMap, but don't concat last one.

insertUnique :: Ord a => a -> [a] -> [a]

Like insert but just insert unique element.