Safe Haskell | None |
---|---|
Language | Haskell2010 |
Util
Contents
- Flags dependent on the compiler build
- General list processing
- Tuples
- List operations controlled by another list
- For loop
- Sorting
- Comparisons
- Edit distance
- Transitive closures
- Strictness
- Module names
- Argument processing
- Floating point
- read helpers
- IO-ish utilities
- Filenames and paths
- Utils for defining Data instances
- Utils for printing C code
- Hashing
Description
Highly random utility functions
- ghciSupported :: Bool
- debugIsOn :: Bool
- ncgDebugIsOn :: Bool
- ghciTablesNextToCode :: Bool
- isWindowsHost :: Bool
- isDarwinHost :: Bool
- zipEqual :: String -> [a] -> [b] -> [(a, b)]
- zipWithEqual :: String -> (a -> b -> c) -> [a] -> [b] -> [c]
- zipWith3Equal :: String -> (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
- zipWith4Equal :: String -> (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
- zipLazy :: [a] -> [b] -> [(a, b)]
- stretchZipWith :: (a -> Bool) -> b -> (a -> b -> c) -> [a] -> [b] -> [c]
- zipWithAndUnzip :: (a -> b -> (c, d)) -> [a] -> [b] -> ([c], [d])
- filterByList :: [Bool] -> [a] -> [a]
- unzipWith :: (a -> b -> c) -> [(a, b)] -> [c]
- mapFst :: (a -> c) -> [(a, b)] -> [(c, b)]
- mapSnd :: (b -> c) -> [(a, b)] -> [(a, c)]
- chkAppend :: [a] -> [a] -> [a]
- mapAndUnzip :: (a -> (b, c)) -> [a] -> ([b], [c])
- mapAndUnzip3 :: (a -> (b, c, d)) -> [a] -> ([b], [c], [d])
- mapAccumL2 :: (s1 -> s2 -> a -> (s1, s2, b)) -> s1 -> s2 -> [a] -> (s1, s2, [b])
- nOfThem :: Int -> a -> [a]
- filterOut :: (a -> Bool) -> [a] -> [a]
- partitionWith :: (a -> Either b c) -> [a] -> ([b], [c])
- splitEithers :: [Either a b] -> ([a], [b])
- dropWhileEndLE :: (a -> Bool) -> [a] -> [a]
- foldl1' :: (a -> a -> a) -> [a] -> a
- foldl2 :: (acc -> a -> b -> acc) -> acc -> [a] -> [b] -> acc
- count :: (a -> Bool) -> [a] -> Int
- all2 :: (a -> b -> Bool) -> [a] -> [b] -> Bool
- lengthExceeds :: [a] -> Int -> Bool
- lengthIs :: [a] -> Int -> Bool
- lengthAtLeast :: [a] -> Int -> Bool
- listLengthCmp :: [a] -> Int -> Ordering
- atLength :: ([a] -> b) -> (Int -> b) -> [a] -> Int -> b
- equalLength :: [a] -> [b] -> Bool
- compareLength :: [a] -> [b] -> Ordering
- leLength :: [a] -> [b] -> Bool
- isSingleton :: [a] -> Bool
- only :: [a] -> a
- singleton :: a -> [a]
- notNull :: [a] -> Bool
- snocView :: [a] -> Maybe ([a], a)
- isIn :: Eq a => String -> a -> [a] -> Bool
- isn'tIn :: Eq a => String -> a -> [a] -> Bool
- fstOf3 :: (a, b, c) -> a
- sndOf3 :: (a, b, c) -> b
- thirdOf3 :: (a, b, c) -> c
- firstM :: Monad m => (a -> m c) -> (a, b) -> m (c, b)
- first3M :: Monad m => (a -> m d) -> (a, b, c) -> m (d, b, c)
- third3 :: (c -> d) -> (a, b, c) -> (a, b, d)
- uncurry3 :: (a -> b -> c -> d) -> (a, b, c) -> d
- takeList :: [b] -> [a] -> [a]
- dropList :: [b] -> [a] -> [a]
- splitAtList :: [b] -> [a] -> ([a], [a])
- split :: Char -> String -> [String]
- dropTail :: Int -> [a] -> [a]
- nTimes :: Int -> (a -> a) -> a -> a
- sortWith :: Ord b => (a -> b) -> [a] -> [a]
- minWith :: Ord b => (a -> b) -> [a] -> a
- nubSort :: Ord a => [a] -> [a]
- isEqual :: Ordering -> Bool
- eqListBy :: (a -> a -> Bool) -> [a] -> [a] -> Bool
- eqMaybeBy :: (a -> a -> Bool) -> Maybe a -> Maybe a -> Bool
- thenCmp :: Ordering -> Ordering -> Ordering
- cmpList :: (a -> a -> Ordering) -> [a] -> [a] -> Ordering
- removeSpaces :: String -> String
- (<&&>) :: Applicative f => f Bool -> f Bool -> f Bool
- (<||>) :: Applicative f => f Bool -> f Bool -> f Bool
- fuzzyMatch :: String -> [String] -> [String]
- fuzzyLookup :: String -> [(String, a)] -> [a]
- transitiveClosure :: (a -> [a]) -> (a -> a -> Bool) -> [a] -> [a]
- seqList :: [a] -> b -> b
- looksLikeModuleName :: String -> Bool
- getCmd :: String -> Either String (String, String)
- toCmdArgs :: String -> Either String (String, [String])
- toArgs :: String -> Either String [String]
- readRational :: String -> Rational
- maybeRead :: Read a => String -> Maybe a
- maybeReadFuzzy :: Read a => String -> Maybe a
- doesDirNameExist :: FilePath -> IO Bool
- getModificationUTCTime :: FilePath -> IO UTCTime
- modificationTimeIfExists :: FilePath -> IO (Maybe UTCTime)
- global :: a -> IORef a
- consIORef :: IORef [a] -> a -> IO ()
- globalM :: IO a -> IORef a
- type Suffix = String
- splitLongestPrefix :: String -> (Char -> Bool) -> (String, String)
- escapeSpaces :: String -> String
- data Direction
- reslash :: Direction -> FilePath -> FilePath
- makeRelativeTo :: FilePath -> FilePath -> FilePath
- abstractConstr :: String -> Constr
- abstractDataType :: String -> DataType
- mkNoRepType :: String -> DataType
- charToC :: Word8 -> String
- hashString :: String -> Int32
Flags dependent on the compiler build
ncgDebugIsOn :: Bool
isDarwinHost :: Bool
General list processing
zipWithEqual :: String -> (a -> b -> c) -> [a] -> [b] -> [c]
zipWith3Equal :: String -> (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
zipWith4Equal :: String -> (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
zipLazy :: [a] -> [b] -> [(a, b)]
stretchZipWith :: (a -> Bool) -> b -> (a -> b -> c) -> [a] -> [b] -> [c]
stretchZipWith p z f xs ys
stretches ys
by inserting z
in
the places where p
returns True
zipWithAndUnzip :: (a -> b -> (c, d)) -> [a] -> [b] -> ([c], [d])
filterByList :: [Bool] -> [a] -> [a]
filterByList
takes a list of Bools and a list of some elements and
filters out these elements for which the corresponding value in the list of
Bools is False. This function does not check whether the lists have equal
length.
unzipWith :: (a -> b -> c) -> [(a, b)] -> [c]
mapFst :: (a -> c) -> [(a, b)] -> [(c, b)]
mapSnd :: (b -> c) -> [(a, b)] -> [(a, c)]
chkAppend :: [a] -> [a] -> [a]
mapAndUnzip :: (a -> (b, c)) -> [a] -> ([b], [c])
mapAndUnzip3 :: (a -> (b, c, d)) -> [a] -> ([b], [c], [d])
mapAccumL2 :: (s1 -> s2 -> a -> (s1, s2, b)) -> s1 -> s2 -> [a] -> (s1, s2, [b])
partitionWith :: (a -> Either b c) -> [a] -> ([b], [c])
Uses a function to determine which of two output lists an input element should join
splitEithers :: [Either a b] -> ([a], [b])
Teases a list of Either
s apart into two lists
dropWhileEndLE :: (a -> Bool) -> [a] -> [a]
foldl2 :: (acc -> a -> b -> acc) -> acc -> [a] -> [b] -> acc
lengthExceeds :: [a] -> Int -> Bool
(lengthExceeds xs n) = (length xs > n)
lengthAtLeast :: [a] -> Int -> Bool
listLengthCmp :: [a] -> Int -> Ordering
atLength :: ([a] -> b) -> (Int -> b) -> [a] -> Int -> b
atLength atLen atEnd ls n
unravels list ls
to position n
. Precisely:
atLength atLenPred atEndPred ls n | n < 0 = atLenPred n | length ls < n = atEndPred (n - length ls) | otherwise = atLenPred (drop n ls)
equalLength :: [a] -> [b] -> Bool
compareLength :: [a] -> [b] -> Ordering
isSingleton :: [a] -> Bool
only :: [a] -> a
singleton :: a -> [a]
Tuples
fstOf3 :: (a, b, c) -> a
sndOf3 :: (a, b, c) -> b
thirdOf3 :: (a, b, c) -> c
third3 :: (c -> d) -> (a, b, c) -> (a, b, d)
uncurry3 :: (a -> b -> c -> d) -> (a, b, c) -> d
List operations controlled by another list
takeList :: [b] -> [a] -> [a]
dropList :: [b] -> [a] -> [a]
splitAtList :: [b] -> [a] -> ([a], [a])
For loop
Sorting
Comparisons
removeSpaces :: String -> String
(<&&>) :: Applicative f => f Bool -> f Bool -> f Bool infixr 3
(<||>) :: Applicative f => f Bool -> f Bool -> f Bool infixr 2
Edit distance
fuzzyMatch :: String -> [String] -> [String]
fuzzyLookup :: String -> [(String, a)] -> [a]
Search for possible matches to the users input in the given list, returning a small number of ranked results
Transitive closures
transitiveClosure :: (a -> [a]) -> (a -> a -> Bool) -> [a] -> [a]
Strictness
seqList :: [a] -> b -> b
Module names
looksLikeModuleName :: String -> Bool
Argument processing
Floating point
readRational :: String -> Rational
read helpers
maybeReadFuzzy :: Read a => String -> Maybe a
IO-ish utilities
doesDirNameExist :: FilePath -> IO Bool
modificationTimeIfExists :: FilePath -> IO (Maybe UTCTime)
Filenames and paths
escapeSpaces :: String -> String
makeRelativeTo :: FilePath -> FilePath -> FilePath
Utils for defining Data instances
abstractConstr :: String -> Constr
abstractDataType :: String -> DataType
mkNoRepType :: String -> DataType Source
Constructs a non-representation for a non-representable type
Utils for printing C code
Hashing
hashString :: String -> Int32
A sample hash function for Strings. We keep multiplying by the golden ratio and adding. The implementation is:
hashString = foldl' f golden where f m c = fromIntegral (ord c) * magic + hashInt32 m magic = 0xdeadbeef
Where hashInt32 works just as hashInt shown above.
Knuth argues that repeated multiplication by the golden ratio will minimize gaps in the hash space, and thus it's a good choice for combining together multiple keys to form one.
Here we know that individual characters c are often small, and this produces frequent collisions if we use ord c alone. A particular problem are the shorter low ASCII and ISO-8859-1 character strings. We pre-multiply by a magic twiddle factor to obtain a good distribution. In fact, given the following test:
testp :: Int32 -> Int testp k = (n - ) . length . group . sort . map hs . take n $ ls where ls = [] : [c : l | l <- ls, c <- ['\0'..'\xff']] hs = foldl' f golden f m c = fromIntegral (ord c) * k + hashInt32 m n = 100000
We discover that testp magic = 0.