ts.data.either | Typescript implementation of the Either data type | Functional Programming library

As it was suggested in the comments section, types in for comprehension should be aligned and the compiler complains about that: you invoke flatMap on EitherT (implicitly via <-) and as a result return Future instead of expected EitherT.

You need to change return type and re-implement next method:

Try to specify type parameters explicitly

It seems that the problem is that the compiler is not able to infer the correct types for EitherT.leftT and EitherT.rightT.
You can fix those errors using explicit types like: EitherT.rightT[IntState, String], or if you only need one flatMap call, it seems doing it explicitly does work:

This works:

When you call EitherT.right(..) the compiler cannot figure out what the left type of your either should be. That's why the error message says it found Nothing instead of A. You need to help it out a bit.

As the error suggests, changing your wrapper to class EitherTWrapper [+L,R] (ei: EitherT[Future,L,R]) will fix your compilation errors.

Your error states that Nothing <: L, but class EitherT is invariant in type A. - this means that Nothing is a subtype of L, so declaring L is illegal since it implies you explicitly want L not its subtypes (i.e. L is invariant).

Declaring something as +L makes it covariant, making what you want possible. Read up more on variance in the scala docs: https://docs.scala-lang.org/tour/variances.html

The reason the below code (from the docs) works is because Scala's List is defined as List[+A], meaning that you can also pass in List[Cat] and List[Dog] to a function that takes a List[Animal]:

In a for-comprehension the type and the bias of the first step in the chain determines the type of all the rest of the steps in the chain have to be. Because Either is right-biased, we can only change the right type between the steps of the for-comprehension, as advised by @Krzysztof. For example,

Try single flatMap instead of nested for-comprehensions like so

But I was expecting it to be able to translate EitherT[F, SubOfA, B] as EitherT[F, SubOfA.asInstanceOf[A], B].

Being invariant means exactly that it isn't possible to "translate" this way: an EitherT[F, SubOfA, B] simply isn't an EitherT[F, A, B].

Now, a separate question is why the type for fail isn't inferred to be Fail despite an expected type for the whole fail.asLeftT[Future, Seq[Receiver#E]]. And the answer there is that Scala type inference just doesn't work that way; when typing expression.method(...), it will type expression first and can't make use of the expected return type of method.

You can still write them inline, but you need type ascription: