Type inference doesn't work correctly for union types used with extension method

[kpodsiad]

Compiler version

3.3.1

Minimized code

//> using scala "3.3.1"

trait Random[F[_]] {
  def element[T](list: Seq[T]): F[T] = ???
}

trait Monad[F[_]] {
  def map[A, B](fa: F[A])(f: A => B): F[B]
  def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B]
}

object Monad {
  extension [F[_]: Monad, A](fa: F[A])
    def map[B](f: A => B): F[B] = ???
    def flatMap[B](f: A => F[B]): F[B] = ???
}

sealed trait Animal
object Animal {
  object Cat extends Animal
  object Dog extends Animal
}

type Mammal = Animal.Cat.type | Animal.Dog.type
val mammals: List[Mammal] = ???

def work[F[_]](random: Random[F])(using mf: Monad[F]) = {
  val result: F[Mammal] =
    mf.map(fa = random.element(mammals))(a => a)

  val result2: F[Mammal] = Monad.map(random.element(mammals))(a => a)

  import Monad.*

  val result3: F[Mammal] = random
    .element(mammals)
    .map { a =>
       a // << a is an Animal, compilation error
    }
}

Output

There is a compilation error in result3

Found:    (a : Animal)
Required: Animal.Cat.type | Animal.Dog.type

Expectation

result3 works correctly, the same as 1 & 2, inferred type should be Cat | Dog or Mammal.

[dwijnand]

I'm not sure that this is a bug, despite it being unfortunate and a good argument being made on how those other variants work. Singleton types of non-case objects are very brittle - I believe if you make Cat and Dog case objects, then it should continue to work.

[mbovel]

I believe if you make Cat and Dog case objects, then it should continue to work.

I tried the following:

sealed trait Animal
object Animal {
  case object Cat extends Animal
  case object Dog extends Animal
}

But it results in the same error.

Is it what you meant?

Also, this seems to be a similar to #18551, isn't it? In both situations, the problem is that a union of case objects is widened to it parent type.

Setting the type parameter of element explicitly solves the problem:

    .element[Mammal](mammals)

[kpodsiad]

I'm fine with helping compiler a bit as I don't use union of case objects that often. However, it's a bummer that among many ways to do the same, results 1..3, the most popular one is not working as one expects.

If fixing it is problematic, can compiler suggests what to do in such cases? It would improve UX and help people who can't figure it out. Just throwing an idea, but probably cost outweighs benefits.

[dwijnand]

Also, this seems to be a similar to #18551, isn't it? In both situations, the problem is that a union of case objects is widened to it parent type.

Yeah, perhaps we can find where the TypeRef to Mammal is replaced by the simplified (and lossy) lub of the hard union, and make it not replace.

[kpodsiad]

simpler testcase

//> using scala "3.3.1"

sealed trait Animal
object Animal {
  case object Cat extends Animal
  case object Dog extends Animal
}

type Mammal = Animal.Cat.type | Animal.Dog.type
val mammals: List[Mammal] = ???

val result = mammals.head
val mammal: Mammal = result // << error