Youssef Shoaib

But it's meant to handle `Left` too, so at the very least it'd be something like `(A, B?) -> Ior` no?

It doesn't need to generate the right from the initial right though. The type `R` may be known to the caller, so e.g. something like `foo.handleErrorWith(...) { Ior.Right(42) }`

I mean, I think we can safely add such an overload (overlord resolution will take care of it). I'm tryna think of what the signature of f would be though....

I don't wanna shut this out completely since maybe it's useful for someone. I think `Ior` doesn't receive as much love as others and maybe it should. If you're happy...

``` public inline fun Ior.handleErrorWith(f: (A, B?) -> Ior): Ior { contract { callsInPlace(f, InvocationKind.AT_MOST_ONCE) } return when (this) { is Left -> f(value, null) is Right -> this is...

``` val ior = ... ior.leftOrNull?.let { left -> val right = ior.rightOrNull } ``` Gives you the same type of info, but without needing to stay within Ior.

Only API breaks are in RaiseAccumulate experimental apis

This would be rather nice to have! To clarify, would captures to such named effects be possible? ```effekt def foo(): Unit / {out: emit[Int], in: read[Byte], log, Exception[WrongFormat]} = {...

I'm not the most familiar with Optics, but I feel like we should just generate code that looks like: ```kotlin fun Test.Companion.value(): Lens = arrow.optics.Lens( get = { test: Test...

This is [mentioned](https://github.com/e2e4b6b7/KEEP/blob/subtyping-reconstruction/proposals/subtyping-reconstruction.md#how-does-this-compare-to-the-scalas-algorithm) in the subtype reconstruction keep. Scala allows such inconsistent type parameters, but Kotlin doesn't. That `Weird` example doesn't even compile in Kotlin: ```kotlin interface Expr interface IntList:...