:: Either a b -> b -package:MissingH

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

Extracts the element out of a Right and throws an error if its argument take the form Left _. Using Control.Lens:

fromRight' x ≡ x^?!_Right

>>> fromRight' (Right 12)
12

Extracts the element out of a Right and throws an error if the argument is a Left.

The fromRight function extracts the element out of a Right and throws an error if its argument take the form Left _.

fromRight but with a better error message if it fails. Use this only where it shouldn't fail!

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

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

Maybe get the Right side of an Either.

rightToMaybe ≡ either (const Nothing) Just

Using Control.Lens:

rightToMaybe ≡ preview _Right
rightToMaybe x ≡ x^?_Right

>>> rightToMaybe (Left 12)
Nothing

>>> rightToMaybe (Right 12)
Just 12

Suppress the Left value of an Either

Transform an Either value into a Maybe value. Right is mapped to Just and Left is mapped to Nothing. The value inside Left is lost.

Safe projection from Right.

maybeRight (Right b) = Just b
maybeRight Left{}    = Nothing

A fromRight that fails in the Maybe monad

Convert an Either to a Maybe. A Right value becomes Just.

>>> eitherToMaybe $ Right 3
Just 3

A Left value becomes Nothing.

>>> eitherToMaybe $ Left "bye"
Nothing

Maps right part of Either to Maybe.

>>> rightToMaybe (Left True)
Nothing

>>> rightToMaybe (Right "aba")
Just "aba"

Turn Right into Just and Left into Nothing.

To prevent a dependency on package errors

Converts an Either to a Maybe.

Lifts an Either e into Monad m with effect Throw e

Return value on the Right and fail otherwise. Lifted version of expectRight.