basic-prelude-0.3.0.0: An enhanced core prelude; a common foundation for alternate preludes.

CorePrelude

Synopsis

Standard

Operators

(\$) :: (a -> b) -> a -> b

Application operator. This operator is redundant, since ordinary application `(f x)` means the same as `(f \$ x)`. However, `\$` has low, right-associative binding precedence, so it sometimes allows parentheses to be omitted; for example:

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

It is also useful in higher-order situations, such as `map (\$ 0) xs`, or `zipWith (\$) fs xs`.

(\$!) :: (a -> b) -> a -> b

Strict (call-by-value) application, defined in terms of `seq`.

(&&) :: Bool -> Bool -> Bool

Boolean "and"

(||) :: Bool -> Bool -> Bool

Boolean "or"

(.) :: Category cat => forall b c a. cat b c -> cat a b -> cat a c

morphism composition

Functions

not :: Bool -> Bool

Boolean "not"

`otherwise` is defined as the value `True`. It helps to make guards more readable. eg.

```  f x | x < 0     = ...
| otherwise = ...
```

fst :: (a, b) -> a

Extract the first component of a pair.

snd :: (a, b) -> b

Extract the second component of a pair.

id :: Category cat => forall a. cat a a

the identity morphism

maybe :: b -> (a -> b) -> Maybe a -> b

The `maybe` function takes a default value, a function, and a `Maybe` value. If the `Maybe` value is `Nothing`, the function returns the default value. Otherwise, it applies the function to the value inside the `Just` and returns the result.

either :: (a -> c) -> (b -> c) -> Either a b -> c

Case analysis for the `Either` type. If the value is `Left a`, apply the first function to `a`; if it is `Right b`, apply the second function to `b`.

flip :: (a -> b -> c) -> b -> a -> c

`flip f` takes its (first) two arguments in the reverse order of `f`.

const :: a -> b -> a

Constant function.

error :: [Char] -> a

`error` stops execution and displays an error message.

putStrLn :: Text -> IO ()

Write a string to `stdout`, followed by a newline.

odd :: Integral a => a -> Bool

even :: Integral a => a -> Bool

uncurry :: (a -> b -> c) -> (a, b) -> c

`uncurry` converts a curried function to a function on pairs.

curry :: ((a, b) -> c) -> a -> b -> c

`curry` converts an uncurried function to a curried function.

swap :: (a, b) -> (b, a)

Swap the components of a pair.

until :: (a -> Bool) -> (a -> a) -> a -> a

`until p f` yields the result of applying `f` until `p` holds.

asTypeOf :: a -> a -> a

`asTypeOf` is a type-restricted version of `const`. It is usually used as an infix operator, and its typing forces its first argument (which is usually overloaded) to have the same type as the second.

undefined :: a

A special case of `error`. It is expected that compilers will recognize this and insert error messages which are more appropriate to the context in which `undefined` appears.

seq :: a -> b -> b

Evaluates its first argument to head normal form, and then returns its second argument as the result.

Type classes

class Eq a => Ord a where

The `Ord` class is used for totally ordered datatypes.

Instances of `Ord` can be derived for any user-defined datatype whose constituent types are in `Ord`. The declared order of the constructors in the data declaration determines the ordering in derived `Ord` instances. The `Ordering` datatype allows a single comparison to determine the precise ordering of two objects.

Minimal complete definition: either `compare` or `<=`. Using `compare` can be more efficient for complex types.

Methods

compare :: a -> a -> Ordering

(<) :: a -> a -> Bool

(>=) :: a -> a -> Bool

(>) :: a -> a -> Bool

(<=) :: a -> a -> Bool

max :: a -> a -> a

min :: a -> a -> a

