Language.Haskell.Generate.PreludeDef

Documentation

nothing' :: forall a. ExpG (Maybe a)

true' :: ExpG Bool

false' :: ExpG Bool

right' :: forall a b. ExpG (b -> Either a b)

left' :: forall a b. ExpG (a -> Either a b)

just' :: forall a. ExpG (a -> Maybe a)

readLn' :: forall a. Read a => ExpG (IO a)

readIO' :: forall a. Read a => ExpG (String -> IO a)

appendFile' :: ExpG (FilePath -> String -> IO ())

writeFile' :: ExpG (FilePath -> String -> IO ())

readFile' :: ExpG (FilePath -> IO String)

interact' :: ExpG ((String -> String) -> IO ())

getContents' :: ExpG (IO String)

getLine' :: ExpG (IO String)

getChar' :: ExpG (IO Char)

print' :: forall a. Show a => ExpG (a -> IO ())

putStrLn' :: ExpG (String -> IO ())

putStr' :: ExpG (String -> IO ())

putChar' :: ExpG (Char -> IO ())

show' :: forall a. Show a => ExpG (a -> String)

read' :: forall a. Read a => ExpG (String -> a)

unwords' :: ExpG ([String] -> String)

unlines' :: ExpG ([String] -> String)

words' :: ExpG (String -> [String])

lines' :: ExpG (String -> [String])

unzip3' :: forall a b c. ExpG ([(a, b, c)] -> ([a], [b], [c]))

unzip' :: forall a b. ExpG ([(a, b)] -> ([a], [b]))

zipWith3' :: forall a b c d. ExpG ((a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d])

zipWith' :: forall a b c. ExpG ((a -> b -> c) -> [a] -> [b] -> [c])

zip3' :: forall a b c. ExpG ([a] -> [b] -> [c] -> [(a, b, c)])

zip' :: forall a b. ExpG ([a] -> [b] -> [(a, b)])

lookup' :: forall a b. Eq a => ExpG (a -> [(a, b)] -> Maybe b)

notElem' :: forall a. Eq a => ExpG (a -> [a] -> Bool)

elem' :: forall a. Eq a => ExpG (a -> [a] -> Bool)

break' :: forall a. ExpG ((a -> Bool) -> [a] -> ([a], [a]))

span' :: forall a. ExpG ((a -> Bool) -> [a] -> ([a], [a]))

dropWhile' :: forall a. ExpG ((a -> Bool) -> [a] -> [a])

takeWhile' :: forall a. ExpG ((a -> Bool) -> [a] -> [a])

splitAt' :: forall a. ExpG (Int -> [a] -> ([a], [a]))

drop' :: forall a. ExpG (Int -> [a] -> [a])

take' :: forall a. ExpG (Int -> [a] -> [a])

cycle' :: forall a. ExpG ([a] -> [a])

replicate' :: forall a. ExpG (Int -> a -> [a])

repeat' :: forall a. ExpG (a -> [a])

iterate' :: forall a. ExpG ((a -> a) -> a -> [a])

scanr1' :: forall a. ExpG ((a -> a -> a) -> [a] -> [a])

scanl1' :: forall a. ExpG ((a -> a -> a) -> [a] -> [a])

scanr' :: forall a b. ExpG ((a -> b -> b) -> b -> [a] -> [b])

scanl' :: forall b a. ExpG ((b -> a -> b) -> b -> [a] -> [b])

minimum' :: forall a. Ord a => ExpG ([a] -> a)

maximum' :: forall a. Ord a => ExpG ([a] -> a)

concatMap' :: forall a b. ExpG ((a -> [b]) -> [a] -> [b])

concat' :: forall a. ExpG ([[a]] -> [a])

product' :: forall a. Num a => ExpG ([a] -> a)

sum' :: forall a. Num a => ExpG ([a] -> a)

all' :: forall a. ExpG ((a -> Bool) -> [a] -> Bool)

