The Haskell 98 Report
top

Index of the Haskell 98 Prelude

Types and Synonyms

Instances which are not defined by Haskell code the Prelude (a ... is used) are not hyperlinked. 

data () = ()  deriving (Eq, Ord, Enum, Bounded) (see 6.1.5)
      Instances: Read Show
data [a] = [] | a : [a]  deriving (Eq, Ord) (see 6.1.3)
      Instances: Read Show Functor Monad
data (a,b) = (a,b) deriving (Eq, Ord, Bounded) (see 6.1.4) 
      Instances: Read Show
data a->b (see 6.1.6)
data Bool = False | True deriving (Eq, Ord, Enum, Read, Show, Bounded) (see 6.1.1)
data Char (see 6.1.2)
       Instances: Eq Ord Enum Read Show 
data Double (see 6.4) 
       Instances: Eq Ord Enum Read Show Num Real Fractional RealFrac Floating RealFloat
data Either a b  e=  Left a | Right b deriving (Eq, Ord, Read, Show) (see 6.1.8)
type FilePath =  String (see 7.1)
data Float (see 6.4)
       Instances: Eq Ord Enum Read Show Num Real Fractional RealFrac Floating RealFloat
data Int (see 6.4)
       Instances: Eq Ord Enum Read Show Num Real Integral Bounded
data Integer (see 6.4)
       Instances: Eq Ord Enum Read Show Num Real Integral
data IO a (see 6.1.7)
       Instances: Functor Monad
data IOError (see 6.1.7)
       Instances: Show Eq
data Maybe a  =  Nothing | Just a deriving (Eq, Ord, Read, Show) (see 6.1.8)
        Instances: Functor Monad
data Ordering = LT | EQ | GT  deriving (Eq, Ord, Enum, Read, Show, Bounded) (see 6.1.8)
type ReadS a = String -> [(a,String)] (see 6.3.3)
type ShowS = String -> String (see 6.3.3)
type String = [Char] (see 6.1.2)

Constructors 

[]
:
(,)
EQ
False
GT
Just
Left
LT
Nothing
Right
True

Classes 

class                             Bounded a    (see 6.3.7)
class                             Enum a       (see 6.3.4)
class                             Eq a         (see 6.3.1)
class           (Fractional a) => Floating a   (see 6.4)
class                  (Num a) => Fractional a (see 6.4)
class                             Functor f    (see 6.3.5)
class         (Real a, Enum a) => Integral a   (see 6.4)
class                             Monad m      (see 6.3.6)
class           (Eq a, Show a) => Num a        (see 6.4)
class                   (Eq a) => Ord a        (see 6.3.2)
class                             Read a       (see 6.3.3)
class           (Num a, Ord a) => Real a       (see 6.4)
class (RealFrac a, Floating a) => RealFloat a  (see 6.4)  
class   (Real a, Fractional a) => RealFrac a   (see 6.4)
class                             Show a       (see 6.3.3)

Functions and Methods

(!!)             :: [a] -> Int -> a [0,1,2] !! 1 = 1
($)              :: (a -> b) -> a -> b f x $ g y = f x (g y)    
($!)             :: (a -> b) -> (a -> b) (see 6.2)
(&&)             :: 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
(++)             :: [a] -> [a] -> [a] "abc" ++ "def" = "abcdef"
(-)              :: 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 
(=<<)            :: Monad a => (a -> m b) -> m a -> m b  Monadic binding (see 6.3.6)
(>)              :: Ord a => a -> a -> Bool 
(>=)             :: Ord a => a -> a -> Bool 
(>>)             :: Monad m => m a -> m b -> m b Monadic binding (see 6.3.6)
(>>=)            :: Monad m => m a -> (a -> m b) -> m b Monadic binding (see 6.3.6)
(^)              :: (Num a, Integral b) => a -> b -> a 
(^^)             :: (Fractional a, Integral b) => a -> b -> a negative exponent allowed
abs              :: Num a => a -> 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             :: Monad m => String -> m a
filter           :: (a -> Bool) -> [a] -> [a]
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 
fmap             :: Functor f => (a -> b) -> f a -> f b
foldl            :: (a -> b -> a) -> a -> [b] -> a foldl (+) 0 [a,b,c] = ((0+a)+b)+c
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] = a+(b+(c+0))
foldr1           :: (a -> a -> a) -> [a] -> a foldr1 (+) [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)
fst              :: (a, b) -> a
gcd              :: (Integral a) => a -> a -> a
getChar          :: IO Char eof generates an IOError
getContents      :: IO String
getLine          :: IO String eof generates an IOError
head             :: [a] -> a
id               :: a -> a
init             :: [a] -> [a]init "abcd" = "abc"
interact         :: (String -> String) -> IO ()
ioError          :: IOError -> IO a 
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              :: (a -> b) -> [a] -> [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
realToFrac       :: (Real a, Fractional b) => a -> b
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] = [0,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,3,0]
scanr1           :: (a -> a -> a) -> [a] -> [a] scanr1 (+) [1,2,3] = [6,5,3]
seq              :: a -> b -> b (see 6.2)
sequence         :: Monad m => [m a] -> m [a] 
sequence_        :: Monad m => [m a] -> m () do operations in sequence
show             :: Show a => a -> String (see 6.3.3)
showChar         :: Char -> ShowS
showList         :: Show a => [a] -> ShowS
showParen        :: Bool -> ShowS -> ShowS
showString       :: String -> ShowS
shows            :: Show a => a -> ShowS (see 6.3.3)
showsPrec        :: Show a => Int -> a -> ShowS (see 6.3.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 
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 ()
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,6]
zipWith3         :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]