Copyright | (c) The University of Glasgow 2001 |
---|---|

License | BSD-style (see the file libraries/base/LICENSE) |

Maintainer | libraries@haskell.org |

Stability | experimental |

Portability | portable |

Safe Haskell | Trustworthy |

Language | Haskell2010 |

The Either type, and associated operations.

# Documentation

The `Either`

type represents values with two possibilities: a value of
type

is either `Either`

a b

or `Left`

a

.`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").

#### Examples

The type

is the type of values which can be either
a `Either`

`String`

`Int`

`String`

or an `Int`

. The `Left`

constructor can be used only on
`String`

s, and the `Right`

constructor can be used only on `Int`

s:

`>>>`

`let s = Left "foo" :: Either String Int`

`>>>`

Left "foo"`s`

`>>>`

`let n = Right 3 :: Either String Int`

`>>>`

Right 3`n`

`>>>`

s :: Either String Int`:type s`

`>>>`

n :: Either String Int`:type n`

The `fmap`

from our `Functor`

instance will ignore `Left`

values, but
will apply the supplied function to values contained in a `Right`

:

`>>>`

`let s = Left "foo" :: Either String Int`

`>>>`

`let n = Right 3 :: Either String Int`

`>>>`

Left "foo"`fmap (*2) s`

`>>>`

Right 6`fmap (*2) n`

The `Monad`

instance for `Either`

allows us to chain together multiple
actions which may fail, and fail overall if any of the individual
steps failed. First we'll write a function that can either parse an
`Int`

from a `Char`

, or fail.

`>>>`

`import Data.Char ( digitToInt, isDigit )`

`>>>`

let parseEither :: Char -> Either String Int parseEither c | isDigit c = Right (digitToInt c) | otherwise = Left "parse error"`:{`

`>>>`

`:}`

The following should work, since both `'1'`

and `'2'`

can be
parsed as `Int`

s.

`>>>`

let parseMultiple :: Either String Int parseMultiple = do x <- parseEither '1' y <- parseEither '2' return (x + y)`:{`

`>>>`

`:}`

`>>>`

Right 3`parseMultiple`

But the following should fail overall, since the first operation where
we attempt to parse `'m'`

as an `Int`

will fail:

`>>>`

let parseMultiple :: Either String Int parseMultiple = do x <- parseEither 'm' y <- parseEither '2' return (x + y)`:{`

`>>>`

`:}`

`>>>`

Left "parse error"`parseMultiple`

Bifunctor Either # | |

Show2 Either # | |

Read2 Either # | |

Ord2 Either # | |

Eq2 Either # | |

Monad (Either e) # | |

Functor (Either a) # | |

MonadFix (Either e) # | |

Applicative (Either e) # | |

Foldable (Either a) # | |

Traversable (Either a) # | |

Generic1 (Either a) # | |

Show a => Show1 (Either a) # | |

Read a => Read1 (Either a) # | |

Ord a => Ord1 (Either a) # | |

Eq a => Eq1 (Either a) # | |

(Eq b, Eq a) => Eq (Either a b) # | |

(Data a, Data b) => Data (Either a b) # | |

(Ord b, Ord a) => Ord (Either a b) # | |

(Read b, Read a) => Read (Either a b) # | |

(Show b, Show a) => Show (Either a b) # | |

Generic (Either a b) # | |

Semigroup (Either a b) # | |

type Rep1 (Either a) # | |

type Rep (Either a b) # | |

type (==) (Either k k1) a b # | |

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

Case analysis for the `Either`

type.
If the value is

, apply the first function to `Left`

a`a`

;
if it is

, apply the second function to `Right`

b`b`

.

#### Examples

We create two values of type

, one using the
`Either`

`String`

`Int`

`Left`

constructor and another using the `Right`

constructor. Then
we apply "either" the `length`

function (if we have a `String`

)
or the "times-two" function (if we have an `Int`

):

`>>>`

`let s = Left "foo" :: Either String Int`

`>>>`

`let n = Right 3 :: Either String Int`

`>>>`

3`either length (*2) s`

`>>>`

6`either length (*2) n`

isLeft :: Either a b -> Bool #

Return `True`

if the given value is a `Left`

-value, `False`

otherwise.

#### Examples

Basic usage:

`>>>`

True`isLeft (Left "foo")`

`>>>`

False`isLeft (Right 3)`

Assuming a `Left`

value signifies some sort of error, we can use
`isLeft`

to write a very simple error-reporting function that does
absolutely nothing in the case of success, and outputs "ERROR" if
any error occurred.

This example shows how `isLeft`

might be used to avoid pattern
matching when one does not care about the value contained in the
constructor:

`>>>`

`import Control.Monad ( when )`

`>>>`

`let report e = when (isLeft e) $ putStrLn "ERROR"`

`>>>`

`report (Right 1)`

`>>>`

ERROR`report (Left "parse error")`

*Since: 4.7.0.0*

isRight :: Either a b -> Bool #

Return `True`

if the given value is a `Right`

-value, `False`

otherwise.

#### Examples

Basic usage:

`>>>`

False`isRight (Left "foo")`

`>>>`

True`isRight (Right 3)`

Assuming a `Left`

value signifies some sort of error, we can use
`isRight`

to write a very simple reporting function that only
outputs "SUCCESS" when a computation has succeeded.

This example shows how `isRight`

might be used to avoid pattern
matching when one does not care about the value contained in the
constructor:

`>>>`

`import Control.Monad ( when )`

`>>>`

`let report e = when (isRight e) $ putStrLn "SUCCESS"`

`>>>`

`report (Left "parse error")`

`>>>`

SUCCESS`report (Right 1)`

*Since: 4.7.0.0*

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.

#### Examples

Basic usage:

`>>>`

`let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]`

`>>>`

(["foo","bar","baz"],[3,7])`partitionEithers list`

The pair returned by

should be the same
pair as `partitionEithers`

x`(`

:`lefts`

x, `rights`

x)

`>>>`

`let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]`

`>>>`

True`partitionEithers list == (lefts list, rights list)`