any' :: forall a. ExpG ((a -> Bool) -> [a] -> Bool)

or' :: ExpG ([Bool] -> Bool)

and' :: ExpG ([Bool] -> Bool)

foldr1' :: forall a. ExpG ((a -> a -> a) -> [a] -> a)

foldl1' :: forall a. ExpG ((a -> a -> a) -> [a] -> a)

foldr' :: forall a b. ExpG ((a -> b -> b) -> b -> [a] -> b)

foldl' :: forall b a. ExpG ((b -> a -> b) -> b -> [a] -> b)

reverse' :: forall a. ExpG ([a] -> [a])

length' :: forall a. ExpG ([a] -> Int)

null' :: forall a. ExpG ([a] -> Bool)

init' :: forall a. ExpG ([a] -> [a])

tail' :: forall a. ExpG ([a] -> [a])

last' :: forall a. ExpG ([a] -> a)

head' :: forall a. ExpG ([a] -> a)

filter' :: forall a. ExpG ((a -> Bool) -> [a] -> [a])

map' :: forall a b. ExpG ((a -> b) -> [a] -> [b])

undefined' :: forall a. ExpG a

asTypeOf' :: forall a. ExpG (a -> a -> a)

until' :: forall a. ExpG ((a -> Bool) -> (a -> a) -> a -> a)

flip' :: forall a b c. ExpG ((a -> b -> c) -> b -> a -> c)

const' :: forall a b. ExpG (a -> b -> a)

id' :: forall a. ExpG (a -> a)

mapM_' :: forall a m b. Monad m => ExpG ((a -> m b) -> [a] -> m ())

mapM' :: forall a m b. Monad m => ExpG ((a -> m b) -> [a] -> m [b])

return' :: forall m. Monad m => forall a. ExpG (a -> m a)

fmap' :: forall f. Functor f => forall a b. ExpG ((a -> b) -> f a -> f b)

realToFrac' :: forall a b. (Real a, Fractional b) => ExpG (a -> b)

fromIntegral' :: forall a b. (Integral a, Num b) => ExpG (a -> b)

lcm' :: forall a. Integral a => ExpG (a -> a -> a)

gcd' :: forall a. Integral a => ExpG (a -> a -> a)

odd' :: forall a. Integral a => ExpG (a -> Bool)

even' :: forall a. Integral a => ExpG (a -> Bool)

subtract' :: forall a. Num a => ExpG (a -> a -> a)

atan2' :: forall a. RealFloat a => ExpG (a -> a -> a)

isNegativeZero' :: forall a. RealFloat a => ExpG (a -> Bool)

isIEEE' :: forall a. RealFloat a => ExpG (a -> Bool)

isDenormalized' :: forall a. RealFloat a => ExpG (a -> Bool)

isInfinite' :: forall a. RealFloat a => ExpG (a -> Bool)

isNaN' :: forall a. RealFloat a => ExpG (a -> Bool)

scaleFloat' :: forall a. RealFloat a => ExpG (Int -> a -> a)

significand' :: forall a. RealFloat a => ExpG (a -> a)

exponent' :: forall a. RealFloat a => ExpG (a -> Int)

encodeFloat' :: forall a. RealFloat a => ExpG (Integer -> Int -> a)

decodeFloat' :: forall a. RealFloat a => ExpG (a -> (Integer, Int))

floatRange' :: forall a. RealFloat a => ExpG (a -> (Int, Int))

floatDigits' :: forall a. RealFloat a => ExpG (a -> Int)

floatRadix' :: forall a. RealFloat a => ExpG (a -> Integer)

floor' :: forall a. RealFrac a => forall b. Integral b => ExpG (a -> b)

ceiling' :: forall a. RealFrac a => forall b. Integral b => ExpG (a -> b)

round' :: forall a. RealFrac a => forall b. Integral b => ExpG (a -> b)

truncate' :: forall a. RealFrac a => forall b. Integral b => ExpG (a -> b)

