Documentation

data Moods Source

moodColor :: Moods -> ColorSource

wrapStars :: [Char] -> [Char]Source

withColor :: Color -> IO a -> IO ()Source

colorStrLn :: Moods -> String -> IO ()Source

colorPhaseLn :: Moods -> [Char] -> [Char] -> IO ()Source

startPhase :: Moods -> [Char] -> IO ()Source

doneLine :: Moods -> [Char] -> IO ()Source

donePhase :: Moods -> String -> IO ()Source

data Empty Source

unIntersperse :: Eq a => a -> [a] -> [[a]]Source

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

wrap :: [a] -> [a] -> [a] -> [a]Source

repeats :: Int -> [a] -> [a]Source

errorstar :: [Char] -> cSource

errortext :: Doc -> cSource

putDocLn :: Doc -> IO ()Source

assertstar :: [Char] -> Bool -> c -> cSource

findWithDefaultL :: (a -> Bool) -> [a] -> a -> aSource

fst3 :: (a, b, c) -> aSource

snd3 :: (a, b, c) -> bSource

thd3 :: (a, b, c) -> cSource

single :: a -> [a]Source

mapFst :: (t -> t1) -> (t, t2) -> (t1, t2)Source

mapSnd :: (t -> t2) -> (t1, t) -> (t1, t2)Source

mapFst3 :: (t -> t1) -> (t, t2, t3) -> (t1, t2, t3)Source

mapSnd3 :: (t -> t2) -> (t1, t, t3) -> (t1, t2, t3)Source

mapThd3 :: (t -> t3) -> (t1, t2, t) -> (t1, t2, t3)Source

expandSnd :: [([a], t)] -> [(a, t)]Source

mapPair :: (a -> b) -> (a, a) -> (b, b)Source

mlookup :: (Eq a, Show a, Hashable a) => HashMap a v -> a -> vSource

mfromJust :: String -> Maybe a -> aSource

boxStrCat :: String -> [String] -> StringSource

tryIgnore :: String -> IO () -> IO ()Source

traceShow :: Show a => String -> a -> aSource

warnShow :: Show a => String -> a -> aSource

inserts :: (Eq k, Hashable k) => k -> a -> HashMap k [a] -> HashMap k [a]Source

group :: (Eq k, Hashable k) => [(k, a)] -> HashMap k [a]Source

groupList :: (Eq k, Hashable k) => [(k, a)] -> [(k, [a])]Source

groupMap :: (Eq k, Hashable k) => (a -> k) -> [a] -> HashMap k [a]Source

sortNub :: Ord a => [a] -> [a]Source

sortDiff :: Ord a => [a] -> [a] -> [a]Source

distinct :: Ord a => [a] -> BoolSource

tr_reverse :: [a] -> [a]Source

tr_foldr' :: (a -> b -> b) -> b -> [a] -> bSource

safeZip :: [Char] -> [a] -> [b] -> [(a, b)]Source

safeZipWith :: [Char] -> (a -> b -> c) -> [a] -> [b] -> [c]Source

safeFromList :: (Eq k, Show k, Show v, Hashable k) => [Char] -> [(k, v)] -> HashMap k vSource

safeUnion :: (Eq k, Show k, Hashable k) => [Char] -> HashMap k v -> HashMap k v -> HashMap k vSource

safeHead :: [Char] -> [t] -> tSource

safeLast :: [Char] -> [a] -> aSource

safeInit :: [Char] -> [a] -> [a]Source

memoIndex :: (Eq k, Hashable k) => (x -> Maybe k) -> [x] -> [Maybe Int]Source

checkFail :: [Char] -> (a -> Bool) -> a -> aSource

chopAfter :: (a -> Bool) -> [a] -> [a]Source

chopPrefix :: Eq a => [a] -> [a] -> Maybe [a]Source

firstElem :: Eq a => [(a, t)] -> [a] -> Maybe IntSource

chopAlt :: Eq a => [(a, a)] -> [a] -> [[a]]Source

firstElems :: [(ByteString, ByteString)] -> ByteString -> Maybe (Int, ByteString, (ByteString, ByteString))Source

splitters :: [(ByteString, t)] -> ByteString -> [(Int, t, (ByteString, ByteString))]Source

bchopAlts :: [(ByteString, ByteString)] -> ByteString -> [ByteString]Source

chopAlts :: [(String, String)] -> String -> [[Char]]Source

findFirst :: Monad m => (t -> m [a]) -> [t] -> m (Maybe a)Source

testM :: Monad m => (t -> m Bool) -> t -> m [t]Source

stripParens :: [Char] -> [Char]Source

stripParens' :: [Char] -> [Char]Source

ifM :: Monad m => m Bool -> m a -> m a -> m aSource

executeShellCommand :: [Char] -> [Char] -> IO ExitCodeSource

checkExitCode :: Monad m => [Char] -> ExitCode -> m ()Source

hashMapToAscList :: Ord a => HashMap a b -> [(a, b)]Source

hashMapMapWithKey :: (k -> v1 -> v2) -> HashMap k v1 -> HashMap k v2Source

hashMapMapKeys :: (Eq k, Hashable k) => (t -> k) -> HashMap t v -> HashMap k vSource

applyNonNull :: t -> ([t1] -> t) -> [t1] -> tSource

concatMapM :: (Monad f, Functor f) => (a1 -> f [a]) -> [a1] -> f [a]Source

angleBrackets :: Doc -> DocSource

dot :: DocSource

arrow :: DocSource

dcolon :: DocSource

intersperse :: Doc -> [Doc] -> DocSource

tshow :: Show a => a -> DocSource

foldlMap :: (a -> b -> (c, a)) -> a -> [b] -> ([c], a)Source