`Nothing` causes type lambda to be inferred in case of bounded type parameter

Compiler version

3.1.1

Minimized code

//> using scala "3.1.1"
trait Foo[+F[_], +A]:
  def flatMap[F2[x] >: F[x], B](f: A => Foo[F2, B]): Foo[F2, B]

def f(fa: Foo[Nothing, Int]): Foo[Nothing, Int] =
  fa.flatMap(_ => fa)

Output

[error] ./p.scala:6:3: Found:    Foo[[x] =>> Nothing, Int]
[error] Required: Foo[Nothing, Int]
[error]   fa.flatMap(_ => fa)
[error]   ^^^^^^^^^^^^^^^^^^^

Expectation

• Nothing to be inferred
• Maybe Nothing should be equivalent to [x] =>> Nothing?

Note if we use the trick from fs2 to define a special alias for Nothing, then both of those expectations are met:

type Pure[A] <: Nothing

def g(fa: Foo[Pure, Int]): Foo[Pure, Int] =
  fa.flatMap(_ => fa)

def h(fa: Foo[Pure, Int]) = // inferred as Foo[[x] =>> Pure, Int]
  fa.flatMap(_ => fa)

def i(fa: Foo[Pure, Int]): Foo[Pure, Int] =
  h(fa)

[smarter]

Yes, it seems like that should be doable.

[smarter]

type Pure[A] <: Nothing

Just type Pure[A] = Nothing works too, I believe using <: was only needed to work around Scala 2’s “fear of Nothing”.

Maybe Nothing should be equivalent to [x] =>> Nothing?

I’d be wary of doing that, it means we could end up forging a term whose type is a type lambda e.g. val x = ??? : [X] =>> Nothing, which is likely to break tons of assumptions in the compiler.