The typeEitherStringInt is the type of values which can be eitheraString or anInt. TheLeft constructor can be used only onStrings, and theRight constructor can be used only onInts:

>>>let s = Left "foo" :: Either String Int>>>sLeft "foo">>>let n = Right 3 :: Either String Int>>>nRight 3>>>:type ss :: Either String Int>>>:type nn :: Either String Int

Thefmap from ourFunctor instance will ignoreLeft values, butwill apply the supplied function to values contained in aRight:

>>>let s = Left "foo" :: Either String Int>>>let n = Right 3 :: Either String Int>>>fmap (*2) sLeft "foo">>>fmap (*2) nRight 6

TheMonad instance forEither allows us to chain together multipleactions which may fail, and fail overall if any of the individualsteps failed. First we'll write a function that can either parse anInt from aChar, or fail.

>>>import Data.Char ( digitToInt, isDigit )>>>:{    let parseEither :: Char -> Either String Int        parseEither c          | isDigit c = Right (digitToInt c)          | otherwise = Left "parse error">>>:}

The following should work, since both'1' and'2' can beparsed asInts.

>>>:{    let parseMultiple :: Either String Int        parseMultiple = do          x <- parseEither '1'          y <- parseEither '2'          return (x + y)>>>:}

>>>parseMultipleRight 3

But the following should fail overall, since the first operation wherewe attempt to parse'm' as anInt will fail:

>>>:{    let parseMultiple :: Either String Int        parseMultiple = do          x <- parseEither 'm'          y <- parseEither '2'          return (x + y)>>>:}

>>>parseMultipleLeft "parse error"

We create two values of typeEitherStringInt, one using theLeft constructor and another using theRight constructor. Then we apply "either" thelength function (if we have aString) or the "times-two" function (if we have anInt):

>>>let s = Left "foo" :: Either String Int>>>let n = Right 3 :: Either String Int>>>either length (*2) s3>>>either length (*2) n6

Basic usage:

>>>let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]>>>lefts list["foo","bar","baz"]

Basic usage:

>>>let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]>>>rights list[3,7]

Basic usage:

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

Assuming aLeft value signifies some sort of error, we can useisLeft 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 howisLeft 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

Basic usage:

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

Assuming aLeft value signifies some sort of error, we can useisRight to write a very simple reporting function that only outputs "SUCCESS" when a computation has succeeded.

This example shows howisRight 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

Basic usage:

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

Basic usage:

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

Basic usage:

>>>let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]>>>partitionEithers list(["foo","bar","baz"],[3,7])

The pair returned bypartitionEithers x should be the same pair as(lefts x,rights x):

>>>let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]>>>partitionEithers list == (lefts list, rights list)True