properFraction' :: forall a. RealFrac a => forall b. Integral b => ExpG (a -> (b, a))

atanh' :: forall a. Floating a => ExpG (a -> a)

acosh' :: forall a. Floating a => ExpG (a -> a)

asinh' :: forall a. Floating a => ExpG (a -> a)

tanh' :: forall a. Floating a => ExpG (a -> a)

cosh' :: forall a. Floating a => ExpG (a -> a)

sinh' :: forall a. Floating a => ExpG (a -> a)

atan' :: forall a. Floating a => ExpG (a -> a)

acos' :: forall a. Floating a => ExpG (a -> a)

asin' :: forall a. Floating a => ExpG (a -> a)

tan' :: forall a. Floating a => ExpG (a -> a)

cos' :: forall a. Floating a => ExpG (a -> a)

sin' :: forall a. Floating a => ExpG (a -> a)

logBase' :: forall a. Floating a => ExpG (a -> a -> a)

sqrt' :: forall a. Floating a => ExpG (a -> a)

log' :: forall a. Floating a => ExpG (a -> a)

exp' :: forall a. Floating a => ExpG (a -> a)

pi' :: forall a. Floating a => ExpG a

fromRational' :: forall a. Fractional a => ExpG (Rational -> a)

recip' :: forall a. Fractional a => ExpG (a -> a)

toInteger' :: forall a. Integral a => ExpG (a -> Integer)

divMod' :: forall a. Integral a => ExpG (a -> a -> (a, a))

quotRem' :: forall a. Integral a => ExpG (a -> a -> (a, a))

mod' :: forall a. Integral a => ExpG (a -> a -> a)

div' :: forall a. Integral a => ExpG (a -> a -> a)

rem' :: forall a. Integral a => ExpG (a -> a -> a)

quot' :: forall a. Integral a => ExpG (a -> a -> a)

fromInteger' :: forall a. Num a => ExpG (Integer -> a)

signum' :: forall a. Num a => ExpG (a -> a)

abs' :: forall a. Num a => ExpG (a -> a)

negate' :: forall a. Num a => ExpG (a -> a)

not' :: ExpG (Bool -> Bool)

uncurry' :: forall a b c. ExpG ((a -> b -> c) -> (a, b) -> c)

curry' :: forall a b c. ExpG (((a, b) -> c) -> a -> b -> c)

snd' :: forall a b. ExpG ((a, b) -> b)

fst' :: forall a b. ExpG ((a, b) -> a)

either' :: forall a c b. ExpG ((a -> c) -> (b -> c) -> Either a b -> c)

maybe' :: forall b a. ExpG (b -> (a -> b) -> Maybe a -> b)

equal' :: forall a. Eq a => ExpG (a -> a -> Bool)

index' :: forall a. ExpG ([a] -> Int -> a)

append' :: forall a. ExpG ([a] -> [a] -> [a])

then' :: forall m. Monad m => forall a b. ExpG (m a -> m b -> m b)

bind' :: forall m. Monad m => forall a b. ExpG (m a -> (a -> m b) -> m b)

floatPow' :: forall a. Floating a => ExpG (a -> a -> a)

divide' :: forall a. Fractional a => ExpG (a -> a -> a)

mult' :: forall a. Num a => ExpG (a -> a -> a)

add' :: forall a. Num a => ExpG (a -> a -> a)

dot' :: forall b c a. ExpG ((b -> c) -> (a -> b) -> a -> c)

(<>.) :: ExpG (b -> c) -> ExpG (a -> b) -> ExpG (a -> c)

tuple0 :: ExpG ()

tuple2 :: ExpG (a -> b -> (a, b))

tuple3 :: ExpG (a -> b -> c -> (a, b, c))

tuple4 :: ExpG (a -> b -> c -> d -> (a, b, c, d))

tuple5 :: ExpG (a -> b -> c -> d -> (a, b, c, d, e))

cons :: ExpG (a -> [a] -> [a])