Match types are (intersection|union)-order-sensitive

[abgruszecki]

Match types allow telling apart intersection types which differ only in the order of elements. We probably don't want to allow doing that.

object Test {                                                                                                                                                                                                                                                                      
  class Inv[T]
  type M[t] = t match {
    case Inv[u] => u
  }
  def foo: M[Inv[Int] & Inv[String]] = ""
  def bar: M[Inv[String] & Inv[Int]] = 0
}

A possible fix would be to use GADTFlexible mode when reducing match types, which would not put any constraints on u from Inv[Int] & Inv[String] <: Inv[u].

[abgruszecki]

Weirdly enough, the following does reduce:

scala> object Test {                                                                                                                                                                                                                                                                      
     |   type M[t] = t match {
     |     case u | v => u
     |   }
     |   def foo: M[Int | String] = ""
     | }
// defined object Test

but the following does not:

scala> object Test {                                                                                                                                                                                                                                                                      
     |   type M[t] = t match {
     |     case u & v => u
     |   }
     |   def foo: M[Int & String] = ""
     | }
5 |  def foo: M[Int & String] = ""
  |                             ^^
  |                             Found:    String("")
  |                             Required: Test.M[Int & String]

[panacekcz]

Test.M[Int & String] defined using case u & v also reduces to Int & String - just the error message shows the unreduced type, but so would it for the variant with case u | v if there was a type mismatch.