Game.Goatee.Common

Common utilities used throughout the project.

Documentation

listDeleteIndex :: 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.

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.

fromLeft :: Either a b -> a

Extracts a left value from an Either.

fromRight :: Either a b -> b

Extracts a right value from an Either.

onLeft :: (a -> c) -> Either a b -> Either c b

Transforms the left value of an Either, leaving a right value alone.

onRight :: (b -> c) -> Either a b -> Either a c

Transforms the right value of an Either, leaving a left value alone. This is just fmap, but looks nicer when used beside onLeft.

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.

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.

newtype Seq m

This sequences ()-valued monadic actions as a monoid. If m is some monad, then Seq m is a monoid where mempty does nothing and mappend sequences actions via >>.

Constructors

Seq (m ())

Instances

Monad m => Monoid (Seq m)