Hmm, looks like Either's flatMap is not conforming...

# arrow

[Marius Kotsbak]

Hmm, looks like Either's flatMap is not conforming to Scalas wrt. left type: https://arrow-kt.io/docs/apidocs/arrow-core-data/arrow.core/flat-map.html vs https://www.scala-lang.org/api/2.12.0/scala/util/Either.html#flatMap[AA%3E:A,Y](f:B=%3Escala.util.Either[AA,Y]):scala.util.Either[AA,Y] Scalas left just needs to be AA >: A, whereas in ArrowKt it needs to be the same.

[Marius Kotsbak]

If it works with Kotlin, shouldn't Arrow do the same? To allow different error types sharing a common superclass.

[stojan]

Kotlin can do the same: https://github.com/LordRaydenMK/fpscala.kt/blob/9131afdc19299e645656d4aba0423d696cff8493/src/main/kotlin/chapter4/either/Either.kt#L16

[Marius Kotsbak]

Ok, so let's do it like that? 🙂

[stojan]

I don't see why not.... @Marius Kotsbak would you like to do a PR? 🙂

[Marius Kotsbak]

I could try yes 🙂

[Marius Kotsbak]

Should try to add a test that indicate a problem today first.

[simon.vergauwen]

Yes, sadly there is no function variance in Kotlin 😞 So they all need to be defined as extension functions when it's desired.

[Marius Kotsbak]

@simon.vergauwen hmm, is that any difference to Scala?

[simon.vergauwen]

The difference is quite nuanced. In Scala it's still a concrete (virtual) method afaik, whilst in Kotlin this results in a static method. Additionally, such a static method requires an explicit (or wildcard) import. This also means there is an impact on IDEA suggesting the method since concrete methods resolve faster.

[stojan]

The current implementation in Arrow is also an extension function...

[simon.vergauwen]

Is the fourth generic param needed in that case? 🤔 fun <A, B, C> EitherOf<A, B>.flatMap(f: (B) -> Either<A, C>): Either<A, C>
I can call flatMap on Either<AA, B> where AA is a subtype of A, no?

[Marius Kotsbak]

Yes, but not with a supertype of A.

[Marius Kotsbak]

Let's say you have ModuleError. And then Call1Error : ModuleError and Call2Error : ModuleError. Flatmap should then give ModuleError as left type.

[simon.vergauwen]

Of course.

[simon.vergauwen]

narrowing instead of widening.

[Marius Kotsbak]

Look at Scaladoc, it's the opposite.

[simon.vergauwen]

Yes, I got the variance symbol mixed up 😅 Should've looked at Stojans snippet

[Marius Kotsbak]

I guess the result is that it widens to the common ancestor, which might be Any (at least in Scala)

[Marius Kotsbak]

Hmm, need to verify, but this seems to work:

"Test" {
      open class TestSuper
      class TestSub1 : TestSuper()
      class TestSub2 : TestSuper()

      val res = Either.left(TestSub1()).flatMap { Either.left(TestSub2()) }
    }

IntelliJ says res has left type TestSuper

[stojan]

so it's already working as the Scala version?

[Marius Kotsbak]

Looks like it, but what magic makes it do, I'm not sure about.