Type coercion for union types in contravariant position

[AndycptOrg]

I've noticed that if I construct a function like the following:

def foo[A, B](a: A=>Boolean, b: B=>Boolean): (A|B)=> Boolean =
(ab: A|B) => ab match {
case a1:A => a(a1)
case b1:B => b(b1)
}

Where A and B are in contravariant positions.

Then when I provide A and B to be a subtype of a common supertype C(like a sealed trait), A <: C, B <: C, such that A | B would cover the entirety of C. (e.g. A: Some[P], B: None.type, C: Option[P])

def bar(a: None.type) = false

def baz(b: Some[Int]) = true

val b = foo(bar, baz)

Then Scala would give b to be (None.type | Some[Int]) => Boolean, which is expected. But when I try to type b to be Option[Int] => Boolean, the compiler would throw an error, claiming it should be a Boolean when it found what was give before.

I bring up the contravariant case because for the covariant case, type coercion does occur and Scala allows b to be coerced into C type, seeming to imply that the C type is somehow a subtype of the union of its "case" types within the implementation.

Would it make sense for the union of all case types of a sealed trait to have/ automatically derive some type evidence between them instead of a subtyping relation?

[bishabosha]

yes Some[Int] | None.type <: Option[Int], and Option[Int] >: Some[Int] | None.type so therefore Option[Int] cannot be passed to Some[Int] | None.type,

so the error in your scenario is:

-- [E007] Type Mismatch Error: -------------------------------------------------
5 |val b: Option[Int] => Boolean = foo(bar, baz)
  |                                ^^^^^^^^^^^^^
  |                                Found:    None.type | Some[Int] => Boolean
  |                                Required: Option[Int] => Boolean
  |
  | longer explanation available when compiling with `-explain`

which is confirmed by

scala> summon[((Some[Int] | None.type) => Boolean) <:< (Option[Int] => Boolean)]
-- [E172] Type Error: ----------------------------------------------------------
1 |summon[((Some[Int] | None.type) => Boolean) <:< (Option[Int] => Boolean)]
  |                                                                         ^
  |Cannot prove that Some[Int] | None.type => Boolean <:< Option[Int] => Boolean.
1 error found

so the arguments foo and bar are pretty fixed and so A and B type params must be typed as concrete Some or None cases.

what facilities exist? i guess implicit conversion which might be what you are asking for, to convert a "sum" type into the union of its child instantiations - but of course this isnt very general and only works when the union type covers every case

im also sure that the type theory experts would not be happy to break the lattice and make Option <:< Some | None

[AndycptOrg]

Oh, ok!
I guess I am just asking for the case where the union type covers every case of the sum type. In that case, would there be any theoretical implications if we allowed the sum type and the union types to be equivalent types for just that case?

[bishabosha]

I won't comment on the theory, however it could be possible to include a facility e.g. an intrinsic type Split[T] that can take a type T and return that union of the child cases? and a term equivalent for manual conversion def split[T](x: T): Split[T] = x.asInstanceOf[Split[T]]