Awaiting on `Future` via suggested extensions is not very practical with type hierarchies

[bdmendes]

The following example should be illustrative:

class A
class B extends A

def foo: Future[A] = ???

Await.result(foo, 1.second) === new B // ok

Await.result(foo, 1.second) must beEqualTo(new B) // ok

foo must beEqualTo(new B).await // does not compile
                                // Found: org.specs2.matcher.EqualityMatcher[B]
                                // Required: org.specs2.matcher.Matcher[A]

This makes testing async APIs tedious, as one needs to:

foo must beEqualTo[A](new B).await

I am not sure what's the best way to fix it. I tried:

extension [F[_] <: Matcher[_], T](m: F[T])(using ee: ExecutionEnv) {
  def awaitMine: F[Future[T]] = ???
}

But the problem is not that the extension is not the generic type, but rather, I think, that the compiler does not know that it needs to widen B to A before attempting the extension.

[bdmendes]

As a thought experiment, I tried:

extension [T](m: Matcher[T])(using ee: ExecutionEnv) {
  def awaitMine[U >: T]: Matcher[Future[U]] =
    m.asInstanceOf[Matcher[U]].await
}

This works when the lhs matches the rhs (eg a Base that's actually Child1 compared to Child1), but not when the lhs is actually Child2 (resulting in a ClassCastException rather than the expected test failure).

[etorreborre]

That's annoying indeed. I can't work on this right now but maybe something needs to be done with the must method as well.

[bdmendes]

Yeah, I thought about providing a Conversion from Matcher[T] to Matcher[U] if U >: T, but then all strong safety in v5 would be thrown away (would be able to move up to Any everywhere...). That might work however if scoped to the must parameter, as in, if I need a Matcher[U] and have a Matcher[T], I might derive it in the must implementation somehow (maybe throw and catch a failure if U turns out not to be a T at runtime?). Not really sure; I'm not familiar with all the internals here, but it would be great to see something like this.