union-type-either

Either implementation for union-type. See also union-type-option.

Implemented interfaces:

Setoid
Foldable
Functor
Apply
Chain
Applicative
Monad
Extract

Documentation

Like Ramda, the functions in this lib take the Either instance as the final argument. All functions with more than one argument are auto-curried using ramda.

This library is written in node-supported es2015 (4.0+) so if you're running in an old environment you may need to transpile to es5.

var Either = require('union-type-either')
var Right = Either.Right
var Left = Either.Left

Right :: a -> Either a

Create an instance of Either with a valid value.

Right(1) // Right(1)

Left :: a -> Either a

Create an instance of Either with a default value.

Left('Danger Will Robinson')

equals :: Either a -> Either b -> Boolean

Compare the contained value of one Either against another using ===.

Either.equals(Right(1), Right(1)) //true
Either.equals(Right({}), Right({})) //false
Either.equals(Left('Doh'), Left('Doh')) //true

map :: (a -> b) -> Either a -> Either b

Run a function on a value in an Either and return new Either with the result.

Either.map(a => a + 3, Right(1)) // Right(4)

extract :: Either a -> a

Get the value out of an Either. Could be Left or Right.

Either.extract(Right(1)) // 1
Either.extract(Left('Doh')) // 'Doh'

of :: a -> Either b -> a

Put a value in an Either. Mostly useful for higher level operations.

Either.of(1, Left('Doh')) // Right(1)
Either.of(1, Right(999)) // Right(1)

chain :: (a -> Either b) -> Either a -> Either b

Run a function that returns an Either on the value in another Either.

var validLength = str => str.length < 8 ? Left('Passwords must contain at least 8 characters') : Right(str)
var validHasCapitals = str => (/[A-Z]/).test(str) ? Right(str) : Left('Password must contain at least one capital')
var validateUsername = username => Either.chain(validHasCapitals, validLength(username))

chainLeft :: (a -> Either b) -> Either a -> Either b

Like chain but only applies to Left values.

bichain :: (a -> Either b) -> (b -> Either c) -> Either a b -> Either c

Like chain but takes two functions and applies one of them to Left or Right.

ap :: Either a -> Either (a -> b) -> Either b

Run a function inside an Either on the value in another Either

Either.ap(Right(2), Right(a => a * 2)) // Right(4)

reduce :: (b -> a -> b) -> b -> Either a -> b

Turn an option into something else by combining its right value with a seed and a reducing function.

Either.reduce((a, b) => a + b, 1, Right(2)) // Right(3)

extend :: Either a => (a -> b) -> a -> Either b

Run a function on an Either and wrap with another Either.

Either.extend(a => a.extract() + 1, Right(1)) // 2

cata :: (a -> c) -> (b -> c) -> Either a b -> c

Catamorphism. Run a function on the value of both branches of an Either

Either.cata(a => a + 1, Right(1)) // 2
Either.cata(a => a + 1, Left(1)) // 2

bimap :: (a -> b) -> (c -> d) -> Either a c -> Either b d

Run a function on the value of both branches of an Either and return an Either

Either.bimap(a => a + 1, Right(1)) // Right(2)
Either.bimap(a => a + 1, Left(1)) // Left(2)

jethrolarson/union-type-either