Haskell Base Library Quick Reference

This page lists classes, types and functions that we will often use in our course. For the complete story, see the full library documentation at haskell.org.

Quick jump:

Type classes

class Eq e

Instances: All basic types except functions
Minimal definition: either (==) or (/=)

(==), (/=) :: e → e → Bool
Equality and inequality operators.

class Ord o (superclass: Eq)

Instances: All basic types except functions
Minimal definition: either compare or (<=)

(<), (<=), (>), (>=) :: o → o → Bool
Comparison operators.
compare :: o → o → Ordering
Compare two values, returning an Ordering (i.e. LT, EQ, or GT).
min, max :: o → o → o
Return the minimum or maximum of two values.

class Enum e

Instances: Bool, Char, Int, Integer, Float, Double

An enumerable type that can be used in ranges such as [1 .. 5].

succ :: e → e
pred :: e → e
Successor and predecessor functions.

class Bounded b

Instances: Bool, Char, Int

minBound :: b
maxBound :: b
Lower and upper bounds for a type.

class Read r

Instances: All basic types except functions

read :: String → r
Parse a value from a string.

class Show s

Instances: All basic types except functions

show :: s → String
Convert a value to its string representation.

Numeric type classes

class Num n

Instances: Int, Integer, Float, Double

(+), (-), (*) :: n → n → n
Addition, subtraction, and multiplication operators.
abs :: n → n
Absolute value.
fromInteger :: Integer -> a
Convert an Integer to any numeric type.

class Integral i (superclasses: Num, Ord, Enum)

Instances: Int, Integer

div, mod :: i → i → i
Integer division (truncating toward -∞) and modulus (always non-negative).
toInteger :: i → Integer
Convert any Integral type to an Integer.

class Fractional f (superclass: Num)

Instances: Float, Double

(/) :: f → f → f
The division operator.
(**) :: f → f → f
Exponentiation to a Fractional power.
cos :: f → f
exp :: f → f
log :: f → f
pi :: f
sin :: f → f
sqrt :: f → f
tan :: f → f
Standard numeric functions.

class RealFrac r (superclass: Fractional)

Instances: Float, Double

ceiling :: Integral i => r → i
Return the smallest integer that is not less than x.
floor :: Integral i => r → i
Return the greatest integer that is not greater than x.

Numbers

type Int

Instance of: Num, Integral

A fixed-length signed integer. In GHC, this is a 64-bit value.

type Integer

Instance of: Num, Integral

A signed integer of arbitrary size.

type Float
type Double

Instance of: Num, Fractional

Single- and double-precision floating-point numbers.

numeric functions

(^) :: (Num n, Integral i) => n → i → n
Exponentiation to an integer power.
even :: Integral a => a → Bool
True if a number is even.
fromIntegral :: (Integral i, Num n) => i → n
Convert an integral value to a number of any type. Defined as
fromIntegral i = fromInteger (toInteger i)
odd :: Integral a => a → Bool
True if a number is odd.

Booleans

type Bool

Instance of: Bounded

A value that is either True or False.

(&&) :: Bool → Bool → Bool
(||) :: Bool → Bool → Bool
Logical AND and OR operators.
not :: Bool → Bool
Logical negation.

Characters

type Char

Instance of: Bounded

Any Unicode character.

Import the Data.Char module to access these functions:

chr :: Int → Char
Convert a Unicode code point to a character. For example, chr(65) is 'A'.
digitToInt :: Char → Int
Convert a Char to the corresponding Int. For example, (digitToInt '7') == 7. Hexadecimal digits are supported.
intToDigit :: Int → Char
Convert an Int in the range 0..15 to the corresponding Char. For example, (intToDigit 7) == '7'. Hexadecimal digits are supported.
isAlpha :: Char → Bool
Check whether a character is a letter.
isDigit :: Char → Bool
Check whether a character is a digit.
isLower :: Char → Bool
Check whether a character is a lowercase letter.
isSpace :: Char → Bool
Check whether a character is whitespace.
isUpper :: Char → Bool
Check whether a character is an uppercase letter.
ord :: Char → Int
Convert a character to a Unicode code point. For example, ord('A') is 65.
toLower :: Char → Char
Convert a character to lowercase.
toUpper :: Char → Char
Convert a character to uppercase.

Strings

type String = [Char]

A string is a list of characters.

