.toEither()

# arrow

[pakoito]

.toEither()

[sam]

Ok that's great. I am doing this:

Validated.applicative(NonEmptyList.semigroup<Any?>()).map(x, y) { (x, y) ->
              x.read(y)
            }.fix().toEither()

[sam]

But I end up with a really weird sig

[sam]

I've got an Either, with errors on the left (good), on the right I have another validatednel

[sam]

Basically I want the result of x.read(y) to completely replace the outside value (if it's executed)

[sam]

This seems to do it, but it seems quite redundant to be returning itself in the fold:

Validated.applicative(NonEmptyList.semigroup<ConfigFailure>()).map(x, y) { (x, y) ->
              x.read(y)
            }.fix().fold(
                { it.invalid() },
                { it }
            )

[pakoito]

weird

[pakoito]

I’d need to touch the code, dunno top of my head

[sam]

ok

[pakoito]

ooooh I see

[pakoito]

x.read(y) is another Validated

[sam]

yep

[sam]

so what I want is kind of Validated.applicative(NonEmptyList.semigroup<ConfigFailure>()).ifNotErrorThenUseLambdaResult(x, y) { }

[pakoito]

yeah what you’re doing is the right thing to do

[pakoito]

flatten it

[pakoito]

then change to either

[sam]

the fold kind of seems redundant

[sam]

since it's just wrapping

[sam]

This is what I was incorrectly imagining as flatMap the other day

[pakoito]

the fold isn’t redundant, you’re flattening something that’s not sequential

[sam]

right

[sam]

redundant in the sense that one of the lambdas is just returning itself

[sam]

Something like this would be good

Validated.applicative(NonEmptyList.semigroup<ConfigFailure>()).apply(x, y) { (x, y) ->
              x.read(y)
            }.fix()

[sam]

.apply (or whatever) could just keep the Invalid, or if it's a Valid, execute the lambda and take that result (which itself would be a Valid or Invalid)

[pakoito]

that¡s two steps