Data.Either.Extra

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.

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