it’s basically an effect in one side, but before you get to MonadError

that’s why it’s wrapped on a Kind<F, (A) -> B>

so it’s the classic “log and continue”

but the paper has other examples

any alternatives for implementation below? flatMap would be really useful

fun <A, B, C> Kind<F, Either<A, B>>.branch(fl: Kind<F, (A) -> C>, fr: Kind<F, (B) -> C>): Kind<F, C> =
      map { it.fold(
        {l -> just(Left(l)).select(fl)},
        { r -> just(Left(r)).select(fr) } )
      }

current not compiling as it returns

Kind<F, Kind<F, C>>

select's signature is

fun <A, B> Kind<F, Either<A, B>>.select(f: Kind<F, (A) -> B>): Kind<F, B>

should say, F is an Applicative so have all relevant functions at hand

let me try 😄

if you need flatMap then the only possible path is to take it off Monad

unless you can find an implementation that does not require monad bind

there’s one

also flatMap isn't really part of monad it's just a convenience

let me find it 😄

right on

🙂 thanks, yup there is a way but my OCaml translation skills aren't so good. I've been too lazy sticking to translating Scala to Kotlin

I’m flunking here too lol

gimme some minutes

Untitled.txt

it’s even nice once you understand that they’re just nesting the either, and then unwrapping it twice

fucking symbols getting on the way

{ a: A -> ff(a).right() }

this could be

ff.andThen(::Right)

for example

Untitled.txt

hah, I was wading through hoogle figuring out applicative symbols. thats awesome. will add

andthen

too late 🙂 thanks

the symbol’s there -.-

Yeh, I was going back over applicative stuff in the Haskell code. I understand the syntax a tiny bit more than ocaml

noted

😄