extra-1.6.17: 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.

If you need more `Either` functions see the either.

Synopsis

- module Data.Either
- fromLeft :: a -> Either a b -> a
- fromRight :: b -> Either a b -> b
- fromEither :: Either a a -> a
- fromLeft' :: Partial => Either l r -> l
- fromRight' :: Partial => Either l r -> r
- eitherToMaybe :: Either a b -> Maybe b
- maybeToEither :: a -> Maybe b -> Either a b
- mapLeft :: (a -> c) -> Either a b -> Either c b
- mapRight :: (b -> c) -> Either a b -> Either a c

# Documentation

module Data.Either

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

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

#### Examples

Expand

Basic usage:

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

Since: base-4.10.0.0

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

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

#### Examples

Expand

Basic usage:

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

Since: base-4.10.0.0

fromEither :: Either a a -> a Source #

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' :: Partial => Either l r -> l Source #

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' :: Partial => Either l r -> r Source #

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 Source #

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 Source #

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

mapLeft :: (a -> c) -> Either a b -> Either c b Source #

The `mapLeft` function takes a function and applies it to an Either value iff the value takes the form ``Left` _`.

    mapLeft show (Left 1) == Left "1"
    mapLeft show (Right True) == Right True

mapRight :: (b -> c) -> Either a b -> Either a c Source #

The `mapRight` function takes a function and applies it to an Either value iff the value takes the form ``Right` _`.

    mapRight show (Left 1) == Left 1
    mapRight show (Right True) == Right "True"