Data.Either.Extra

extra-1.5.1: Extra functions I use.

Safe Haskell | Safe
Language | Haskell2010

Data.Either.Extra

Description

This module extends Data.Either with extra operations, particularly to quickly extract from inside an `Either`. Some of these operations are partial, and should be used with care in production-quality code.

Synopsis

- module Data.Either
- isLeft :: Either a b -> Bool
- isRight :: Either a b -> Bool
- fromLeft :: a -> Either a b -> a
- fromRight :: b -> Either a b -> b
- fromEither :: Either a a -> a
- fromLeft' :: Either l r -> l
- fromRight' :: Either l r -> r
- eitherToMaybe :: Either a b -> Maybe b
- maybeToEither :: a -> Maybe b -> Either a b

# Documentation

module Data.Either

isLeft :: Either a b -> Bool #

Return `True` if the given value is a `Left`-value, `False` otherwise.

#### Examples

Basic usage:

    >>> isLeft (Left "foo")
    True
    >>> isLeft (Right 3)
    False

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)
    >>> report (Left "parse error")
    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:

    >>> isRight (Left "foo")
    False
    >>> isRight (Right 3)
    True

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")
    >>> report (Right 1)
    SUCCESS

Since: 4.7.0.0

fromLeft :: a -> Either a b -> a #

Return the contents of a `Left`-value or a default value otherwise.

    fromLeft 1 (Left 3) == 3
    fromLeft 1 (Right "foo") == 1

fromRight :: b -> Either a b -> b #

Return the contents of a `Right`-value or a default value otherwise.

    fromRight 1 (Right 3) == 3
    fromRight 1 (Left "foo") == 1

fromEither :: Either a a -> a #

Pull the value out of an `Either` where both alternatives have the same type.

    \x -> fromEither (Left x ) == x
    \x -> fromEither (Right x) == x

fromLeft' :: Either l r -> l #

The `fromLeft'` function extracts the element out of a `Left` and throws an error if its argument is `Right`. Much like `fromJust`, using this function in polished code is usually a bad idea.

    \x -> fromLeft' (Left  x) == x
    \x -> fromLeft' (Right x) == undefined

fromRight' :: Either l r -> r #

The `fromRight'` function extracts the element out of a `Right` and throws an error if its argument is `Left`. Much like `fromJust`, using this function in polished code is usually a bad idea.

    \x -> fromRight' (Right x) == x
    \x -> fromRight' (Left  x) == undefined

eitherToMaybe :: Either a b -> Maybe b #

Given an `Either`, convert it to a `Maybe`, where `Left` becomes `Nothing`.

    \x -> eitherToMaybe (Left x) == Nothing
    \x -> eitherToMaybe (Right x) == Just x

maybeToEither :: a -> Maybe b -> Either a b #

Given a `Maybe`, convert it to an `Either`, providing a suitable value for the `Left` should the value be `Nothing`.

    \a b -> maybeToEither a (Just b) == Right b
    \a -> maybeToEither a Nothing == Left a