LEFT
Constructs a Left value in an Either type.
LEFT 1 == [0 1]
LEFT b#hello == [0 b#hello]
LEFT NIL == [0 0]
RIGHT
Constructs a Right value in an Either type.
RIGHT 1 == [1 1]
RIGHT b#hello == [1 b#hello]
RIGHT NIL == [1 0]
fromLeft
Extracts the value from a Left, or returns a default value for a Right.
fromLeft 0 [0 2] == 2
fromLeft 0 ~[0 2] == [2 0]
fromLeft 1 (LEFT b#b) == b#b
fromLeft 1 (RIGHT b#b) == (1 b#b)
unpackLeft
Extracts the value from a Left, or crashes for a Right.
unpackLeft (LEFT 1) == 1
unpackLeft (LEFT b#a) == b#a
unpackLeft (RIGHT 1) ; crashes with "Unexpected RIGHT"
fromRight
Extracts the value from a Right, or returns a default value for a Left.
fromRight 0 (RIGHT 1) == 1
fromRight 0 (LEFT 1) == (0 1)
fromRight natBar (RIGHT b#right) == b#right
fromRight natBar (LEFT {left}) == b#left
unpackRight
Extracts the value from a Right, or crashes for a Left.
unpackRight (RIGHT 1) == 1
unpackRight (RIGHT b#a) == b#a
unpackRight (LEFT 1) ; crashes with "Unexpected LEFT"
eitherCase
Pattern matches on an Either value, applying the appropriate function.
eitherCase [1 0] (add 1) (add 3) == 3
eitherCase (RIGHT 1) (add 1) (add 3) == 3
eitherCase [0 b#a] (const b#left) (const b#right) == b#left
eitherOpen
Pattern matches on an Either value, returning the value for a Right, or applying a function for a Left.
eitherOpen [0 2] (add 1) == [0 2]
eitherOpen [1 2] (add 1) == 3
eitherOpen (LEFT b#a) (const b#left) == [0 b#a]
eitherOpen (RIGHT b#a) (const b#left) == b#left
eitherOpenLeft
Pattern matches on an Either value, returning the value for a Left, or applying a function for a Right.
eitherOpenLeft [0 2] (add 1) == 3
eitherOpenLeft [1 2] (add 1) == [1 2]
eitherOpenLeft (LEFT b#a) (const b#right) == b#right
eitherOpenLeft (RIGHT b#a) (const b#right) == [1 b#a]
eitherCaseLeft
Pattern matches on an Either value, applying the appropriate function (opposite order of eitherCase).
eitherCaseLeft [1 0] (add 1) (add 3) == 1
eitherCaseLeft (RIGHT 1) (add 1) (add 3) == 2
eitherCaseLeft [0 b#a] (const b#left) (const b#right) == b#right
eitherGetRight
Extracts the value from a Right, or applies a function to the Left value.
eitherGetRight (RIGHT 1) (add 1) == 2
eitherGetRight (LEFT 1) (add 1) == [0 1]
eitherGetRight (RIGHT b#a) (const b#left) == b#left
eitherGetLeft
Extracts the value from a Left, or applies a function to the Right value.
eitherGetLeft (LEFT 1) (add 1) == 2
eitherGetLeft (RIGHT 1) (add 1) == [1 1]
eitherGetLeft (LEFT b#a) (const b#right) == b#right
eitherMap
Applies a function to the value in a Right, leaving a Left unchanged.
eitherMap (add 2) (RIGHT 1) == (1 3)
eitherMap (add 2) (LEFT 1) == (0 1)
eitherMap (strWeld {hello_}) (RIGHT {world}) == (1 {hello_world})
eitherBind
Applies a function that returns an Either to the value in a Right, leaving a Left unchanged.
eitherBind (RIGHT 1) (x & if (even x) (RIGHT (mul x 2)) (LEFT x)) == [0 1]
eitherBind (RIGHT 2) (x & if (even x) (RIGHT (mul x 2)) (LEFT x)) == [1 4]
eitherBind (RIGHT b#bye) (x & if (eql x b#hello) (RIGHT b#world) (LEFT x)) == [0 b#bye]
partition
Separates a row of Either values into two rows: one for Left values and one for Right values.
partition [[0 0] [1 1] [1 2] [0 3]] == [[0 3] [1 2]]
partition [LEFT-1 RIGHT-2 LEFT-3 RIGHT-4] == [[1 3] [2 4]]
partition [(RIGHT b#a) (LEFT b#b) (RIGHT b#c)] == [[b#b] [b#a b#c]]
partition [] == [[] []]