Instances

 Ord Bool Ord Char Ord Double Ord Float Ord Int Ord Int8 Ord Int16 Ord Int32 Ord Int64 Ord Integer Ord Ordering Ord Word Ord Word8 Ord Word16 Ord Word32 Ord Word64 Ord () Ord AsyncException Ord ArrayException Ord ExitCode Ord All Ord Any Ord ArithException Ord TypeRep Ord TyCon Ord ByteString Ord ByteString Ord Arity Ord Fixity Ord Associativity Ord Text Ord Root Ord FilePath Ord Text Ord a => Ord [a] Integral a => Ord (Ratio a) Ord a => Ord (Dual a) Ord a => Ord (Sum a) Ord a => Ord (Product a) Ord a => Ord (First a) Ord a => Ord (Last a) Ord a => Ord (Maybe a) Ord a => Ord (Set a) Ord a => Ord (Vector a) (Unbox a, Ord a) => Ord (Vector a) (Prim a, Ord a) => Ord (Vector a) (Ord a, Ord b) => Ord (Either a b) (Ord a, Ord b) => Ord (a, b) (Ord k, Ord v) => Ord (Map k v) Ord a => Ord (Stream Id a) (Ord a, Ord b, Ord c) => Ord (a, b, c) (Ord a, Ord b, Ord c, Ord d) => Ord (a, b, c, d) (Ord a, Ord b, Ord c, Ord d, Ord e) => Ord (a, b, c, d, e) (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f) => Ord (a, b, c, d, e, f) (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g) => Ord (a, b, c, d, e, f, g) (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h) => Ord (a, b, c, d, e, f, g, h) (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i) => Ord (a, b, c, d, e, f, g, h, i) (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j) => Ord (a, b, c, d, e, f, g, h, i, j) (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k) => Ord (a, b, c, d, e, f, g, h, i, j, k) (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l) => Ord (a, b, c, d, e, f, g, h, i, j, k, l) (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m) (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n) (Ord a, Ord b, Ord c, Ord d, Ord e, Ord f, Ord g, Ord h, Ord i, Ord j, Ord k, Ord l, Ord m, Ord n, Ord o) => Ord (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

class Eq a where

The `Eq` class defines equality (`==`) and inequality (`/=`). All the basic datatypes exported by the Prelude are instances of `Eq`, and `Eq` may be derived for any datatype whose constituents are also instances of `Eq`.

Minimal complete definition: either `==` or `/=`.

Methods

(==) :: a -> a -> Bool

(/=) :: a -> a -> Bool

Instances

 Eq Bool Eq Char Eq Double Eq Float Eq Int Eq Int8 Eq Int16 Eq Int32 Eq Int64 Eq Integer Eq Ordering Eq Word Eq Word8 Eq Word16 Eq Word32 Eq Word64 Eq () Eq AsyncException Eq ArrayException Eq ExitCode Eq IOErrorType Eq All Eq Any Eq MaskingState Eq IOException Eq ArithException Eq TypeRep Eq TyCon Eq ByteString Eq ByteString Eq Arity Eq Fixity Eq Associativity Eq Text Eq Root Eq FilePath Eq Text Eq a => Eq [a] Eq a => Eq (Ratio a) Eq a => Eq (Dual a) Eq a => Eq (Sum a) Eq a => Eq (Product a) Eq a => Eq (First a) Eq a => Eq (Last a) Eq a => Eq (Maybe a) Eq a => Eq (Set a) (Hashable a, Eq a) => Eq (HashSet a) Eq a => Eq (Vector a) (Unbox a, Eq a) => Eq (Vector a) (Prim a, Eq a) => Eq (Vector a) (Eq a, Eq b) => Eq (Either a b) (Eq a, Eq b) => Eq (a, b) (Eq k, Eq a) => Eq (Map k a) (Eq k, Eq v) => Eq (Leaf k v) (Eq k, Eq v) => Eq (HashMap k v) Eq a => Eq (Stream Id a) (Eq a, Eq b, Eq c) => Eq (a, b, c) (Eq a, Eq b, Eq c, Eq d) => Eq (a, b, c, d) (Eq a, Eq b, Eq c, Eq d, Eq e) => Eq (a, b, c, d, e) (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f) => Eq (a, b, c, d, e, f) (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g) => Eq (a, b, c, d, e, f, g) (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h) => Eq (a, b, c, d, e, f, g, h) (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i) => Eq (a, b, c, d, e, f, g, h, i) (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j) => Eq (a, b, c, d, e, f, g, h, i, j) (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k) => Eq (a, b, c, d, e, f, g, h, i, j, k) (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l) => Eq (a, b, c, d, e, f, g, h, i, j, k, l) (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m) (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n) (Eq a, Eq b, Eq c, Eq d, Eq e, Eq f, Eq g, Eq h, Eq i, Eq j, Eq k, Eq l, Eq m, Eq n, Eq o) => Eq (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

class Bounded a where

The `Bounded` class is used to name the upper and lower limits of a type. `Ord` is not a superclass of `Bounded` since types that are not totally ordered may also have upper and lower bounds.

The `Bounded` class may be derived for any enumeration type; `minBound` is the first constructor listed in the `data` declaration and `maxBound` is the last. `Bounded` may also be derived for single-constructor datatypes whose constituent types are in `Bounded`.

Methods

minBound :: a

maxBound :: a

Instances

 Bounded Bool Bounded Char Bounded Int Bounded Int8 Bounded Int16 Bounded Int32 Bounded Int64 Bounded Ordering Bounded Word Bounded Word8 Bounded Word16 Bounded Word32 Bounded Word64 Bounded () Bounded All Bounded Any Bounded a => Bounded (Dual a) Bounded a => Bounded (Sum a) Bounded a => Bounded (Product a) (Bounded a, Bounded b) => Bounded (a, b) (Bounded a, Bounded b, Bounded c) => Bounded (a, b, c) (Bounded a, Bounded b, Bounded c, Bounded d) => Bounded (a, b, c, d) (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e) => Bounded (a, b, c, d, e) (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f) => Bounded (a, b, c, d, e, f) (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g) => Bounded (a, b, c, d, e, f, g) (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h) => Bounded (a, b, c, d, e, f, g, h) (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i) => Bounded (a, b, c, d, e, f, g, h, i) (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j) => Bounded (a, b, c, d, e, f, g, h, i, j) (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k) => Bounded (a, b, c, d, e, f, g, h, i, j, k) (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l) (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m) (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n) (Bounded a, Bounded b, Bounded c, Bounded d, Bounded e, Bounded f, Bounded g, Bounded h, Bounded i, Bounded j, Bounded k, Bounded l, Bounded m, Bounded n, Bounded o) => Bounded (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

class Enum a where

Class `Enum` defines operations on sequentially ordered types.

The `enumFrom`... methods are used in Haskell's translation of arithmetic sequences.

Instances of `Enum` may be derived for any enumeration type (types whose constructors have no fields). The nullary constructors are assumed to be numbered left-to-right by `fromEnum` from `0` through `n-1`. See Chapter 10 of the Haskell Report for more details.

For any type that is an instance of class `Bounded` as well as `Enum`, the following should hold:

• The calls `succ maxBound` and `pred minBound` should result in a runtime error.
• `fromEnum` and `toEnum` should give a runtime error if the result value is not representable in the result type. For example, `toEnum 7 :: Bool` is an error.
• `enumFrom` and `enumFromThen` should be defined with an implicit bound, thus:
```    enumFrom     x   = enumFromTo     x maxBound
enumFromThen x y = enumFromThenTo x y bound
where
| otherwise                = minBound
```

Methods

succ :: a -> a

the successor of a value. For numeric types, `succ` adds 1.

pred :: a -> a

the predecessor of a value. For numeric types, `pred` subtracts 1.

toEnum :: Int -> a

Convert from an `Int`.

Convert to an `Int`. It is implementation-dependent what `fromEnum` returns when applied to a value that is too large to fit in an `Int`.

enumFrom :: a -> [a]

Used in Haskell's translation of `[n..]`.

enumFromThen :: a -> a -> [a]

Used in Haskell's translation of `[n,n'..]`.

enumFromTo :: a -> a -> [a]

Used in Haskell's translation of `[n..m]`.

enumFromThenTo :: a -> a -> a -> [a]

Used in Haskell's translation of `[n,n'..m]`.

Instances

 Enum Bool Enum Char Enum Double Enum Float Enum Int Enum Int8 Enum Int16 Enum Int32 Enum Int64 Enum Integer Enum Ordering Enum Word Enum Word8 Enum Word16 Enum Word32 Enum Word64 Enum () Integral a => Enum (Ratio a)

class Show a

Conversion of values to readable `String`s.

Minimal complete definition: `showsPrec` or `show`.

Derived instances of `Show` have the following properties, which are compatible with derived instances of `Read`:

• The result of `show` is a syntactically correct Haskell expression containing only constants, given the fixity declarations in force at the point where the type is declared. It contains only the constructor names defined in the data type, parentheses, and spaces. When labelled constructor fields are used, braces, commas, field names, and equal signs are also used.
• If the constructor is defined to be an infix operator, then `showsPrec` will produce infix applications of the constructor.
• the representation will be enclosed in parentheses if the precedence of the top-level constructor in `x` is less than `d` (associativity is ignored). Thus, if `d` is `0` then the result is never surrounded in parentheses; if `d` is `11` it is always surrounded in parentheses, unless it is an atomic expression.
• If the constructor is defined using record syntax, then `show` will produce the record-syntax form, with the fields given in the same order as the original declaration.

For example, given the declarations

``` infixr 5 :^:
data Tree a =  Leaf a  |  Tree a :^: Tree a
```

the derived instance of `Show` is equivalent to

``` instance (Show a) => Show (Tree a) where

showsPrec d (Leaf m) = showParen (d > app_prec) \$
showString "Leaf " . showsPrec (app_prec+1) m
where app_prec = 10

showsPrec d (u :^: v) = showParen (d > up_prec) \$
showsPrec (up_prec+1) u .
showString " :^: "      .
showsPrec (up_prec+1) v
where up_prec = 5
```

Note that right-associativity of `:^:` is ignored. For example,

• `show (Leaf 1 :^: Leaf 2 :^: Leaf 3)` produces the string `"Leaf 1 :^: (Leaf 2 :^: Leaf 3)"`.

Instances

 Show Bool Show Char Show Double Show Float Show Int Show Int8 Show Int16 Show Int32 Show Int64 Show Integer Show Ordering Show Word Show Word8 Show Word16 Show Word32 Show Word64 Show () Show BlockedIndefinitelyOnMVar Show BlockedIndefinitelyOnSTM Show Deadlock Show AssertionFailed Show AsyncException Show ArrayException Show ExitCode Show IOErrorType Show All Show Any Show MaskingState Show IOException Show SomeException Show ErrorCall Show ArithException Show TypeRep Show TyCon Show ByteString Show ByteString Show Arity Show Fixity Show Associativity Show Text Show FilePath Show Text Show a => Show [a] (Integral a, Show a) => Show (Ratio a) Show a => Show (Dual a) Show a => Show (Sum a) Show a => Show (Product a) Show a => Show (First a) Show a => Show (Last a) Show a => Show (Maybe a) Show a => Show (Set a) Show (Rules a) Show a => Show (HashSet a) Show a => Show (Vector a) (Show a, Unbox a) => Show (Vector a) (Show a, Prim a) => Show (Vector a) (Show a, Show b) => Show (Either a b) (Show a, Show b) => Show (a, b) (Show k, Show a) => Show (Map k a) (Show k, Show v) => Show (HashMap k v) (Show a, Show b, Show c) => Show (a, b, c) (Show a, Show b, Show c, Show d) => Show (a, b, c, d) (Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e) (Show a, Show b, Show c, Show d, Show e, Show f) => Show (a, b, c, d, e, f) (Show a, Show b, Show c, Show d, Show e, Show f, Show g) => Show (a, b, c, d, e, f, g) (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h) => Show (a, b, c, d, e, f, g, h) (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i) => Show (a, b, c, d, e, f, g, h, i) (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j) => Show (a, b, c, d, e, f, g, h, i, j) (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k) => Show (a, b, c, d, e, f, g, h, i, j, k) (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l) => Show (a, b, c, d, e, f, g, h, i, j, k, l) (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m) (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n) (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k, Show l, Show m, Show n, Show o) => Show (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Parsing of `String`s, producing values.

Minimal complete definition: `readsPrec` (or, for GHC only, `readPrec`)

Derived instances of `Read` make the following assumptions, which derived instances of `Show` obey:

• If the constructor is defined to be an infix operator, then the derived `Read` instance will parse only infix applications of the constructor (not the prefix form).
• Associativity is not used to reduce the occurrence of parentheses, although precedence may be.
• If the constructor is defined using record syntax, the derived `Read` will parse only the record-syntax form, and furthermore, the fields must be given in the same order as the original declaration.
• The derived `Read` instance allows arbitrary Haskell whitespace between tokens of the input string. Extra parentheses are also allowed.

For example, given the declarations

``` infixr 5 :^:
data Tree a =  Leaf a  |  Tree a :^: Tree a
```

the derived instance of `Read` in Haskell 98 is equivalent to

``` instance (Read a) => Read (Tree a) where

(\r -> [(Leaf m,t) |
("Leaf",s) <- lex r,
(m,t) <- readsPrec (app_prec+1) s]) r

(\r -> [(u:^:v,w) |
(":^:",t) <- lex s,
(v,w) <- readsPrec (up_prec+1) t]) r

where app_prec = 10
up_prec = 5
```

Note that right-associativity of `:^:` is unused.

The derived instance in GHC is equivalent to

``` instance (Read a) => Read (Tree a) where

readPrec = parens \$ (prec app_prec \$ do
Ident "Leaf" <- lexP
return (Leaf m))

+++ (prec up_prec \$ do
Symbol ":^:" <- lexP
return (u :^: v))

where app_prec = 10
up_prec = 5

```

Instances

class Functor f where

The `Functor` class is used for types that can be mapped over. Instances of `Functor` should satisfy the following laws:

``` fmap id  ==  id
fmap (f . g)  ==  fmap f . fmap g
```

The instances of `Functor` for lists, `Maybe` and `IO` satisfy these laws.

Methods

fmap :: (a -> b) -> f a -> f b

(<\$) :: a -> f b -> f a

Replace all locations in the input with the same value. The default definition is `fmap . const`, but this may be overridden with a more efficient version.

Instances

 Functor [] Functor IO Functor ZipList Functor ReadP Functor Maybe Functor Vector Functor ((->) r) Functor (Either a) Functor ((,) a) Functor (Const m) Monad m => Functor (WrappedMonad m) Functor (Map k) Functor (HashMap k) Arrow a => Functor (WrappedArrow a b)

The `Monad` class defines the basic operations over a monad, a concept from a branch of mathematics known as category theory. From the perspective of a Haskell programmer, however, it is best to think of a monad as an abstract datatype of actions. Haskell's `do` expressions provide a convenient syntax for writing monadic expressions.

Minimal complete definition: `>>=` and `return`.

Instances of `Monad` should satisfy the following laws:

``` return a >>= k  ==  k a
m >>= return  ==  m
m >>= (\x -> k x >>= h)  ==  (m >>= k) >>= h
```

Instances of both `Monad` and `Functor` should additionally satisfy the law:

``` fmap f xs  ==  xs >>= return . f
```

The instances of `Monad` for lists, `Maybe` and `IO` defined in the Prelude satisfy these laws.

Methods

(>>=) :: m a -> (a -> m b) -> m b

Sequentially compose two actions, passing any value produced by the first as an argument to the second.

(>>) :: m a -> m b -> m b

Sequentially compose two actions, discarding any value produced by the first, like sequencing operators (such as the semicolon) in imperative languages.

return :: a -> m a

Inject a value into the monadic type.

fail :: String -> m a

Fail with a message. This operation is not part of the mathematical definition of a monad, but is invoked on pattern-match failure in a `do` expression.

Instances

(=<<) :: Monad m => (a -> m b) -> m a -> m b

Same as `>>=`, but with the arguments interchanged.

Numeric type classes

class Num a where

Basic numeric class.

Minimal complete definition: all except `negate` or `(-)`

Methods

(+) :: a -> a -> a

(*) :: a -> a -> a

(-) :: a -> a -> a

negate :: a -> a

Unary negation.

abs :: a -> a

Absolute value.

signum :: a -> a

Sign of a number. The functions `abs` and `signum` should satisfy the law:

``` abs x * signum x == x
```

For real numbers, the `signum` is either `-1` (negative), `0` (zero) or `1` (positive).

fromInteger :: Integer -> a

Conversion from an `Integer`. An integer literal represents the application of the function `fromInteger` to the appropriate value of type `Integer`, so such literals have type `(Num a) => a`.

Instances

 Num Double Num Float Num Int Num Int8 Num Int16 Num Int32 Num Int64 Num Integer Num Word Num Word8 Num Word16 Num Word32 Num Word64 Integral a => Num (Ratio a)

class (Num a, Ord a) => Real a where

Methods

toRational :: a -> Rational

the rational equivalent of its real argument with full precision

Instances

 Real Double Real Float Real Int Real Int8 Real Int16 Real Int32 Real Int64 Real Integer Real Word Real Word8 Real Word16 Real Word32 Real Word64 Integral a => Real (Ratio a)

class (Real a, Enum a) => Integral a where

Integral numbers, supporting integer division.

Minimal complete definition: `quotRem` and `toInteger`

Methods

quot :: a -> a -> a

integer division truncated toward zero

rem :: a -> a -> a

integer remainder, satisfying

``` (x `quot` y)*y + (x `rem` y) == x
```

div :: a -> a -> a

integer division truncated toward negative infinity

mod :: a -> a -> a

integer modulus, satisfying

``` (x `div` y)*y + (x `mod` y) == x
```

quotRem :: a -> a -> (a, a)

simultaneous `quot` and `rem`

divMod :: a -> a -> (a, a)

simultaneous `div` and `mod`

toInteger :: a -> Integer

conversion to `Integer`

class Num a => Fractional a where

Fractional numbers, supporting real division.

Minimal complete definition: `fromRational` and (`recip` or `(/)`)

Methods

(/) :: a -> a -> a

fractional division

recip :: a -> a

reciprocal fraction

fromRational :: Rational -> a

Conversion from a `Rational` (that is `Ratio Integer`). A floating literal stands for an application of `fromRational` to a value of type `Rational`, so such literals have type `(Fractional a) => a`.

Instances

 Fractional Double Fractional Float Integral a => Fractional (Ratio a)

class Fractional a => Floating a where

Trigonometric and hyperbolic functions and related functions.

Minimal complete definition: `pi`, `exp`, `log`, `sin`, `cos`, `sinh`, `cosh`, `asin`, `acos`, `atan`, `asinh`, `acosh` and `atanh`

Methods

pi :: a

exp :: a -> a

sqrt :: a -> a

log :: a -> a

(**) :: a -> a -> a

logBase :: a -> a -> a

sin :: a -> a

tan :: a -> a

cos :: a -> a

asin :: a -> a

atan :: a -> a

acos :: a -> a

sinh :: a -> a

tanh :: a -> a

cosh :: a -> a

asinh :: a -> a

atanh :: a -> a

acosh :: a -> a

Instances

 Floating Double Floating Float

class (Real a, Fractional a) => RealFrac a where

Extracting components of fractions.

Minimal complete definition: `properFraction`

Methods

properFraction :: Integral b => a -> (b, a)

The function `properFraction` takes a real fractional number `x` and returns a pair `(n,f)` such that `x = n+f`, and:

• `n` is an integral number with the same sign as `x`; and
• `f` is a fraction with the same type and sign as `x`, and with absolute value less than `1`.

The default definitions of the `ceiling`, `floor`, `truncate` and `round` functions are in terms of `properFraction`.

truncate :: Integral b => a -> b

`truncate x` returns the integer nearest `x` between zero and `x`

round :: Integral b => a -> b

`round x` returns the nearest integer to `x`; the even integer if `x` is equidistant between two integers

ceiling :: Integral b => a -> b

`ceiling x` returns the least integer not less than `x`

floor :: Integral b => a -> b

`floor x` returns the greatest integer not greater than `x`

Instances

 RealFrac Double RealFrac Float Integral a => RealFrac (Ratio a)

class (RealFrac a, Floating a) => RealFloat a where

Minimal complete definition: all except `exponent`, `significand`, `scaleFloat` and `atan2`

Methods

a constant function, returning the radix of the representation (often `2`)

floatDigits :: a -> Int

a constant function, returning the number of digits of `floatRadix` in the significand

floatRange :: a -> (Int, Int)

a constant function, returning the lowest and highest values the exponent may assume

decodeFloat :: a -> (Integer, Int)

The function `decodeFloat` applied to a real floating-point number returns the significand expressed as an `Integer` and an appropriately scaled exponent (an `Int`). If `decodeFloat x` yields `(m,n)`, then `x` is equal in value to `m*b^^n`, where `b` is the floating-point radix, and furthermore, either `m` and `n` are both zero or else `b^(d-1) <= abs m < b^d`, where `d` is the value of `floatDigits x`. In particular, `decodeFloat 0 = (0,0)`. If the type contains a negative zero, also `decodeFloat (-0.0) = (0,0)`. The result of `decodeFloat x` is unspecified if either of `isNaN x` or `isInfinite x` is `True`.

encodeFloat :: Integer -> Int -> a

`encodeFloat` performs the inverse of `decodeFloat` in the sense that for finite `x` with the exception of `-0.0`, `uncurry encodeFloat (decodeFloat x) = x`. `encodeFloat m n` is one of the two closest representable floating-point numbers to `m*b^^n` (or `±Infinity` if overflow occurs); usually the closer, but if `m` contains too many bits, the result may be rounded in the wrong direction.

exponent :: a -> Int

`exponent` corresponds to the second component of `decodeFloat`. `exponent 0 = 0` and for finite nonzero `x`, `exponent x = snd (decodeFloat x) + floatDigits x`. If `x` is a finite floating-point number, it is equal in value to `significand x * b ^^ exponent x`, where `b` is the floating-point radix. The behaviour is unspecified on infinite or `NaN` values.

significand :: a -> a

The first component of `decodeFloat`, scaled to lie in the open interval (`-1`,`1`), either `0.0` or of absolute value `>= 1/b`, where `b` is the floating-point radix. The behaviour is unspecified on infinite or `NaN` values.

scaleFloat :: Int -> a -> a

multiplies a floating-point number by an integer power of the radix

isNaN :: a -> Bool

`True` if the argument is an IEEE "not-a-number" (NaN) value

isInfinite :: a -> Bool

`True` if the argument is an IEEE infinity or negative infinity

isDenormalized :: a -> Bool

`True` if the argument is too small to be represented in normalized format

isNegativeZero :: a -> Bool

`True` if the argument is an IEEE negative zero

isIEEE :: a -> Bool

`True` if the argument is an IEEE floating point number

atan2 :: a -> a -> a

a version of arctangent taking two real floating-point arguments. For real floating `x` and `y`, `atan2 y x` computes the angle (from the positive x-axis) of the vector from the origin to the point `(x,y)`. `atan2 y x` returns a value in the range [`-pi`, `pi`]. It follows the Common Lisp semantics for the origin when signed zeroes are supported. `atan2 y 1`, with `y` in a type that is `RealFloat`, should return the same value as `atan y`. A default definition of `atan2` is provided, but implementors can provide a more accurate implementation.

Instances

 RealFloat Double RealFloat Float

Data types

data Maybe a

The `Maybe` type encapsulates an optional value. A value of type `Maybe a` either contains a value of type `a` (represented as `Just a`), or it is empty (represented as `Nothing`). Using `Maybe` is a good way to deal with errors or exceptional cases without resorting to drastic measures such as `error`.

The `Maybe` type is also a monad. It is a simple kind of error monad, where all errors are represented by `Nothing`. A richer error monad can be built using the `Either` type.

Constructors

 Nothing Just a

Instances

 Monad Maybe Functor Maybe Typeable1 Maybe MonadPlus Maybe Applicative Maybe Alternative Maybe Eq a => Eq (Maybe a) Ord a => Ord (Maybe a) Read a => Read (Maybe a) Show a => Show (Maybe a) Generic (Maybe a) Monoid a => Monoid (Maybe a) Lift a semigroup into `Maybe` forming a `Monoid` according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup `S` may be turned into a monoid simply by adjoining an element `e` not in `S` and defining `e*e = e` and `e*s = s = s*e` for all `s ∈ S`." Since there is no "Semigroup" typeclass providing just `mappend`, we use `Monoid` instead. Hashable a => Hashable (Maybe a)

data Ordering

Constructors

 LT EQ GT

data Bool

Constructors

 False True

Instances

 Bounded Bool Enum Bool Eq Bool Ord Bool Read Bool Show Bool Typeable Bool Generic Bool Hashable Bool Unbox Bool Vector Vector Bool MVector MVector Bool

data Char

The character type `Char` is an enumeration whose values represent Unicode (or equivalently ISO/IEC 10646) characters (see http://www.unicode.org/ for details). This set extends the ISO 8859-1 (Latin-1) character set (the first 256 characters), which is itself an extension of the ASCII character set (the first 128 characters). A character literal in Haskell has type `Char`.

To convert a `Char` to or from the corresponding `Int` value defined by Unicode, use `toEnum` and `fromEnum` from the `Enum` class respectively (or equivalently `ord` and `chr`).

Instances

 Bounded Char Enum Char Eq Char Ord Char Read Char Show Char Typeable Char Generic Char Hashable Char Unbox Char Vector Vector Char MVector MVector Char

data IO a

A value of type `IO a` is a computation which, when performed, does some I/O before returning a value of type `a`.

There is really only one way to "perform" an I/O action: bind it to `Main.main` in your program. When your program is run, the I/O will be performed. It isn't possible to perform I/O from an arbitrary function, unless that function is itself in the `IO` monad and called at some point, directly or indirectly, from `Main.main`.

`IO` is a monad, so `IO` actions can be combined using either the do-notation or the `>>` and `>>=` operations from the `Monad` class.

Instances

data Either a b

The `Either` type represents values with two possibilities: a value of type `Either a b` is either `Left a` or `Right b`.

The `Either` type is sometimes used to represent a value which is either correct or an error; by convention, the `Left` constructor is used to hold an error value and the `Right` constructor is used to hold a correct value (mnemonic: "right" also means "correct").

Constructors

 Left a Right b

Instances

 Typeable2 Either Monad (Either e) Functor (Either a) Applicative (Either e) (Eq a, Eq b) => Eq (Either a b) (Ord a, Ord b) => Ord (Either a b) (Read a, Read b) => Read (Either a b) (Show a, Show b) => Show (Either a b) Generic (Either a b) (Hashable a, Hashable b) => Hashable (Either a b)

Re-exports

Packed reps

data ByteString

A space-efficient representation of a Word8 vector, supporting many efficient operations. A `ByteString` contains 8-bit characters only.

Instances of Eq, Ord, Read, Show, Data, Typeable

data Text

A space efficient, packed, unboxed Unicode text type.

Instances

 Eq Text Data Text Ord Text Read Text Show Text Typeable Text IsString Text Monoid Text NFData Text Hashable Text

Containers

data Map k a

A Map from keys `k` to values `a`.

Instances

 Typeable2 Map Functor (Map k) Foldable (Map k) Traversable (Map k) (Eq k, Eq a) => Eq (Map k a) (Data k, Data a, Ord k) => Data (Map k a) (Ord k, Ord v) => Ord (Map k v) (Ord k, Read k, Read e) => Read (Map k e) (Show k, Show a) => Show (Map k a) Ord k => Monoid (Map k v) (NFData k, NFData a) => NFData (Map k a)

data HashMap k v

A map from keys to values. A map cannot contain duplicate keys; each key can map to at most one value.

Instances

 Typeable2 HashMap Functor (HashMap k) Foldable (HashMap k) Traversable (HashMap k) (Eq k, Eq v) => Eq (HashMap k v) (Show k, Show v) => Show (HashMap k v) (Eq k, Hashable k) => Monoid (HashMap k v) (NFData k, NFData v) => NFData (HashMap k v)

data Set a

A set of values `a`.

Instances

 Typeable1 Set Foldable Set Eq a => Eq (Set a) (Data a, Ord a) => Data (Set a) Ord a => Ord (Set a) (Read a, Ord a) => Read (Set a) Show a => Show (Set a) Ord a => Monoid (Set a) NFData a => NFData (Set a)

data HashSet a

A set of values. A set cannot contain duplicate values.

Instances

 Foldable HashSet (Hashable a, Eq a) => Eq (HashSet a) Show a => Show (HashSet a) (Hashable a, Eq a) => Monoid (HashSet a) NFData a => NFData (HashSet a)

data Vector a

Boxed vectors, supporting efficient slicing.

Instances

 Monad Vector Functor Vector Typeable1 Vector MonadPlus Vector Applicative Vector Foldable Vector Traversable Vector Alternative Vector Vector Vector a Eq a => Eq (Vector a) Data a => Data (Vector a) Ord a => Ord (Vector a) Read a => Read (Vector a) Show a => Show (Vector a) Monoid (Vector a)

class (Vector Vector a, MVector MVector a) => Unbox a

Instances

 Unbox Bool Unbox Char Unbox Double Unbox Float Unbox Int Unbox Int8 Unbox Int16 Unbox Int32 Unbox Int64 Unbox Word Unbox Word8 Unbox Word16 Unbox Word32 Unbox Word64 Unbox () (RealFloat a, Unbox a) => Unbox (Complex a) (Unbox a, Unbox b) => Unbox (a, b) (Unbox a, Unbox b, Unbox c) => Unbox (a, b, c) (Unbox a, Unbox b, Unbox c, Unbox d) => Unbox (a, b, c, d) (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e) => Unbox (a, b, c, d, e) (Unbox a, Unbox b, Unbox c, Unbox d, Unbox e, Unbox f) => Unbox (a, b, c, d, e, f)

class Hashable a

The class of types that can be converted to a hash value.

Minimal implementation: `hash` or `hashWithSalt`.

Instances

 Hashable Bool Hashable Char Hashable Double Hashable Float Hashable Int Hashable Int8 Hashable Int16 Hashable Int32 Hashable Int64 Hashable Integer Hashable Word Hashable Word8 Hashable Word16 Hashable Word32 Hashable Word64 Hashable () Hashable ThreadId Hashable TypeRep Hashable ByteString Hashable ByteString Hashable Text Hashable Text Hashable a => Hashable [a] (Integral a, Hashable a) => Hashable (Ratio a) Hashable (StableName a) Hashable a => Hashable (Maybe a) (Hashable a, Hashable b) => Hashable (Either a b) (Hashable a1, Hashable a2) => Hashable (a1, a2) (Hashable a1, Hashable a2, Hashable a3) => Hashable (a1, a2, a3) (Hashable a1, Hashable a2, Hashable a3, Hashable a4) => Hashable (a1, a2, a3, a4) (Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5) => Hashable (a1, a2, a3, a4, a5) (Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5, Hashable a6) => Hashable (a1, a2, a3, a4, a5, a6) (Hashable a1, Hashable a2, Hashable a3, Hashable a4, Hashable a5, Hashable a6, Hashable a7) => Hashable (a1, a2, a3, a4, a5, a6, a7)

Numbers

data Word

A `Word` is an unsigned integral type, with the same size as `Int`.

Instances

 Bounded Word Enum Word Eq Word Integral Word Num Word Ord Word Read Word Real Word Show Word Ix Word Typeable Word Bits Word Hashable Word Unbox Word Vector Vector Word MVector MVector Word

data Word8

8-bit unsigned integer type

data Word32

32-bit unsigned integer type

data Word64

64-bit unsigned integer type

data Int

A fixed-precision integer type with at least the range `[-2^29 .. 2^29-1]`. The exact range for a given implementation can be determined by using `minBound` and `maxBound` from the `Bounded` class.

Instances

 Bounded Int Enum Int Eq Int Integral Int Num Int Ord Int Read Int Real Int Show Int Typeable Int Generic Int Hashable Int Unbox Int Vector Vector Int MVector MVector Int

data Int32

32-bit signed integer type

data Int64

64-bit signed integer type

data Integer

Arbitrary-precision integers.

type Rational = Ratio Integer

Arbitrary-precision rational numbers, represented as a ratio of two `Integer` values. A rational number may be constructed using the `%` operator.

data Float

Single-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE single-precision type.

data Double

Double-precision floating point numbers. It is desirable that this type be at least equal in range and precision to the IEEE double-precision type.

Numeric functions

(^) :: (Num a, Integral b) => a -> b -> a

raise a number to a non-negative integral power

(^^) :: (Fractional a, Integral b) => a -> b -> a

raise a number to an integral power

subtract :: Num a => a -> a -> a

the same as `flip (-)`.

Because `-` is treated specially in the Haskell grammar, `(-` e`)` is not a section, but an application of prefix negation. However, `(subtract` exp`)` is equivalent to the disallowed section.

fromIntegral :: (Integral a, Num b) => a -> b

general coercion from integral types

realToFrac :: (Real a, Fractional b) => a -> b

general coercion to fractional types

Monoids

class Monoid a where

The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following laws:

• `mappend mempty x = x`
• `mappend x mempty = x`
• `mappend x (mappend y z) = mappend (mappend x y) z`
• `mconcat = `foldr` mappend mempty`

The method names refer to the monoid of lists under concatenation, but there are many other instances.

Minimal complete definition: `mempty` and `mappend`.

Some types can be viewed as a monoid in more than one way, e.g. both addition and multiplication on numbers. In such cases we often define `newtype`s and make those instances of `Monoid`, e.g. `Sum` and `Product`.

Methods

mempty :: a

Identity of `mappend`

mappend :: a -> a -> a

An associative operation

mconcat :: [a] -> a

Fold a list using the monoid. For most types, the default definition for `mconcat` will be used, but the function is included in the class definition so that an optimized version can be provided for specific types.

Instances

 Monoid Ordering Monoid () Monoid All Monoid Any Monoid ByteString Monoid ByteString Monoid Text Monoid FilePath Monoid Text Monoid [a] Monoid a => Monoid (Dual a) Monoid (Endo a) Num a => Monoid (Sum a) Num a => Monoid (Product a) Monoid (First a) Monoid (Last a) Monoid a => Monoid (Maybe a) Lift a semigroup into `Maybe` forming a `Monoid` according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup `S` may be turned into a monoid simply by adjoining an element `e` not in `S` and defining `e*e = e` and `e*s = s = s*e` for all `s ∈ S`." Since there is no "Semigroup" typeclass providing just `mappend`, we use `Monoid` instead. Ord a => Monoid (Set a) (Hashable a, Eq a) => Monoid (HashSet a) Monoid (Vector a) Unbox a => Monoid (Vector a) Prim a => Monoid (Vector a) Monoid b => Monoid (a -> b) (Monoid a, Monoid b) => Monoid (a, b) Ord k => Monoid (Map k v) (Eq k, Hashable k) => Monoid (HashMap k v) (Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) (Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d) (Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e)

(<>) :: Monoid m => m -> m -> m

An infix synonym for `mappend`.

Arrow

first :: Arrow a => forall b c d. a b c -> a (b, d) (c, d)

Send the first component of the input through the argument arrow, and copy the rest unchanged to the output.

second :: Arrow a => forall b c d. a b c -> a (d, b) (d, c)

A mirror image of `first`.

The default definition may be overridden with a more efficient version if desired.

(***) :: Arrow a => forall b c b' c'. a b c -> a b' c' -> a (b, b') (c, c')

Split the input between the two argument arrows and combine their output. Note that this is in general not a functor.

The default definition may be overridden with a more efficient version if desired.

(&&&) :: Arrow a => forall b c c'. a b c -> a b c' -> a b (c, c')

Fanout: send the input to both argument arrows and combine their output.

The default definition may be overridden with a more efficient version if desired.

Maybe

mapMaybe :: (a -> Maybe b) -> [a] -> [b]

The `mapMaybe` function is a version of `map` which can throw out elements. In particular, the functional argument returns something of type `Maybe b`. If this is `Nothing`, no element is added on to the result list. If it just `Just b`, then `b` is included in the result list.

catMaybes :: [Maybe a] -> [a]

The `catMaybes` function takes a list of `Maybe`s and returns a list of all the `Just` values.

fromMaybe :: a -> Maybe a -> a

The `fromMaybe` function takes a default value and and `Maybe` value. If the `Maybe` is `Nothing`, it returns the default values; otherwise, it returns the value contained in the `Maybe`.

Either

partitionEithers :: [Either a b] -> ([a], [b])

Partitions a list of `Either` into two lists All the `Left` elements are extracted, in order, to the first component of the output. Similarly the `Right` elements are extracted to the second component of the output.

Ord

on :: (b -> b -> c) -> (a -> b) -> a -> a -> c

`(*) `on` f = \x y -> f x * f y`.

Typical usage: `sortBy (compare `on` fst)`.

Algebraic properties:

• `(*) `on` id = (*)` (if `(*) ∉ {⊥, const ⊥}`)
• `((*) `on` f) `on` g = (*) `on` (f . g)`
• ``flip` on f . `flip` on g = `flip` on (g . f)`

comparing :: Ord a => (b -> a) -> b -> b -> Ordering

``` comparing p x y = compare (p x) (p y)
```

Useful combinator for use in conjunction with the `xxxBy` family of functions from Data.List, for example:

```   ... sortBy (comparing fst) ...
```

equating :: Eq a => (b -> a) -> b -> b -> BoolSource

Applicative

class Functor f => Applicative f where

A functor with application, providing operations to

• embed pure expressions (`pure`), and
• sequence computations and combine their results (`<*>`).

A minimal complete definition must include implementations of these functions satisfying the following laws:

identity
`pure id <*> v = v`
composition
`pure (.) <*> u <*> v <*> w = u <*> (v <*> w)`
homomorphism
`pure f <*> pure x = pure (f x)`
interchange
`u <*> pure y = pure (\$ y) <*> u`

The other methods have the following default definitions, which may be overridden with equivalent specialized implementations:

```      u `*>` v = `pure` (`const` `id`) `<*>` u `<*>` v
u `<*` v = `pure` `const` `<*>` u `<*>` v
```

As a consequence of these laws, the `Functor` instance for `f` will satisfy

```      `fmap` f x = `pure` f `<*>` x
```

If `f` is also a `Monad`, it should satisfy `pure = return` and `(<*>) = ap` (which implies that `pure` and `<*>` satisfy the applicative functor laws).

Methods

pure :: a -> f a

Lift a value.

(<*>) :: f (a -> b) -> f a -> f b

Sequential application.

(*>) :: f a -> f b -> f b

Sequence actions, discarding the value of the first argument.

(<*) :: f a -> f b -> f a

Sequence actions, discarding the value of the second argument.

Instances

 Applicative [] Applicative IO Applicative ZipList Applicative STM Applicative Maybe Applicative Vector Applicative ((->) a) Applicative (Either e) Monoid a => Applicative ((,) a) Applicative (ST s) Monoid m => Applicative (Const m) Monad m => Applicative (WrappedMonad m) Applicative (ST s) Arrow a => Applicative (WrappedArrow a b)

(<\$>) :: Functor f => (a -> b) -> f a -> f b

An infix synonym for `fmap`.

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c

Transformers

lift :: MonadTrans t => forall m a. Monad m => m a -> t m a

Monads in which `IO` computations may be embedded. Any monad built by applying a sequence of monad transformers to the `IO` monad will be an instance of this class.

Instances should satisfy the following laws, which state that `liftIO` is a transformer of monads:

• ``liftIO` . `return` = `return``
• ``liftIO` (m >>= f) = `liftIO` m >>= (`liftIO` . f)`

Methods

liftIO :: IO a -> m a

Lift a computation from the `IO` monad.

Instances

liftIO :: MonadIO m => forall a. IO a -> m a

Lift a computation from the `IO` monad.

Exceptions

class (Typeable e, Show e) => Exception e where

Any type that you wish to throw or catch as an exception must be an instance of the `Exception` class. The simplest case is a new exception type directly below the root:

``` data MyException = ThisException | ThatException
deriving (Show, Typeable)

instance Exception MyException
```

The default method definitions in the `Exception` class do what we need in this case. You can now throw and catch `ThisException` and `ThatException` as exceptions:

```*Main> throw ThisException `catch` \e -> putStrLn ("Caught " ++ show (e :: MyException))
Caught ThisException
```

In more complicated examples, you may wish to define a whole hierarchy of exceptions:

``` ---------------------------------------------------------------------
-- Make the root exception type for all the exceptions in a compiler

data SomeCompilerException = forall e . Exception e => SomeCompilerException e
deriving Typeable

instance Show SomeCompilerException where
show (SomeCompilerException e) = show e

instance Exception SomeCompilerException

compilerExceptionToException :: Exception e => e -> SomeException
compilerExceptionToException = toException . SomeCompilerException

compilerExceptionFromException :: Exception e => SomeException -> Maybe e
compilerExceptionFromException x = do
SomeCompilerException a <- fromException x
cast a

---------------------------------------------------------------------
-- Make a subhierarchy for exceptions in the frontend of the compiler

data SomeFrontendException = forall e . Exception e => SomeFrontendException e
deriving Typeable

instance Show SomeFrontendException where
show (SomeFrontendException e) = show e

instance Exception SomeFrontendException where
toException = compilerExceptionToException
fromException = compilerExceptionFromException

frontendExceptionToException :: Exception e => e -> SomeException
frontendExceptionToException = toException . SomeFrontendException

frontendExceptionFromException :: Exception e => SomeException -> Maybe e
frontendExceptionFromException x = do
SomeFrontendException a <- fromException x
cast a

---------------------------------------------------------------------
-- Make an exception type for a particular frontend compiler exception

data MismatchedParentheses = MismatchedParentheses
deriving (Typeable, Show)

instance Exception MismatchedParentheses where
toException   = frontendExceptionToException
fromException = frontendExceptionFromException
```

We can now catch a `MismatchedParentheses` exception as `MismatchedParentheses`, `SomeFrontendException` or `SomeCompilerException`, but not other types, e.g. `IOException`:

```*Main> throw MismatchedParentheses `catch` e -> putStrLn ("Caught " ++ show (e :: MismatchedParentheses))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` e -> putStrLn ("Caught " ++ show (e :: SomeFrontendException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` e -> putStrLn ("Caught " ++ show (e :: SomeCompilerException))
Caught MismatchedParentheses
*Main> throw MismatchedParentheses `catch` e -> putStrLn ("Caught " ++ show (e :: IOException))
*** Exception: MismatchedParentheses
```

Methods

toException :: e -> SomeException

data SomeException

The `SomeException` type is the root of the exception type hierarchy. When an exception of type `e` is thrown, behind the scenes it is encapsulated in a `SomeException`.

throwIO :: Exception e => e -> IO a

A variant of `throw` that can only be used within the `IO` monad.

Although `throwIO` has a type that is an instance of the type of `throw`, the two functions are subtly different:

``` throw e   `seq` x  ===> throw e
throwIO e `seq` x  ===> x
```

The first example will cause the exception `e` to be raised, whereas the second one won't. In fact, `throwIO` will only cause an exception to be raised when it is used within the `IO` monad. The `throwIO` variant should be used in preference to `throw` to raise an exception within the `IO` monad because it guarantees ordering with respect to other `IO` operations, whereas `throw` does not.

Files

data FilePath

An alias for `append`.

An alias for `addExtension`.

Get whether a `FilePath`’s last extension is the predicate.

Retrieve a `FilePath`’s basename component.

``` basename "foo/bar.txt" == "bar"
```

Retrieve a `FilePath`’s filename component.

``` filename "foo/bar.txt" == "bar.txt"
```

Print

print :: Show a => a -> IO ()

The `print` function outputs a value of any printable type to the standard output device. Printable types are those that are instances of class `Show`; `print` converts values to strings for output using the `show` operation and adds a newline.

For example, a program to print the first 20 integers and their powers of 2 could be written as:

``` main = print ([(n, 2^n) | n <- [0..19]])
```