Can't define typeclasses for union and intersection types

[japgolly]

Compiler version

3.0.0-RC3

Minimized code

case class F[A]()

given F[Int] = F()
given F[Boolean] = F()

given [A, B](using F[A], F[B]): F[A | B] = F()
given [A, B](using F[A], F[B]): F[A & B] = F()

object Test:

  summon[F[Int | Int]]     // ok
  summon[F[Int | Boolean]] // error

  summon[F[Int & Int]]     // ok
  summon[F[Int & Boolean]] // error

Output

[error] -- Error: src/main/scala/a.scala:12:26 ---------------
[error] 12 |  summon[F[Int | Boolean]] // error
[error]    |                          ^
[error]    |ambiguous implicit arguments of type F[Int | Boolean] found for parameter x of method summon in object Predef.
[error]    |I found:
[error]    |
[error]    |    given_F_|[A, B](
[error]    |      /* ambiguous: both given instance given_F_Int and given instance given_F_Boolean match type F[A] */
[error]    |        summon[F[A]]
[error]    |    , 
[error]    |      /* ambiguous: both given instance given_F_Int and given instance given_F_Boolean match type F[B] */
[error]    |        summon[F[B]]
[error]    |    )
[error]    |
[error]    |But both given instance given_F_Int and given instance given_F_Boolean match type F[A].
[error] -- Error: src/main/scala/a.scala:15:26 ---------------
[error] 15 |  summon[F[Int & Boolean]] // error
[error]    |                          ^
[error]    |ambiguous implicit arguments of type F[Int & Boolean] found for parameter x of method summon in object Predef.
[error]    |I found:
[error]    |
[error]    |    given_F_&[A, B](
[error]    |      /* ambiguous: both given instance given_F_Int and given instance given_F_Boolean match type F[A] */
[error]    |        summon[F[A]]
[error]    |    , 
[error]    |      /* ambiguous: both given instance given_F_Int and given instance given_F_Boolean match type F[B] */
[error]    |        summon[F[B]]
[error]    |    )
[error]    |
[error]    |But both given instance given_F_Int and given instance given_F_Boolean match type F[A].
[error] two errors found

Expectation

It should compile. We need a way to generically define typeclasses for unions and intersection types.

I think what's happening is that, because union and intersection types are commutative, the implicit search correctly identifies that A | B can be reversed to B | A in order to satisfy its search. In this case at least, it doesn't matter which is chosen - they're identical so implicit search should just choose A | B.

[odersky]

That's currently beyond the scope of what's possible. These things are ambiguous according to the rules of implicit search in the language spec. Extending the language spec to allow looks non-trivial. It will probably require major research. Moving to discussions.

[joroKr21]

I thought so too initially, but commutativity means that we can't expect things to be broken down like this. You can use opaque type aliases though opaque type And[A, B] = A & B and opaque type Or[A, B] = A | B if you want to lose commutativity in this case.

[LPTK]

commutativity means that we can't expect things to be broken down like this

Yes, and it's not just commutativity. Idempotence, associativity, and subtyping are all things that make the result of destructuring types based on unions very much ill-defined. For instance, (A | B) | C is equivalent to (meaning it denotes the same type as) A | (B | C | A) | A0 where A0 <: A. So a naive destructuring approach would yield wildly different instances for equivalent types.