Transformation Functions

import Either from 'crocks/Either'
import Maybe from 'crocks/Maybe'

import identity from 'crocks/combinators/identity'
import map from 'crocks/pointfree/map'
import option from 'crocks/pointfree/option'

const data =
  Either.of(Maybe.of(3))
//=> Right Just 3

// mapping on the inner Maybe is tedious at best
data
  .map(map(x => x + 1))   //=> Right Just 4
  .map(map(x => x * 10))  //=> Right Just 40

// and extraction...super gross
data
  .either(identity, identity)  //=> Just 3
  .option(0)                   //=> 3

// or
data
  .either(option(0), option(0))  // 3

import Either from 'crocks/Either'
import Maybe from 'crocks/Maybe'

import identity from 'crocks/combinators/identity'
import map from 'crocks/pointfree/map'
import maybeToEither from 'crocks/Either/maybeToEither'

const data =
  Either.of(Maybe.of(3))      //=> Right Just 3
    .chain(maybeToEither(0))  //=> Right 3

// mapping on a single Either, much better
data
  .map(x => x + 1)  //=> Right 4
  .map(x => x * 10) //=> Right 40

// no need to default the Left case anymore
data
  .either(identity, identity)
//=> 3

// effects of the inner type are applied immediately
const nested =
  Either.of(Maybe.Nothing)
//=> Right Nothing

const unnested =
  nested
    .chain(maybeToEither(0))
//=> Left 0

// Always maps, although the inner Maybe skips
nested
  .map(map(x => x + 1))        //=> Right Nothing (runs mapping)
  .map(map(x => x * 10))       //=> Right Nothing (runs mapping)
  .either(identity, identity)  //=> Nothing
  .option(0)                   //=> 0

// Never maps on a Left, just skips it
unnested
  .map(x => x + 1)             //=> Left 0 (skips mapping)
  .map(x => x * 10)            //=> Left 0 (skips mapping)
  .either(identity, identity)  //=> 0

import Either from 'crocks/Either'
import Maybe from 'crocks/Maybe'
import Async from 'crocks/Async'

import safeLift from 'crocks/Maybe/safeLift'
import maybeToAsync from 'crocks/Either/maybeToAsync'
import eitherToMaybe from 'crocks/Maybe/eitherToMaybe'
import compose from 'crocks/helpers/compose'
import isNumber from 'crocks/predicates/isNumber'

// Avoid nesting
// inc :: a -> Maybe Number
const inc =
  safeLift(isNumber, x => x + 1)

// using Function signature
// asyncInc :: a -> Async Number Number
const asyncInc =
  maybeToAsync(0, inc)

// using ADT signature to compose (extending functions)
// asyncInc :: a -> Async Number Number
const anotherInc =
  compose(maybeToAsync(0), inc)

// resolveValue :: a -> Async _ a
const resolveValue =
  Async.Resolved

resolveValue(3)                          // Resolved 3
  .chain(asyncInc)                       // Resolved 4
  .chain(anotherInc)                     // Resolved 5
  .chain(compose(maybeToAsync(20), inc)) // Resolved 6

resolveValue('oops')                     // Resolved 'oops'
  .chain(asyncInc)                       // Rejected 0
  .chain(anotherInc)                     // Rejected 0
  .chain(compose(maybeToAsync(20), inc)) // Rejected 0

// Squash existing nesting
// Just Right 'nice'
const good =
  Maybe.of(Either.Right('nice'))

// Just Left 'not so nice'
const bad =
  Maybe.of(Either.Left('not so nice'))

good
  .chain(eitherToMaybe) // Just 'nice'

bad
  .chain(eitherToMaybe) // Nothing