# Documentation

type Nat = Int Source #

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

single :: t -> [t] 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 #

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

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

concatMapM :: (Monad f, Traversable t) => (a1 -> f [a]) -> t a1 -> f [a] Source #

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

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

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

condNull :: Bool -> [a] -> [a] Source #

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

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

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

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

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

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

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

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

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