Can't use MonadError syntax for EitherT

[wedens]

With introduction (#1644) of prioritised MonadError instance for F: MonadError in EitherT[F, E, A], it's now impossible to use MonadError syntax for handling E.
It makes it difficult to upgrade to 1.0.0-RC1 as this syntax is used quite a bit in a project.

implicit val merr: MonadError[IO, Throwable] = ???
type M[A] = EitherT[IO, Error, A]
val a: M[A] = ???
a.ensure(Error)(predicate) // type mismatch: found Error, required Throwable

[wedens]

Actually I still have this issue with handleErrorWith instead of ensure.

val e: EitherT[ConnectionIO, A, B] = ???
e.handleErrorWith(1) // required: Throwable => EitherT[ConnectionIO,A,B]
// [error]  found   : A => cats.data.EitherT[doobie.ConnectionIO,A,B]
// [error]  required: Throwable => cats.data.EitherT[doobie.ConnectionIO,A,B]
//[error]         e.handleErrorWith((a: A) => EitherT.left(a.pure[ConnectionIO]))
e.handleErrorWith((a: A) => EitherT.left(a.pure[ConnectionIO]))

[kailuowang]

@wedens not sure I fully understand your second example, were those error caused by
e.handleErrorWith(1)
or e.handleErrorWith((a: A) => EitherT.left(a.pure[ConnectionIO]))?
Is your A abstract in this usage?

[kailuowang]

it's just type class syntax extension cannot differentiate the two instance available:
MonadError[EitherT[ConnectionIO, A, ?], A] and MonadError[EitherT[ConnectionIO, A, ?], Throwable], right now the latter takes higher precedence.
A quick work around before we fix in Cats would be add a high priority instance in the local scope.

implicit val me =  MonadError[EitherT[ConnectionIO, A, ?], A]
e.handleError((a:A) => someB)

I see 3 options to fix it in Cats.

1. A relatively easy quick fix in Cats would be just flipping the priority sequence between the two instance, so that the syntax goes back to the behavior prior to 1.0-RC1. Then if user need the MonadError syntax with the other MonadError instance (namely MonadError[EitherT[ConnectionIO, A, ?], Throwable] in this example), they would need to do the same work around as above, i.e. create a local implicit instance that takes higher precedence.
2. make the MonadError[EitherT[ConnectionIO, A, ?], Throwable] no longer implicit, if user needs it, they have to explicitly call a method to get it.
3. duplicate all the MonadError syntax methods in EitherT that is parameterized to help type inference. E.g.

def handleError[E](f: T => E)(implicit ME: MonadError[EitherT[F, L, ?], E]) = ME.handleError(this)(f)

This is likely to get rid off the ambiguity, but I haven't test it.

cc @leandrob13 @peterneyens @LukaJCB