Use of Either and returning the error immediately

Question

I have a function which returns an instance of Either where the Left side represent the exception / error, while the second side stores the return value.

If the Either instance has been Left instantiated to the Error branch I want to return immediately. If the instance has been Right instantiated I want to wrap that in a Maybe and continue on (as it comes into the function as a Maybe, and only gets looked up if it is Nothing).

This is working per my test cases:

1. isNothing being passed in :: lookup is in error
2. isNothing being passed in :: lookup is successful
3. isJust(22) being passed in (lookup doesn't execute)

The code feels OK, but I don't supect I may be missing sme of the finer points of the Folktale data.either library.

// from data.monad
const someValue = Maybe.Nothing()

// ...snip...

if (someValue.isNothing) {

    // from data.either :: Either.Left | Either.Right
    const possiblySomeValue = yield lookupSomeValue()
    if(possiblySomeValue.isLeft) {
        return possiblySomeValue
    } else {
        someValue = Maybe.Just(possiblySomeValue.get())
    }
}

I am combining ES6 (Node 4.1) with Folktale: data.either and data.maybe. My goal is really elevating my understanding in how to write properly in this style

---

update the problem is a little more complex I ahve back to back independent lookups, which I feel could be chained together:

// from data.monad
const someValue = Maybe.Nothing()

// ...snip...

if (someValue.isNothing) {

    // from data.either :: Either.Left | Either.Right
    const possiblySomeValue = yield lookupSomeValue()
    if(possiblySomeValue.isLeft) {
        return possiblySomeValue
    } else {
        someValue = Maybe.Just(possiblySomeValue.get())
    }
}

// from data.monad
const someValue2 = Maybe.Nothing()

// ...snip...

if (someValue2.isNothing) {

    // from data.either :: Either.Left | Either.Right
    const possiblySomeValue2 = yield lookupSomeValue2()
    if(possiblySomeValue2.isLeft) {
        return possiblySomeValue2
    } else {
        someValue2 = Maybe.Just(possiblySomeValue2.get())
    }
}

Its the back to back occurances whcih make the code super ugly...

Answer 1

This is the current state of my code which I think is better. First be able to convert the Maybe to an either, to allow me to chain / orElse with transformations (Maybe.orElse does not allow take a function, whereas the Either.orElse does take a function for the transformation)

const maybeToEither = function(maybe) {
    if (maybe.isNothing) {
        return Either.Left(undefined)
    } else {
        return Either.Right(maybe.get())
    }
}

then, since I ma unpackaging the Maybe.Just into the Either.Right as part of the conversion, I simply need to provide the orElse transformation.

const someValue = maybeToEither(maybeSomeValue).orElse(function(ignore){
    return lookupSumValue()
}).get()

Blending into my actual problem, with generators lead to a slightly ugglier solution. lookupSomeValue is a generator function, so we need to yield. Also since the value is used in multiple places we want to force this into a value with get.

const someValue = (yield maybeToEither(maybeSomeValue).orElse(function(ignore){
    return lookupSumValue()
})).get()

so when repeated the code isn't nearly as bad as my original solution -

const someValue = (yield maybeToEither(maybeSomeValue).orElse(function(ignore){
    return lookupSumValue()
})).get()

const someValue2 = (yield maybeToEither(maybeSomeValue2).orElse(function(ignore){
    const someRandom = getRandom()
    return lookupSumValue2(someRandom)
})).get()

I am still looking for a more concise grammar. Will update with another solution if I find one.

Answer 2

Maybe (pun fully intended) a better approach

const someValue = (yield maybeToEither(maybeSomeValue).cata({
    Left: lookupSumValue,
    Right: yieldableRight})).get()

with these two helper functions

const yieldableRight = function(value){
    return function*(){ return Either.Right(value) }
}

const maybeToEither = function(maybe) {
    if (maybe.isNothing) {
        return Either.Left(undefined)
    } else {
        return Either.Right(maybe.get())
    }
}

Where lookupSomeValue is in the form (a function that returns a Generator):

const lookupSomeValue = function(){
    return ((function *(){
        return 10
    })())
}

The problem is that the Right side needs to return something that is yieldable. For some reason Koa/Co is choking on the Either.Right() (even though Objects are yieldable), as a yieldable - so I return a generator that returns the value. I get that (I don't understadn whay I can't yield on the Either.Right, but thats a different problem).

I don't understand why the Right side needs to be wrapped back up in an Either, while the Left side doesn't.