Language.Fixpoint.Misc

Documentation

data Moods

Constructors

Ok

Loud

Sad

Happy

Angry

moodColor :: Moods -> Color

wrapStars :: [Char] -> [Char]

wrapStarsWithOptStars :: Bool -> [Char] -> [Char]

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

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

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

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

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

colorPhaseLnWithOptStars :: Bool -> Moods -> [Char] -> [Char] -> IO ()

startPhaseWithOptStars :: Bool -> Moods -> [Char] -> IO ()

doneLineWithOptStars :: Bool -> Moods -> [Char] -> IO ()

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

donePhaseWithOptStars :: Bool -> Moods -> String -> IO ()

data Empty

Constructors

Emp

Instances

Eq Empty

Data Empty

Show Empty

Typeable * Empty

unIntersperse :: Eq t => t -> [t] -> [[t]]

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

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

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

errorstar :: [Char] -> c

errortext :: Doc -> c

putDocLn :: Doc -> IO ()

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

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

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

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

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

single :: a -> [a]

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

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

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

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

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

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

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

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

mfromJust :: String -> Maybe a -> a

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

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

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

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

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

concatMaps :: (Hashable k, Ord a, Eq k) => [HashMap k [a]] -> HashMap k [a]

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

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

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

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

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

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

tr_reverse :: [a] -> [a]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

stripParens :: Text -> Text

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

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

executeShellCommandWithOptStars :: Bool -> [Char] -> [Char] -> IO ExitCode

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

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

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

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

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

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

angleBrackets :: Doc -> Doc

dot :: Doc

arrow :: Doc

dcolon :: Doc

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

tshow :: Show a => a -> Doc

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

mapEither :: (a -> Either b c) -> [a] -> ([b], [c])

(<$$>) :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)