ghc-7.6.3: The GHC API

Safe Haskell | None

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

Synopsis

- ghciSupported :: Bool
- debugIsOn :: Bool
- ncgDebugIsOn :: Bool
- ghciTablesNextToCode :: Bool
- isDynamicGhcLib :: Bool
- isWindowsHost :: Bool
- isWindowsTarget :: Bool
- isDarwinTarget :: 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]
- unzipWith :: (a -> b -> c) -> [(a, b)] -> [c]
- mapFst :: (a -> c) -> [(a, b)] -> [(c, b)]
- mapSnd :: (b -> c) -> [(a, b)] -> [(a, c)]
- 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])
- 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
- 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
- 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
- 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
- parseSearchPath :: String -> [FilePath]
- data Direction
  - = Forwards
  - | Backwards
- reslash :: Direction -> FilePath -> FilePath
- abstractConstr :: String -> Constr
- abstractDataType :: String -> DataType
- mkNoRepType :: String -> DataType
- charToC :: Word8 -> String
- hashString :: String -> Int32

# Flags dependent on the compiler build

ghciSupported :: Bool

debugIsOn :: Bool

ncgDebugIsOn :: Bool

ghciTablesNextToCode :: Bool

isDynamicGhcLib :: Bool

isWindowsHost :: Bool

isWindowsTarget :: Bool

isDarwinTarget :: Bool

# General list processing

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)]

`zipLazy` is a kind of `zip` that is lazy in the second list (observe the ~)

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`

unzipWith :: (a -> b -> c) -> [(a, b)] -> [c]

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

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

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]

Like filter, only it reverses the sense of the test

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

foldl1' :: (a -> a -> a) -> [a] -> aSource

A strict version of `foldl1`

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

     (lengthExceeds xs n) = (length xs > n)

lengthIs :: [a] -> Int -> Bool

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]

notNull :: [a] -> Bool

snocView :: [a] -> Maybe ([a], a)

isIn :: Eq a => String -> a -> [a] -> Bool

isn'tIn :: Eq a => String -> a -> [a] -> Bool

# Tuples

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

# List operations controlled by another list

takeList :: [b] -> [a] -> [a]

dropList :: [b] -> [a] -> [a]

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

split :: Char -> String -> [String]

dropTail :: Int -> [a] -> [a]

# For loop

nTimes :: Int -> (a -> a) -> a -> a

Compose a function with itself n times. (nth rather than twice)

# Sorting

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

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

# Comparisons

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

# 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

getCmd :: String -> Either String (String, String)

toCmdArgs :: String -> Either String (String, [String])

toArgs :: String -> Either String [String]

# Floating point

readRational :: String -> Rational

# read helpers

maybeRead :: Read a => String -> Maybe a

maybeReadFuzzy :: Read a => String -> Maybe a

# IO-ish utilities

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

# Filenames and paths

type Suffix = String

splitLongestPrefix :: String -> (Char -> Bool) -> (String, String)

escapeSpaces :: String -> String

parseSearchPath :: String -> [FilePath]

The function splits the given string to substrings using the `searchPathSeparator`.

data Direction

Constructors

Forwards |
Backwards |

reslash :: Direction -> FilePath -> FilePath

# Utils for defining Data instances

abstractConstr :: String -> Constr

abstractDataType :: String -> DataType

mkNoRepType :: String -> DataType Source

Constructs a non-representation for a non-presentable type

# Utils for printing C code

charToC :: Word8 -> String

# 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.