A generic structure for a type with two possibilities: a Left a
or
a Right b
.
The only implementation
map : (a -> b) -> Either x a -> Either x b
Apply a function to an Either
. If the argument is Right
, it
will be converted. If the argument is an Left
, the same left value
will propogate through.
map ((+) 1) (Left "Hello") == Left "Hello"
map ((+) 1) (Right 2) == Right 3
mapLeft : (a -> b) -> Either a x -> Either b x
Apply a function to the Left
of an Either
.
mapLeft ((+) 1) (Left 2) == Left 3
mapLeft ((+) 1) (Right 2) == Right 2
mapRight : (a -> b) -> Either x a -> Either x b
Alias for map
.
voidRight : a -> Either x b -> Either x a
Ignore the return value of the Right
using the specified value instead.
Exactly the same as <$
in other languages.
voidRight 2 (Right True) == Right 2
voidRight 2 (Left "banana") == Left "banana"
voidLeft : a -> Either b x -> Either a x
Ignore the return value of the Left
using the specified value instead.
NOT the same as $>
in other languages.
voidLeft "two" (Right True) == Right True
voidLeft "two" (Left 6) == Left "two"
mapBoth : (a -> b) -> (c -> d) -> Either a c -> Either b d
Apply the first argument function to a Left
and the second
argument function to a Right
of an Either
.
mapBoth (\s -> s ++ "!!") ((+) 1) (Left "Hello") == Left "Hello!!"
mapBoth (\s -> s ++ "!!") ((+) 1) (Right 2) == Right 3
mapEach : (a -> b) -> Either a a -> Either b b
Not crazy on the name, but apply a function to either the Left
or the Right
where the Left
and the Right
are of the same type.
mapEach ((+) 1) (Left 2) == Left 3
mapEach ((+) 1) (Right 3) == Right 4
singleton : b -> Either x b
Create a singleton
from a value to an Either
with a Right
of the same type. Also known as pure
. Use the Left
constructor
for a singleton of the Left
variety.
singleton 2 == Right 2
andMap : Either x a -> Either x (a -> b) -> Either x b
Apply the function that is inside Either
to a value that is inside
Either
. Return the result inside Either
. If one of the Either
arguments is Left x
, return Left x
. Also known as apply
.
Left "Hello" |> andMap (Left "World") == Left "Hello"
Left "Hello" |> andMap (Right 2) == Left "Hello"
Right ((+) 1) |> andMap (Left "World") == Left "World"
Right ((+) 1) |> andMap (Right 2) == Right 3
andMapLeft : Either a x -> Either (a -> b) x -> Either b x
Apply the function that is inside Either
to a value that is inside
Either
. Return the result inside Either
. If one of the Either
arguments is Right x
, return Right x
. Also known as apply
.
Left (\s -> s ++ "!!") |> andMap (Left "Hello") == Left "Hello!!"
Left (\s -> s ++ "!!") |> andMap (Right 2) == Right 2
Right 99 |> andMap (Left "World") == Right 99
Right 99 |> andMap (Right 2) == Right 99
andMapRight : Either x a -> Either x (a -> b) -> Either x b
Alias for andMap
.
map2 : (a -> b -> c) -> Either x a -> Either x b -> Either x c
Apply a function to two eithers, if both arguments are Right
.
If not, the first argument which is a Left
will propagate through.
Also known as liftA2
.
map2 (+) (Left "Hello") (Left "World") == Left "Hello"
map2 (+) (Left "Hello") (Right 3) == Left "Hello"
map2 (+) (Right 2) (Left "World") == Left "World"
map2 (+) (Right 2) (Right 3) == Right 5
It’s essentially a helper for (and why it’s under applicative)
singleton (+) |> andMap (Right 2) |> andMap (Right 3) == Right 5
map3 : (a -> b -> c -> d) -> Either x a -> Either x b -> Either x c -> Either x d
Like map2
, but with 3 eithers. Also known as liftA3
map4 : (a -> b -> c -> d -> e) -> Either x a -> Either x b -> Either x c -> Either x d -> Either x e
Like map2
, but with 4 eithers. Also known as liftA4
length : Either a b -> Basics.Int
Returns the length of an Either
. This happens to be 0
for a
Left
and 1
for a Right
.
length (Left 2) == 0
length (Right "Sharks") == 1
foldl : (a -> b -> b) -> b -> Either a a -> b
Folds an Either
over a function with an accumulator. If
it is a Left
the function is applied with the accumulator.
If it is a Right
only the accumulator is returned.
foldl (*) 2 (Left 3) == 6
foldl (*) 2 (Right 3) == 2
foldr : (a -> b -> b) -> b -> Either a a -> b
Folds an Either
over a function with an accumulator. If
it is a Right
the function is applied with the accumulator.
If it is a Left
only the accumulator is returned.
foldr (*) 2 (Left 3) == 2
foldr (*) 2 (Right 3) == 6
andThen : (a -> Either x b) -> Either x a -> Either x b
Chain together in many computations that will stop computing if
a chain is on a Left
. Also known as bind
.
Left "Hello" |> andThen (\i -> Right (i + 1)) == Left "Hello"
Right 2 |> andThen (\i -> Right (i + 1)) == Right 3
andThenLeft : (a -> Either b x) -> Either a x -> Either b x
Chain together in many computations that will stop computing if
a chain is on a Right
. Also known as bind
.
Left "Hello" |> andThen (\s -> Left (s ++ "!!")) == Left "Hello!!"
Right 2 |> andThen (\s -> Left (s ++ "!!")) == Right 2
andThenRight : (a -> Either x b) -> Either x a -> Either x b
Alias for andThen
.
andThenBoth : (a -> Either c d) -> (b -> Either c d) -> Either a b -> Either c d
appendLeft : Either appendable x -> Either appendable x -> Either appendable x
Append inner values of a Left
.
appendLeft (Left [ 1, 2 ]) (Left [ 3, 4 ]) == Left [ 1, 2, 3, 4 ]
appendLeft (Left [ 1, 2 ]) (Right 'b') == Left [ 1, 2 ]
appendLeft (Right 'a') (Left [ 3, 4 ]) == Left [ 3, 4 ]
appendLeft (Right 'a') (Right 'b') == Right 'a'
appendRight : Either x appendable -> Either x appendable -> Either x appendable
Append inner values of a Right
.
appendRight (Right "Hello") (Right "World") == Right "HelloWorld"
appendRight (Right "Hello") (Left 1) == Right "Hello"
appendRight (Left 0) (Right "World") == Right "World"
appendRight (Left 0) (Left 1) == Left 0
equals : Either comparable comparable1 -> Either comparable comparable1 -> Basics.Bool
One rendition of equals assuming both sides of the Either
are comparable.
equals (Right "Hello") (Right "Hello") == True
equals (Right "Hello") (Right "World") == False
equals (Right "Hello") (Left "Hello") == False
equals (Right "Hello") (Left 1) == False
equals (Left 0) (Right "World") == False
equals (Left 0) (Left 0) == True
equals (Left 0) (Left 1) == False
equals (Left 0) (Right 0) == False
toList : Either x a -> List a
Converts a Either x b
to a List
of b
.
toList (Right 1) == [ 1 ]
toList (Left 'a') == []
toListVia : (a -> b) -> Either x a -> List b
Folds a Either x b
to a List
of c
via a transforming function.
toList ((+) 1) (Right 1) == [ 2 ]
toList ((+) 1) (Left 'a') == []
lefts : List (Either a x) -> List a
Converts a List
of Either a x
to a List of a
.
lefts [ Left "Hello", Left "world", Right 2 ] == [ "Hello", "world" ]
rights : List (Either x a) -> List a
Converts a List
of Either x b
to a List of b
.
rights [ Left "Hello", Left, "world", Right 2 ] == [ 2 ]
partition : List (Either a b) -> ( List a, List b )
Converts a List
of Either a b
, into a tuple2 where
the first value is a List a
and the second is List b
.
partition [ Left "Hello", Left "world", Right 2 ] == ( [ "Hello", "World" ], [ 2 ] )
biList : Either a a -> List a
Collects the list of elements of a structure, from left to right.
biList (Left 4) == [ 4 ]
biList (Right 9) == [ 9 ]
toArray : Either x b -> Array b
Convert from Either
to Array
toArray (Right 1) == Array.fromList [ 1 ]
toArray (Left 'a') == Array.fromList []
toArrayVia : (a -> b) -> Either x a -> Array b
Folds from Either
to Array
via a transforming function.
toArrayVia ((+) 1) (Right 1) == Array.fromList [ 2 ]
toArrayVia ((+) 1) (Left 'a') == Array.fromList []
toSet : Either x comparable -> Set comparable
Convert from Either
to Set
toSet (Right 1) == Set.fromList [ 1 ]
toSet (Left 'a') == Set.fromList []
toSetVia : (a -> comparable) -> Either x a -> Set comparable
Folds from Either
to Set
via a transforming function.
toSetVia ((+) 1) (Right 1) == Set.fromList [ 2 ]
toSetVia ((+) 1) (Left 'a') == Set.fromList []
toDict : Either x ( comparable, v ) -> Dict comparable v
Convert from Either
to Dict
toDict (Right ( "KEY", 1 )) == Dict.fromList [ ( "KEY", 1 ) ]
toDict (Left 'a') == Dict.fromList []
toDictVia : (a -> ( comparable, v )) -> Either x a -> Dict comparable v
Folds from Either
to Dict
via a transforming function.
toDictVia (Right ( "KEY", 1 )) == Dict.fromList [ ( "KEY", 1 ) ]
toDictVia (Left 'a') == Dict.fromList []
toMaybe : Either x b -> Maybe b
Maybe
get the Right
side of an Either
.
toMaybe (Right 2) == Just 2
toMaybe (Left "World") == Nothing
toMaybeVia : (b -> c) -> Either x b -> Maybe c
Folds a Maybe
get the Right
side of an Either
via a transforming
function.
toMaybeVia ((*) 3) (Right 2) == Just 6
toMaybeVia ((*) 3) (Left "World") == Nothing
leftToMaybe : Either a x -> Maybe a
Maybe
get the Left
side of an Either
.
leftToMaybe (Left "World") == Just "World"
leftToMaybe (Right 2) == Nothing
rightToMaybe : Either x b -> Maybe b
Alias for toMaybe
.
fromMaybe : a -> Maybe b -> Either a b
Convert from a Maybe
to Either
with a default value
for Left
for Nothing
.
fromMaybe "Hello" (Just 2) == Right 2
fromMaybe "Hello" Nothing == Left "Hello"
leftFromMaybe : b -> Maybe a -> Either a b
Convert from a Maybe
to Either
with a default value
for Right
for Nothing
.
leftFromMaybe 3 (Just "World") == Left "World"
leftFromMaybe 3 Nothing == Right 3
rightFromMaybe : a -> Maybe b -> Either a b
Alias for fromMaybe
.
toResult : Either a b -> Result a b
Convert from Either
to Result
.
toResult (Right 2) == Ok 2
toResult (Left "World") == Err "World"
toResultVia : (b -> c) -> Either a b -> Result a c
Fold from Either
to Result
via transforming function.
toResultVia ((+) 3) (Left "World") == Err "World"
toResultVia ((+) 3) (Right 2) == Ok 5
fromResult : Result a b -> Either a b
Convert from Result
to Either
.
fromResult (Ok 2) == Right 2
fromResult (Err "World") == Left "World"
toTask : Either a b -> Task a b
Convert from Either
to Task
toTask (Right "World") -- succeed "World"
toTask (Left 2) -- fail 2
toTaskVia : (b -> c) -> Either a b -> Task a c
Fold from Either
to Task
via transforming function.
toTaskVia (\s -> s ++ "!!") (Right "World") -- succeed "World!!"
toTaskVia (\s -> s ++ "!!") (Left 2) -- fail 2
isLeft : Either a b -> Basics.Bool
Returns True
if argument is Left _
isLeft (Left "World") == True
isLeft (Right 2) == False
isRight : Either a b -> Basics.Bool
Returns True
if argument is Right _
isRight (Left "World") == False
isRight (Right 2) == True
fromLeft : a -> Either a b -> a
Extract left value or a default.
fromLeft "World" (Left "Hello") == "Hello"
fromLeft "World" (Right 2) == "World"
fromRight : b -> Either a b -> b
Extract right value or a default.
fromRight 3 (Left "Hello") == 3
fromRight 3 (Right 2) == 2
withDefault : b -> Either a b -> b
Alias for fromRight
.
unpack : (a -> c) -> (b -> c) -> Either a b -> c
Given a function for both Left
and Right
to to type a generic
type c
, collapse down the Either
to a value of that type.
unpack identity toString (Left "World") == "World"
unpack identity toString (Right 2) == "2"
unwrap : b -> (a -> b) -> Either x a -> b
Apply a function to Right
value. If argument was a Left
use the
default value. Equivalent to Either.map >> Either.fromRight
.
unwrap 99 ((+) 1) (Left "Hello") == 99
unwrap 99 ((+) 1) (Right 2) == 3
swap : Either a b -> Either b a
Swap the Left
and Right
sides of an Either
.
swap (Left "World") == Right "World"
swap (Right 2) == Left 2