I have some functions that can return either a successful result, or an error, so I originally went with Either, but I want to accumulate the errors. So I switched to a ValidatedNel, but now I want to flatMap on that. What's the solution when you want to treat the result as a monad, but you also want to accumulate errors ?

if you think about it you cannot do both

if B depends on A, and A doesn’t produce a value, you’ll never be able to create B

so you won’t accumulate the errors of B

So if I have an Invalid and I call map or flatMap I want the invalid to continue

if I have a valid and I call flatMap then I want the result of the function

so why can't it work

InvalidNel<String, Int>(Nel("Some error")).map { a: Int -> <some_function_here> }

and

InvalidNel<String, Int>(Nel("Some error")).flatMap { a: Int -> <some_function_here> }

what is possible is to run several functions as long as they’re independent from each other

and that’s what the

appicative().map

does: independent execution where each value you pass doesn’t depend on the result of the others so they’re always executed

they’re still run sequentially and accumulate errors. Maybe they could have been called

merge

or something.

also, totally a coincidence but this may be useful to you too 😄 https://twitter.com/pacoworks/status/1135117279732088833

MonadError catch should not exist based on throwable, we will probably remove that because things that throw are effects and therefore should be suspend which can only be handled in the effect hierarchy

Wait, so use MonadDefer instead of MonadError?

oh MonadError is for computations that can throw exceptions, MonadDefer is for computations with IO-type side effects

Monad error is not for computations that can throw but for computations that wish to represent their error with a custom error. MonadThrow is when the custom error is a Throwable and this will probably change once we add custom errors to the effect hierarchy and bifunctor IO

MonadDefer is currently fixed to Throwable but this will change

Inside a binding block, is it the destructuring that does the magic

Can you quickly show me how to convert a

List<Either<A,B>>

to two seperate lists of As and Bs in an arrow way ?

Untitled.kt

@sam ^^^

not sure what a good term is

and this can probably be generalized to all foldables for which a Monoid instance exists

partition() maybe

as a name

but awesome thanks

I found the equivalent function in haskell for

[Either a b] -> ([a], [b])

It’s called

partitionEither

but it’s fixed to lists. This can further generalized to Foldable and it’d be more useful when we have type classes:

cool