lines :: String → [String]
Break a string into a list of lines, separated by newline characters.
unlines :: [String] → String
Join a list of strings into a single string, separating the strings with newline characters.
unwords :: [String] → String
Join a list of strings into a single string, separating the strings with spaces.
words :: String → [String]
Break a string into a list of words, separated by sequences of whitespace characters.

Additional string functions

Import the Text.Read module to access these functions:

readMaybe :: Read a => String -> Maybe a
Read a value from a string if possible; otherwise return Nothing.

Functions

(.) :: (b → c) → (a → b) → (a → c)
The function composition operator.
($) :: (a → b) → a → b
The function application operator. $ has low precedence and binds to the right, so

f $ g $ h x == f (g (h x))

id :: a → a
The identity function.

Ordering

Import the Data.Ord module to get this function:

comparing :: Ord a => (b → a) → b → b → Ordering
Given a function that extracts a comparison key, return a function that compares two values. In other words,
comparing p x y = compare (p x) (p y)
This is a convenient helper function for functions such as maximumBy and sortBy. For example,
sortBy (comparing snd) list
will sort a list of pairs by their second element.

Maybe

data Maybe t = Nothing | Just t

Import the Data.Maybe module to access these functions:

fromJust :: Maybe a → a
Return the value in a Just, throwing an error if the argument is Nothing.
fromMaybe :: a → Maybe a → a
Given a default value and a Maybe, return the default value if the Maybe is Nothing; otherwise return the value in the Maybe.
listToMaybe :: [a] → Maybe a
Return (Just a) where a is the first element of the list, or Nothing on an empty list.
maybe :: b -> (a -> b) -> Maybe a -> b
This function takes a default value, a function f, and a Maybe value. If the Maybe value is Nothing, it returns the default value. Otherwise, it applies f to the value inside the Just and returns the result.
maybeToList :: Maybe a → [a]
Return the singleton list [x] when given (Just x), or [] when given Nothing.

Tuples

type (a, b)
type (a, b, c)
…

fst :: (a, b) → a
snd :: (a, b) → b
Return the first or second component of a pair.

Lists

type [a]

A list of elements of type a.

Lists can be compared lexicographically.

[] :: [a]
The empty list.
(:) :: a → [a] → [a]
Prepend an element to a list.
(++) :: [a] → [a] → [a]
Append two lists.
(!!) :: [a] → Int → a
Return the nth element of a non-empty list.
all :: (a → Bool) → [a] → Bool
Return true if all values in a list satisfy a predicate.
and :: [Bool] → Bool
Return true if all values in a boolean list are true.
any :: (a → Bool) → [a] → Bool
Return true if any values in a list satisfy a predicate.
concat :: [[a]] → [a]
Flatten a list of lists into a single-level list.
concatMap :: (a → [b]) → [a] → [b]
Map a function over a list and concatenate the resulting lists.
drop :: Int → [a] → [a]
Drop the first n elements from a list. If the list has fewer than n elements, the empty list is returned.
dropWhile :: (a → Bool) → [a] → [a]
Drop the longest prefix of elements that satisfy a predicate.
elem :: Eq a => a → [a] → Bool
Return true if a list contains a given value.
filter :: (a → Bool) → [a] → [a]
Select all elements of a list that satisfy a predicate.
foldl :: (a → b → a) → a → [b] → a
Fold a list using a binary operator, from left to right. In the type signature above, a is the accumulator type and b is the list element type. The function passed to foldl takes the accumulator as its first argument, i.e. on the left.
foldl f a [x1, x2, x3, …, xn] = f (… (f (f (f a x1) x2) x3) … xn)
For example,

foldl (+) 0 [1, 2, 3] = (((0 + 1) + 2) + 3) = 6
foldl (-) 0 [1, 2, 3] = (((0 - 1) - 2) - 3) = -6

