Another GADT typechecking error

Compiler version

3.0.2-RC1

Minimized code

class Module[*[_, _]] {
  sealed trait Box[A]

  case class Box2x2[A, B, C, D](value: (A * B) * (C * D)) extends Box[(A * B) * (C * D)]

  def unbox2[X, Y](box: Box[X * Y]): (X * Y) =
    box match {
      case Box2x2(v) => v // we know that v has type ((a * b) * (c * d))
                          // for some types a, b, c, d,
                          // and that ((a * b) * (c * d)) = (X * Y),
                          // so v does have the expected return type (X * Y)
    }
}

Output

% ~/scala3-3.0.2-RC1/bin/scalac boxes.scala 
-- [E007] Type Mismatch Error: boxes.scala:8:24 --------------------------------
8 |      case Box2x2(v) => v // we know that v has type ((a * b) * (c * d))
  |                        ^
  |       Found:    (v : A$1 * B$1 * (C$1 * D$1))
  |       Required: X * Y
  |
  |       where:    * is a type in class Module with bounds <: [_, _] =>> Any

longer explanation available when compiling with `-explain`
1 error found

Expectation

The code should typecheck, as per the explanation in the code comment.

[dwijnand]

#fixed-in-scala2 😛

$ pbpaste > boxes.scala
$ m boxes.scala
class Module[*[_, _]] {
  sealed trait Box[A]

  case class Box2x2[A, B, C, D](value: (A * B) * (C * D)) extends Box[(A * B) * (C * D)]

  def unbox2[X, Y](box: Box[X * Y]): (X * Y) =
    box match {
      case Box2x2(v) => v // we know that v has type ((a * b) * (c * d))
                          // for some types a, b, c, d,
                          // and that ((a * b) * (c * d)) = (X * Y),
                          // so v does have the expected return type (X * Y)
    }
}
$ scalac boxes.scala
$

[LPTK]

Yes, though you actually need to phrase it in a way that’s a bit of more general:

abstract class Eq[A, B]:
  type Ev >: B | A <: A & B

def toEqF[A, B, F[_]](eq: Eq[A, B]): Eq[F[A], F[B]] =
  new Eq[F[eq.Ev], F[eq.Ev]]{}

(This Ev member of course still works for the original problem in this issue.)