| (!!) :: [a] -> Int -> a | [0,1,2] !! 1 = 1 |
| ($) :: (a -> b) -> a -> b | f x $ g y = f x (g y) |
| (&&) :: Bool -> Bool -> Bool | Boolean `and' |
| (||) :: Bool -> Bool -> Bool | Boolean `or' |
| (*) :: Num a => a -> a -> a |
| (**) :: Floating a => a -> a -> a |
| (+) :: Num a => a -> a -> a |
| (++) :: MonadPlus m => m a -> m a -> m a | "abc" ++ "def" = "abdec" |
| (-) :: Num a => a -> a -> a |
| (.) :: (b -> c) -> (a -> b) -> a -> c | Function composition |
| (/) :: Fractional a => a -> a -> a |
| (/=) :: Eq a => a -> a -> Bool | not equal |
| (<) :: Ord a => a -> a -> Bool |
| (<=) :: Ord a => a -> a -> Bool |
| (==) :: Eq a => a -> a -> Bool |
| (>) :: Ord a => a -> a -> Bool |
| (>=) :: Ord a => a -> a -> Bool |
| (>>) :: m a -> m b -> m b | Monadic binding (see 3.14) |
| (>>=) :: Monad m => m a -> (a -> m b) -> m b | Monadic binding (see 3.14) |
| (^) :: (Num a, Integral b) => a -> b -> a |
| (^^) :: (Fractional a, Integral b) => a -> b -> a | negative exponent allowed |
| abs :: Num a => a -> a |
| accumulate :: Monad m => [m a] -> m [a] |
| acos :: Floating a => a -> a |
| acosh :: Floating a => a -> a |
| all :: (a -> Bool) -> [a] -> Bool | all (/= 'a') "cba" = False |
| and :: [Bool] -> Bool | and [True, True, True] = True |
| any :: (a -> Bool) -> [a] -> Bool | any (== 'c') "abc" = True |
| appendFile :: FilePath -> String -> IO () |
| applyM :: Monad m => (a -> m b) -> m a -> m b |
| asTypeOf :: a -> a -> a | Sort of a type cast |
| asin :: Floating a => a -> a |
| asinh :: Floating a => a -> a |
| atan :: Floating a => a -> a |
| atan2 :: RealFrac a => a -> a |
| atanh :: Floating a => a -> a |
| break :: (a -> Bool) -> [a] -> ([a], [a]) | break (<2) [1,2,3] = ([1],[2,3]) |
| catch :: IO a -> (IOError -> IO a) -> IO a |
| ceiling :: (RealFrac a, Integral b) => a -> b |
| compare :: Ord a => a -> a -> Ordering |
| concat :: MonadPlus m => [m a] -> m a | concat ["a","bc","d"] = "abcd" |
| concatMap :: (a -> [b]) -> [a] -> [b] |
| const :: a -> b -> a |
| cos :: Floating a => a -> a |
| cosh :: Floating a => a -> a |
| curry :: ((a, b) -> c) -> a -> b -> c |
| cycle :: [a] -> [a] | cycle "abc" = "abcabcabc ..." |
| decodeFloat :: RealFloat a => a -> (Integer, Int) |
| div :: Integral a => a -> a -> a |
| divMod :: Integral a => a -> a -> (a, a) |
| drop :: Int -> [a] -> [a] | drop 2 "abcd" = "cd" |
| dropWhile :: (a -> Bool) -> [a] -> [a] | dropWhile (>3) [5,3,5] = [3,5] |
| elem :: Eq a => a -> [a] -> Bool | 'a' `Elem` "abc" = True |
| encodeFloat :: RealFloat a => Integer -> Int -> a |
| enumFrom :: Enum a => a -> [a] | [n..] |
| enumFromThen :: Enum a => a -> a -> [a] | [m,n..] |
| enumFromThenTo :: Enum a => a -> a -> a -> [a] | [m,n..o] |
| enumFromTo :: Enum a => a -> a -> [a] | [m..n] |
| error :: String -> a | (see 3.1) |
| even :: Integral a => a -> Bool |
| exp :: Floating a => a -> a |
| exponent :: RealFloat a => a -> Int |
| fail :: IOError -> IO a |
| filter :: MonadZero m => (a -> Bool) -> m a -> m a | filter isUpper "AbCd" = "AB" |
| flip :: (a -> b -> c) -> (b -> a -> c) |
| floatDigits :: RealFloat a => a -> Int |
| floatRadix :: RealFloat a => a -> Integer |
| floatRange :: RealFloat a => a -> (Int, Int) |
| floor :: (RealFrac a, Integral b) => a -> b |
| foldl :: (a -> b -> a) -> a -> [b] -> a | foldl (+) 0 [a,b,c] = ((a+b)+c)+0 |
| foldl1 :: (a -> a -> a) -> [a] -> a | foldl1 (+) [a,b,c] = (a+b)+c |
| foldr :: (a -> b -> b) -> b -> [a] -> b | foldr (+) 0 [a,b,c] = 0+(a+(b+c)) |
| foldr1 :: (a -> a -> a) -> [a] -> a | foldr (+) [a,b,c] = a+(b+c) |
| fromEnum :: Enum a => a -> Int |
| fromInteger :: Num a => Integer -> a | (see 3.2) |
| fromIntegral :: (Integral a, Num b) => a -> b |
| fromRational :: Fractional a => Rational -> a | (see 3.2) |
| fromRealFrac :: (RealFrac a, Fractional b) => a -> b |
| fst :: (a, b) -> a |
| gcd :: (Integral a) => a -> a -> a |
| getChar :: IO Char | eof generates an IOError |
| getContents :: IO String |
| getLine :: IO Char | eof generates an IOError |
| guard :: MonadZero m => Bool -> m () |
| head :: [a] -> a |
| id :: a -> a |
| init :: [a] -> [a] | init "abcd" = "abc" |
| interact :: (String -> String) -> IO () |
| isDenormalized :: RealFloat a => a -> Bool |
| isIEEE :: RealFloat a => a -> Bool |
| isInfinite :: RealFloat a => a -> Bool |
| isNaN :: RealFloat a => a -> Bool |
| isNegativeZero :: RealFloat a => a -> Bool |
| iterate :: (a -> a) -> a -> [a] | iterate (++ " ") "" = ["", " ", " ",...] |
| last :: [a] -> a | last "abcde" = "e" |
| lcm :: Integral a => a -> a -> a |
| length :: [a] -> Int | length "Abc" = 3 |
| lex :: ReadS String | lex "abc def" = [("abc"," def")] |
| lines :: String -> [String] |
| log :: Floating a => a -> a |
| logBase :: Floating a => a -> a -> a |
| lookup :: Eq a => a -> [(a, b)] -> Maybe b |
| map :: Functor f => (a -> b) -> f a -> f b |
| mapM :: Monad m => (a -> m b) -> [a] -> m [b] |
| mapM_ :: Monad m => (a -> m b) -> [a] -> m () |
| max :: Ord a => a -> a -> a |
| maxBound :: Bounded a => a |
| maximum :: Ord a => [a] -> a |
| maybe :: b -> (a -> b) -> Maybe a -> b | maybe 0 (+1) (Just 1) = 2 |
| min :: Ord a => a -> a -> a |
| minBound :: Bounded a => a |
| minimum :: Ord a => [a] -> a |
| mod :: Integral a => a -> a -> a |
| negate :: Num a => a -> a |
| not :: Bool -> Bool |
| notElem :: Eq a => a -> [a] -> Bool |
| null :: [a] -> Bool |
| odd :: Integral a => a -> Bool |
| or :: [Bool] -> Bool |
| otherwise :: Bool |
| pi :: Floating a => a |
| pred :: Enum a => a -> a | pred True = False |
| print :: Show a => IO () | adds a newline |
| product :: Num a => [a] -> a |
| properFraction :: (RealFrac a, Integral b) => a -> (b, a) |
| putChar :: Char -> IO () |
| putStr :: String -> IO () |
| putStrLn :: String -> IO () | adds a newline |
| quot :: Integral a => a -> a -> a |
| quotRem :: Integral a => a -> a -> (a, a) |
| read :: Read a => String -> a |
| readFile :: FilePath -> IO String |
| readIO :: Read a => String -> IO a | fails with IOError |
| readList :: Read a => ReadS [a] |
| readLn :: Read a => IO a |
| readParen :: Bool -> ReadS a -> ReadS a |
| reads :: Read a => ReadS a | reads "1 2" :: [(Int,String)] = [(1," 2")] |
| readsPrec :: Read a => Int -> ReadS a |
| recip :: Fractional a => a -> a |
| rem :: Integral a => a -> a -> a |
| repeat :: a -> [a] | repeat 'a' = "aaaaaaaaa..." |
| replicate :: Int -> a -> [a] | replicate 4 'a' = "aaaa" |
| return :: Monad m => a -> m a |
| reverse :: [a] -> [a] | reverse "abc" = "cba" |
| round :: (RealFrac a, Integral b) => a -> b |
| scaleFloat :: RealFloat a => Int -> a -> a |
| scanl :: (a -> b -> a) -> a -> [b] -> [a] | scanl (+) 0 [1,2,3] = [1,3,6] |
| scanl1 :: (a -> a -> a) -> [a] -> [a] | scanl1 (+) [1,2,3] = [1,3,6] |
| scanr :: (a -> b -> b) -> b -> [a] -> [b] | scanr (+) 0 [1,2,3] = [6,5,1,0] |
| scanr1 :: (a -> a -> a) -> [a] -> [a] | scanr (+) [1,2,3] = [6,5,1] |
| seq :: Eval a => a -> a -> b | (see 6.2.7) |
| sequence :: Monad m => [m a] -> m () | do operations in sequence |
| show :: Show a => a -> String | (see 6.2.3) |
| showChar :: Char -> ShowS |
| showList :: Show a => [a] -> ShowS |
| showParen :: Bool -> ShowS -> ShowS |
| showString :: String -> ShowS |
| shows :: Show a => a -> ShowS | (see 6.2.3) |
| showsPrec :: Show a => Int -> a -> ShowS | (see 6.2.3) |
| significand :: RealFloat a => a -> a |
| signum :: Num a => a -> a |
| sin :: Floating a => a -> a |
| sinh :: Floating a => a -> a |
| snd :: (a, b) -> b |
| span :: (a -> Bool) -> [a] -> ([a], [a]) | span isAlpha "ab cd" = ("ab"," cd") |
| splitAt :: Int -> [a] -> ([a], [a]) | splitAt 2 "abcdef" = ("ab","cdef") |
| sqrt :: Floating a => a -> a |
| strict :: Eval a => (a -> b) -> (a -> b) | (see 6.2.7) |
| subtract :: Num a => a -> a -> a |
| succ :: Enum a => a -> a | succ False = True |
| sum :: Num a => [a] -> a | sum [1,2,3] = 6 |
| tail :: [a] -> [a] | tail "abc" = "bc" |
| take :: Int -> [a] -> [a] | take 3 "abcde" = "abc" |
| takeWhile :: (a -> Bool) -> [a] -> [a] | takeWhile (> 2) [3,2,1] = [3] |
| tan :: Floating a => a -> a |
| tanh :: Floating a => a -> a |
| toEnum :: Enum a => Int -> a | toEnum 0 :: Bool = False |
| toInteger :: Integral a => a -> Integer |
| toRational :: Real a => a -> Rational |
| truncate :: (RealFrac a, Integral b) => a -> b |
| uncurry :: (a -> b -> c) -> ((a, b) -> c) |
| undefined :: a | (see 3.1) |
| unlines :: [String] -> String |
| until :: (a -> Bool) -> (a -> a) -> a -> a | until (> 3) (+ 2) 0 = 4 |
| unwords :: [String] -> String |
| unzip :: [(a, b)] -> ([a], [b]) | unzip [('a','b'),('c','d')] = ["ac",bd"] |
| unzip3 :: [(a, b, c)] -> ([a], [b], [c]) |
| userError :: String -> IOError |
| words :: String -> [String] | words "ab d as+3" = ["ab","d","as+3"] |
| writeFile :: FilePath -> String -> IO () |
| zero :: MonadZero m => m a |
| zip :: [a] -> [b] -> [(a, b)] | zip "abc" "de" = [('a','d'), ('b',e')] |
| zip3 :: [a] -> [b] -> [c] -> [(a, b, c)] |
| zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] | zipWith (+) [1,2] [3,4] = [4,7] |
| zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d] |