foldl1 :: (a → a → a) → [a] → a
A variant of foldl that has no starting value argument (and so it can't be applied to empty lists).
foldr :: (a → b → b) → b → [a] → b
Reduce a list using a binary operator, from right to left. In the type signature above, a is the accumulator type and b is the list element type. The function passed to foldr takes the accumulator as its first argument, i.e. on the right.
foldr f a [x1, x2, x3, …, xn] = f x1 (f x2 (f x3 (… (f xn a) …)))
For example,

foldr (+) 0 [1, 2, 3] = 1 + (2 + (3 + 0)) = 6
foldr (-) 0 [1, 2, 3] = 1 - (2 - (3 - 0)) = 2

foldr1 :: (a → a → a) → [a] → a
A variant of foldr that has no starting value argument (and so it can't be applied to empty lists).
head :: [a] → a
Return the first element of a non-empty list.
init :: [a] → [a]
Return all elements of a list except the last element. The list must be non-empty.
iterate :: (a → a) → a → [a]
Return an infinite list generated by applying a function repeatedly:

iterate f x = [x, f x, f (f x), ...]

last :: [a] → a
Return the last element of a non-empty list.
length :: [a] → Int
Return the length of a list.
lookup :: Eq a => a → [(a, b)] → Maybe b
Look up a key in an association list, i.e. a list of (key, value) pairs.
map :: (a → b) → [a] → [b]
Apply a function to all elements of a list.
maximum :: Ord a => [a] → a
Return the largest value in a list.
minimum :: Ord a => [a] → a
Return the smallest value in a list.
null :: [a] → Bool
Return true if a list is empty.
or :: [Bool] → Bool
Return true if any values in a boolean list are true.
repeat :: a → [a]
Produce an infinite list of identical elements.
replicate :: Int → a → [a]
Produce a list with n identical elements.
reverse :: [a] → [a]
Reverse a list.
span :: (a → Bool) → [a] → ([a], [a])
Split a list into two lists using a predicate p. (span p l) is equivalent to (takeWhile p l, dropWhile p l).
splitAt :: Int → [a] → ([a], [a])
Split a list into two lists: the first contains the first n elements, and the second contains the remaining elements. (splitAt n xs) is equivalent to (take n xs, drop n xs).
sum :: Num a => [a] → a
Return the sum of a list of numbers.
tail :: [a] → a
Return a list of all elements except the first element. The list must be non-empty.
take :: Int → [a] → [a]
Return the first n elements of a list. If the list has fewer than n elements, the entire list is returned.
takeWhile :: (a → Bool) → [a] → [a]
Return the longest prefix of elements that satisfy a predicate.
unzip :: [(a, b)] → ([a], [b])
Produce a pair of lists from a list of pairs.
unzip3 :: [(a, b, c)] → ([a], [b], [c])
Produce a triple of lists from a list of triples.
zip :: [a] → [b] → [(a, b)]
Produce a list of pairs from a pair of lists. If one of the input lists is shorter than the other, excess elements of the longer list are discarded.
zip3 :: [a] → [b] → [c] → [(a, b, c)]
zip3 takes three lists and returns a list of triples.
zipWith :: (a → b → c) → [a] → [b] → [c]
A generalized version of zip that combines corresponding elements using the given function rather than a tupling function.

Additional list functions

Import the Data.List module to access these functions:

(\\) :: Eq a => [a] → [a] → [a]
Return the difference of two sets represented by lists. The result will contain no duplicates unless duplicates were already present in the first of the input lists.
delete :: Eq a => a → [a] → [a]
Delete the first occurrence of a value from a list. If the value is not found, the list is returned unchanged:
> delete 7 [2, 3, 7, 1, 5]
[2,3,1,5]
> delete 6 [2, 3, 7, 1, 5]
[2,3,7,1,5]
elemIndex :: Eq a => a → [a] → Maybe Int
Return the index of the first element in the given list that is equal to the query element, or Nothing if there is no such element.
find :: (a → Bool) → [a] → Maybe a
Return the first element in the list that satisfies the given predicate, or Nothing if there is none.
foldl' :: (a → b → a) → a → [b] → a
Like fold, but applies the given function strictly to reduce to weak head normal form at each step.
group :: Eq a => [a] → [[a]]
Group adjacent identical elements into sublists. For example,

group "Mississippi" == ["M","i","ss","i","ss","i","pp","i"]

groupBy :: (a → a → Bool) → [a] → [[a]]
Like group, but using a caller-specified equality test rather than (==).
intercalate :: [a] → [[a]] → [a]
Insert a list of elements between each pair of lists in the second argument. Usually you will use this function when you want to join strings. For example, intercalate ", " ["abc", "def", "ghi"] returns "abc, def, ghi".
intersect :: Eq a => [a] → [a] → [a]
Return an intersection of two sets represented by lists. The result will contain no duplicates unless duplicates were already present in one of the original lists.
isInfixOf :: Eq a => [a] → [a] → Bool
Take two lists and return true if the first list is contained, wholly and intact, anywhere within the second.
isPrefixOf :: Eq a => [a] → [a] → Bool
Take two lists and return true if the first list is a prefix of the second.
isSuffixOf :: Eq a => [a] → [a] → Bool
Take two lists and return true if the first list is a suffix of the second.
maximumBy :: (a → a → Ordering) → [a] → a
Compute the largest element of a list with respect to a comparison function.
minimumBy :: (a → a → Ordering) → [a] → a
Compute the smallest element of a list with respect to a comparison function.
nub :: Eq a => [a] → [a]
Remove duplicate elements from a list. Note that this function runs in O(N2).
partition :: (a → Bool) → [a] → ([a], [a])
Given a predicate and a list, return lists of elements that do and do not satisfy the predicate. In other words,

(partition p list) == (filter p list, filter (\x → not (p x)) list)

sort :: Ord a => [a] → [a]
Sort a list, keeping duplicates.
sortBy :: (a → a → Ordering) → [a] → [a]
Sort elements using a comparison function.
tails :: [a] → [[a]]
Return all final segments of a list. For example,

tails "abc" == ["abc", "bc", "c", ""]

transpose :: [[a]] → [[a]]
Transpose the rows and columns of a list of lists. For example, transpose [[1,2,3],[4,5,6]] returns [[1,4],[2,5],[3,6]].
union :: Eq a => [a] → [a] → [a]
Return a union of two sets represented by lists. The result will contain no duplicates unless duplicates were already present in one of the original lists.

Arrays

Import the Data.Array module to get these functions:

class Ord a => Ix a

A type class for types that can be array indices. Instances of this class include Int, Integer, and various other types.

data Array i e

The type of immutable arrays with indices of type i and elements of type e.
accumArray :: Ix i => (e -> a -> e) -> e -> (i, i) -> [(i, a)] -> Array i e
Build an array from an accumulating function, an intial value, a range of indices and an association list.
array :: Ix i => (i, i) -> [(i, e)] -> Array i e
Build an array from a range of indices and an association list of values.
assocs :: Ix i => Array i e -> [(i, e)]
Return an assocation list of all indices and elements in index order.
elems :: Array i e -> [e]
Return a list of all elements in an array in index order.
listArray :: Ix i => (i, i) -> [e] -> Array i e
Build an array from a range of indices and a list of values.
(!) :: Ix i => Array i e => i -> e
Return the value at a given index in an array.

Input/output

type IO a

An I/O action that returns a value of type a.

getContents :: IO String
Return all input as a single string, which is read lazily as needed.
getLine :: IO String
Read a line from standard input.
print :: Show a => a → IO ()
Print a value of any printable type, followed by a newline.
putStr :: String → IO ()
Write a string to standard output.
putStrLn :: String → IO ()
Write a string to standard output, followed by a newline character.
readLn :: Read a => IO a
Read a line and parse it into a value of any readable type.

Additional I/O-related functions

Import the System.IO module to access these functions:
data BufferMode = NoBuffering | LineBuffering | BlockBuffering
A buffering mode.
hSetBuffering :: Handle -> BufferMode -> IO ()
Set the buffering mode on an I/O stream. The following call will disable buffering on standard output:
      hSetBuffering stdout NoBuffering
That will cause Haskell to automatically flush the output after each call to putStr, so that it will be visible on the terminal before a following call to getLine.

Printf

Import the Text.Printf module to access this function:

printf :: PrintfType r => String → r
Print formatted output. For example:
>>> printf "%s, %d, %.4f" "hello" 123 pi
hello, 123, 3.1416
This version is largely compatible with other implementations of printf, such as in the standard C library. For example, in the format string above, %s represents a string, %d represents a integer and %.4f is a floating-point number rounded to four digits after the decimal point. See the official documentation for more details.

Functor

class Functor f

Instances: [], Maybe, IO, ((->) r)

A functor is a container for a value or, more generally, a value with some kind of context.

fmap :: (a -> b) -> f a -> f b
Apply a function to a functorial value.
(<$>) :: Functor f => (a -> b) -> f a -> f b
An infix synonym for fmap.
If the functor is a monad, f <$> a is the same as
do
    x <- a
    return (f x)

functor functions

(<$) :: a -> f b -> f a
Replace all locations with the same value.
If the functor is a monad, a <$ b is the same as
do
    b
    return a

Applicative

class Applicative f (superclass: Functor)

Instances: [], Maybe, IO, ((->) r)

An applicative is a functor in which a value holding a function can be applied to another value.

pure :: a -> f a
Produce an applicative value.
(<*>) :: f (a -> b) -> f a -> f b
Apply one applicative to another.
If the applicative is a monad, a <*> b is the same as
do
    f <- a
    x <- b
    return (f x)

Monad

class Monad m (superclass: Applicative)

Instances: [], Maybe, IO, ((->) r)

A monad is an abstract datatype of actions.

return :: a -> m a
Produce a monadic value.
(>>=) :: m a -> (a -> m b) -> m b
Compose two actions, passing a value produced by the first as an argument to the second.
a >>= f is the same as
do
    x <- a
    f x
(>>) :: m a -> m b -> m b
Compose two actions, discarding any value produced by the first.
a >> b is the same as
do
    a
    b

monad functions

mapM :: Monad m => (a → m b) → [a] → m [b]
Map a function that returns a monadic value over a list, then combine the results into a single monadic value.
mapM_ :: Monad m => (a → m b) → [a] → m ()
Like mapM, but ignores the resulting values.
sequence :: Monad m => [m a] → m [a]
Combine a list of monadic values into a single monadic value.
sequence [a, b, c] is the same as
do
  x <- a
  y <- b
  z <- c
  return [x, y, z]

Import the Control.Monad module to access these functions:

ap :: Monad m => m (a -> b) -> m a -> m b
Apply two monadic values. (This is generally the same as <*>.)
ap a b is the same as
do
    f <- a
    x <- b
    return (f x)
forM :: Monad m => [a] → (a → m b) → m [b]
Like mapM, but with the arguments flipped.
forM_ :: Monad m => [a] → (a → m b) → m ()
Like mapM_, but with the arguments flipped.
liftM :: Monad m => (a -> b) -> m a -> m b
Apply a function to a monadic value. (This is generally the same as fmap.)
liftM f a is equivalent to
do
  x <- a
  return (f x)
when :: Monad m => Bool → m () → m ()
A conditional for monadic values, useful for I/O actions. Equivalent to
when p v = if p then v else return ()

Reader

Import the Control.Monad.Reader module to access this monad:

type Reader r a

A computation with a readable environment of type r.

ask :: Reader r r
Return the environment.
asks :: (r -> a) -> Reader r a
Return a projection of the current environment.
runReader :: Reader r a -> r -> a
Run a reader computation in the given environment.

State

Import the Control.Monad.State module to access this monad:

type State s a

A stateful computation with a state of type s.

get :: State s s
Return the current state.
gets :: (s -> a) -> State s a
Return a projection of the current state.
put :: s -> State s ()
Replace the state inside the monad.
runState :: State s a -> s -> (a, s)
Run a computation, returning its result and the final state.

Writer

Import the Control.Monad.Writer module to access this monad:

type Writer w a

A computation that can produce output of type w, which must implement the Monoid type class.

runWriter :: Writer w a -> (a, w)
Run a writer computation, returning its result and the collected output.
tell :: w -> Writer w ()
Append to the monad's output.

Paths

type FilePath = String

A FilePath represents a filename.

Import the System.FilePath module to access these functions:

combine :: FilePath → FilePath → FilePath
(</>) :: FilePath → FilePath → FilePath
Combine two paths. The infix operator </> is a synonym for the combine function. For example,
"mydir" </> "myfile.txt"
will produce "mydir/myfile.txt" on Unix or macOS, and "mydir\myfile.txt" on Windows.
takeExtension :: FilePath → String
Return a filename's extension. For example, takeExtension "mydir/myfile.png" will return ".png".

Files

readFile :: FilePath → IO String
Read a file (lazily) and return its contents as a string.
writeFile :: FilePath → String → IO ()
Write a string to a file.

Directories

Import the System.Directory module to access these functions:

doesDirectoryExist :: FilePath → IO Bool
Return True if the given path exists and is a directory (i.e. not a file), otherwise False.
doesFileExist :: FilePath → IO Bool
Return True if the given path exists and is a file (i.e. not a directory), otherwise False.
listDirectory :: FilePath → IO [FilePath]
Return a list of the names of all files and directories in the given directory. (The special directories "." and ".." are not included in the returned list.)

Environment

Import the System.Environment module to access this function:

getArgs :: IO [String]
Return a list of the program's command-line arguments.

Debugging

Import the Debug.Trace module to access this function:

trace :: String → a → a
(trace str x) outputs the given string, then returns x.

Miscellaneous

error :: String → a
Stop execution and display an error message.
seq :: a -> b -> b
Evaluate a to weak head normal form before returning b.