liquid-fixpoint-0.5.0.1: Predicate Abstraction-based Horn-Clause/Implication Constraint Solver

Safe HaskellNone
LanguageHaskell98

Language.Fixpoint.Misc

Synopsis

Documentation

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

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

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

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

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

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

data Moods Source

Constructors

Ok 
Loud 
Sad 
Happy 
Angry 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

groupBase :: (Eq k, Foldable t, Hashable k) => HashMap k [a] -> t (k, a) -> HashMap k [a] Source

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

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

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

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

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

type ListNE a = [a] Source

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

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

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

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

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

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

tshow :: Show a => a -> Doc Source

writeLoud :: String -> IO () Source

if loud, write a string to stdout

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