Language.Fixpoint.Misc

Documentation

type (|->) a b = HashMap a b

firstMaybe :: (a -> Maybe b) -> [a] -> Maybe b

asyncMapM :: (a -> IO b) -> [a] -> IO [b]

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

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

findNearest :: (Ord i, Num i) => i -> [(i, a)] -> Maybe a

argMin :: Ord k => [(k, v)] -> Maybe v

headMb :: [a] -> Maybe a

getUniqueInt :: IO Int

Unique Int -----------------------------------------------

editDistance :: Eq a => [a] -> [a] -> Int

Edit Distance --------------------------------------------

data Moods

Constructors

Ok

Loud

Sad

Happy

Angry

Wary

moodColor :: Moods -> Color

wrapStars :: String -> String

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

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

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

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

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

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

putBlankLn :: IO ()

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

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

errorP :: String -> String -> a

errorstar :: (?callStack :: CallStack) => String -> a

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

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

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

secondM :: Functor f => (b -> f c) -> (a, b) -> f (a, c)

mlookup :: (?callStack :: CallStack, Eq k, Show k, Hashable k) => HashMap k v -> k -> v

safeLookup :: (?callStack :: CallStack, Eq k, Hashable k) => String -> k -> HashMap k v -> v

mfromJust :: (?callStack :: CallStack) => String -> Maybe a -> a

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

removes :: (Eq k, Hashable k, Eq v) => k -> v -> HashMap k [v] -> HashMap k [v]

count :: (Eq k, Hashable k) => [k] -> [(k, Int)]

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

groupBase :: (Eq k, Hashable k) => HashMap k [v] -> [(k, v)] -> HashMap k [v]

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

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

allMap :: (Eq k, Hashable k) => (v -> Bool) -> HashMap k v -> Bool

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

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

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

hashNubWith :: (Eq b, Hashable b) => (a -> b) -> [a] -> [a]

mFromList :: (Eq k, Hashable k) => [(k, v)] -> HashMap k v

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

safeZip :: (?callStack :: CallStack) => String -> [a] -> [b] -> [(a, b)]

safeZipWith :: (?callStack :: CallStack) => String -> (a -> b -> c) -> [a] -> [b] -> [c]

type ListNE a = [a]

safeHead :: (?callStack :: CallStack) => String -> ListNE a -> a

safeLast :: (?callStack :: CallStack) => String -> ListNE a -> a

safeInit :: (?callStack :: CallStack) => String -> ListNE a -> [a]

safeUncons :: (?callStack :: CallStack) => String -> ListNE a -> (a, [a])

safeUnsnoc :: (?callStack :: CallStack) => String -> ListNE a -> ([a], a)

safeFromList :: (?callStack :: CallStack, Eq k, Hashable k, Show k) => String -> [(k, v)] -> HashMap k v

executeShellCommand :: String -> String -> IO ExitCode

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

arrow :: Doc

dcolon :: Doc

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

tshow :: Show a => a -> Doc

writeLoud :: String -> IO ()

If loud, write a string to stdout

ensurePath :: FilePath -> IO ()

singleton :: a -> [a]

pair :: a -> a -> [a]

triple :: a -> a -> a -> [a]

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

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

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

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

isRight :: Either a b -> Bool

componentsWith :: Ord c => (a -> [(b, c, [c])]) -> a -> [[b]]

topoSortWith :: Ord v => (a -> (v, [v])) -> [a] -> [a]

sccsWith :: Ord v => (a -> (v, [v])) -> [a] -> [[a]]

>>> let em = M.fromList [ (1, [2, 3]), (2, [1, 3]), (3, []   ) ]
>>> let ef = \v -> (v, M.lookupDefault [] v em)
>>> sccsWith ef [1,2,3]
[[3],[1,2]] 

exTopo :: [Int]

type EqHash a = (Eq a, Ord a, Hashable a)

coalesce :: EqHash v => [ListNE v] -> [ListNE v]

coalesceEdges :: EqHash v => [ListNE v] -> [(v, v, [v])]

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

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

allCombinations :: [[a]] -> [[a]]

powerset :: [a] -> [[a]]

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

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

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

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

nubDiff :: (Eq a, Hashable a) => [a] -> [a] -> HashSet a

fold1M :: Monad m => (a -> a -> m a) -> [a] -> m a