Game.Goatee.Common

Common utilities used throughout the project.

Documentation

listDeleteAt :: Int -> [a] -> [a]

Drops the element at an index from a list. If the index is out of bounds then the list is returned unmodified.

listInsertAt :: Int -> a -> [a] -> [a]

Inserts the element into the list before the given position. If the position is less than 0 or greater than the length of the list, then the index is clamped to this range.

listReplace :: Eq a => a -> a -> [a] -> [a]

listReplace old new list replaces all occurrences of old with new in list.

listUpdate :: Show a => (a -> a) -> Int -> [a] -> [a]

Modifies the element at a specific index in a list.

andEithers :: [Either a b] -> Either [a] [b]

If any item is a Left, then the list of Lefts is returned, otherwise the list of Rights is returned.

for :: [a] -> (a -> b) -> [b]

for is flip map.

mapTuple :: (a -> b) -> (a, a) -> (b, b)

Transforms both values in a homogeneous tuple.

mapInvert :: Ord v => Map k v -> Map v [k]

Inverts a map, collecting all of the keys that map to a single value in one list in the result map. No guarantees are made on the order of the keys in each value's list. If you want the results in ascending order, apply map sort to the result.

whenMaybe :: Monad m => Maybe a -> (a -> m ()) -> m ()

Executes the monadic function if a Maybe contains a value.

cond :: a -> [(Bool, a)] -> a

Finds the first tuple whose first element is true, and returns its second element. If all of the first values are false, then the first argument to cond is returned instead.

if' :: a -> a -> Bool -> a

A function form of if that takes its test last.

andM :: Monad m => [m Bool] -> m Bool

and in a monad. Executes the actions in the list in order. If any action returns false then the remaining actions are skipped and the result is false. Otherwise all actions returned true, and the result is true. An empty list returns true.

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

forM_ that also passes in the index of each element.

whileM :: Monad m => m Bool -> m () -> m ()

whileM test body repeatedly evaluates test until it returns false. Every time test returns true, body is executed once.

whileM' :: Monad m => m (Maybe a) -> (a -> m ()) -> m ()

whileM' test body repeatedly evaluates test until it returns Nothing. Every time it returns a Just, that value is passed to body and the result is executed.

doWhileM :: Monad m => a -> (a -> m (Either b a)) -> m b

doWhileM init body repeatedly calls body with init. As long as body returns a Right value, it is re-executed with the returned value. When it returns a Left value, the loop stops and the value is returned.