Language.Haskell.Liquid.Misc

Documentation

type Nat = Int

(.&&.) :: (a -> Bool) -> (a -> Bool) -> a -> Bool

(.||.) :: (a -> Bool) -> (a -> Bool) -> a -> Bool

up :: (b -> c -> d) -> (a -> b) -> (a -> c) -> a -> d

timedAction :: Show msg => Maybe msg -> IO a -> IO a

(!?) :: [a] -> Int -> Maybe a

safeFromJust :: String -> Maybe t -> t

safeFromLeft :: String -> Either a b -> a

takeLast :: Int -> [a] -> [a]

getNth :: Int -> [a] -> Maybe a

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

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

thd4 :: (t1, t2, t3, t4) -> t3

thrd3 :: (t1, t2, t3) -> t3

mapFifth5 :: (t -> t4) -> (t0, t1, t2, t3, t) -> (t0, t1, t2, t3, t4)

mapFourth4 :: (t -> t4) -> (t1, t2, t3, t) -> (t1, t2, t3, t4)

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

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

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

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

replaceN :: (Enum a, Eq a, Num a) => a -> t -> [t] -> [t]

thd5 :: (t0, t1, t2, t3, t4) -> t2

snd5 :: (t0, t1, t2, t3, t4) -> t1

fst5 :: (t0, t1, t2, t3, t4) -> t0

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

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

mapSndM :: Applicative m => (b -> m c) -> (a, b) -> m (a, c)

firstM :: Functor f => (t -> f a) -> (t, t1) -> f (a, t1)

secondM :: Functor f => (t -> f a) -> (t1, t) -> f (t1, a)

first3M :: Functor f => (t -> f a) -> (t, t1, t2) -> f (a, t1, t2)

second3M :: Functor f => (t -> f a) -> (t1, t, t2) -> f (t1, a, t2)

third3M :: Functor f => (t -> f a) -> (t1, t2, t) -> f (t1, t2, a)

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

zip4 :: [t] -> [t1] -> [t2] -> [t3] -> [(t, t1, t2, t3)]

zip5 :: [t] -> [t1] -> [t2] -> [t3] -> [t4] -> [(t, t1, t2, t3, t4)]

unzip4 :: [(t, t1, t2, t3)] -> ([t], [t1], [t2], [t3])

getCssPath :: IO FilePath

getCoreToLogicPath :: IO FilePath

zipMaybe :: [a] -> [b] -> Maybe [(a, b)]

safeZipWithError :: String -> [t] -> [t1] -> [(t, t1)]

safeZip3WithError :: String -> [t] -> [t1] -> [t2] -> [(t, t1, t2)]

safeZip4WithError :: String -> [t1] -> [t2] -> [t3] -> [t4] -> [(t1, t2, t3, t4)]

mapNs :: (Eq a, Num a, Foldable t) => t a -> (a1 -> a1) -> [a1] -> [a1]

mapN :: (Eq a, Num a) => a -> (a1 -> a1) -> [a1] -> [a1]

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

zipWithDef :: (a -> a -> a) -> [a] -> [a] -> [a]

single :: t -> [t]

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)

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

hashMapMapKeys :: (Eq k2, Hashable k2) => (k1 -> k2) -> HashMap k1 v -> HashMap k2 v

concatMapM :: (Monad m, Traversable t) => (a -> m [b]) -> t a -> m [b]

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

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

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 -> [String]

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

(<->) :: Doc -> Doc -> Doc

angleBrackets :: Doc -> Doc

mkGraph :: (Eq a, Eq b, Hashable a, Hashable b) => [(a, b)] -> HashMap a (HashSet b)

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

condNull :: Monoid m => Bool -> m -> m

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

intToString :: Int -> String

mapAccumM :: (Monad m, Traversable t) => (a -> b -> m (a, c)) -> a -> t b -> m (a, t c)

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

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

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

nubHashLastM :: (Eq k, Hashable k, Monad m) => (a -> m k) -> [a] -> m [a]

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

uniqueByKey' :: (Eq k, Hashable k) => ((k, [v]) -> Either e v) -> [(k, v)] -> Either e [v]

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

fstByRank :: (Ord r, Hashable k, Eq k) => [(r, k, v)] -> [(r, k, v)]

sortOn :: Ord b => (a -> b) -> [a] -> [a]

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

mapErr :: (a -> Either e b) -> [a] -> Either [e] [b]

catEithers :: [Either a b] -> Either [a] [b]

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

concatUnzip :: [([a], [b])] -> ([a], [b])

sayReadFile :: FilePath -> IO String

lastModified :: FilePath -> IO (Maybe UTCTime)

data Validate e a

Constructors

Err e

Val a

Instances

Monoid e => Applicative (Validate e)

Defined in Language.Haskell.Liquid.Misc

Methods

pure :: a -> Validate e a

(<*>) :: Validate e (a -> b) -> Validate e a -> Validate e b

liftA2 :: (a -> b -> c) -> Validate e a -> Validate e b -> Validate e c

(*>) :: Validate e a -> Validate e b -> Validate e b

(<*) :: Validate e a -> Validate e b -> Validate e a

Functor (Validate e)

Defined in Language.Haskell.Liquid.Misc

Methods

fmap :: (a -> b) -> Validate e a -> Validate e b

(<$) :: a -> Validate e b -> Validate e a