Data.Either.Combinators

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

Using Data.Bifunctor:

mapLeft = first

Using Control.Arrow:

mapLeft = (left)

Using Control.Lens:

mapLeft = over _Left

>>> mapLeft (*2) (Left 4)Left 8

>>> mapLeft (*2) (Right "hello")Right "hello"

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

Using Data.Bifunctor:

mapRight = second

Using Control.Arrow:

mapRight = (right)

Using Control.Lens:

mapRight = over _Right

>>> mapRight (*2) (Left "hello")Left "hello"

>>> mapRight (*2) (Right 4)Right 8

Generalize Either e as MonadError e m.

If the argument has form Left e, an error is produced in the monad via throwError. Otherwise, the Right a part is forwarded.

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

Using Control.Lens:

fromLeft' x ≡ x^?!_Left

>>> fromLeft' (Left 12)12

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

Maybe get the Left side of an Either.

leftToMaybe ≡ either Just (const Nothing)

Using Control.Lens:

leftToMaybe ≡ preview _Left
leftToMaybe x ≡ x^?_Left

>>> leftToMaybe (Left 12)Just 12

>>> leftToMaybe (Right 12)Nothing

The mapBoth function takes two functions and applies the first if iff the value takes the form Left _ and the second if the value takes the form Right _.

Using Data.Bifunctor:

mapBoth = bimap

Using Control.Arrow:

mapBoth = (+++)

>>> mapBoth (*2) (*3) (Left 4)Left 8

>>> mapBoth (*2) (*3) (Right 4)Right 12

Maybe produce a Left, otherwise produce a Right.

>>> maybeToLeft "default" (Just 12)Left 12

>>> maybeToLeft "default" NothingRight "default"

Maybe produce a Right, otherwise produce a Left.

>>> maybeToRight "default" (Just 12)Right 12

>>> maybeToRight "default" NothingLeft "default"

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

Swap the Left and Right sides of an Either.

>>> swapEither (Right 3)Left 3

>>> swapEither (Left "error")Right "error"

A synonym of whenRight.

A synonym of whenLeft.

The whenLeft function takes an Either value and a function which returns a monad. The monad is only executed when the given argument takes the form Left _, otherwise it does nothing.

Using Control.Lens:

whenLeft ≡ forOf_ _Left

>>> whenLeft (Left 12) print12

The whenRight function takes an Either value and a function which returns a monad. The monad is only executed when the given argument takes the form Right _, otherwise it does nothing.

Using Data.Foldable:

whenRight ≡ forM_

Using Control.Lens:

whenRight ≡ forOf_ _Right

>>> whenRight (Right 12) print12

Extract the left value or a default.

fromLeft b ≡ either id (const b)

>>> fromLeft "hello" (Right 42)"hello"

>>> fromLeft "hello" (Left "world")"world"

Extract the right value or a default.

fromRight b ≡ either (const b) id

>>> fromRight "hello" (Right "world")"world"

>>> fromRight "hello" (Left 42)"hello"

The isLeft function returns True iff its argument is of the form Left _.

Using Control.Lens:

isLeft ≡ has _Left

>>> isLeft (Left 12)True

>>> isLeft (Right 12)False

The isRight function returns True iff its argument is of the form Right _.

Using Control.Lens:

isRight ≡ has _Right

>>> isRight (Left 12)False

>>> isRight (Right 12)True