Union type too restrictive in inline match

[Adam-Vandervorst]

Compiler version

3.8.1

Minimized code

trait Dist[T]: 
  def sample(using rng: java.util.Random): T

inline def Uniform[F <: Float | Double | Int | Long](inline low: F, inline high: F): Dist[F] = new:
  override def sample(using rng: java.util.Random): F =
    inline compiletime.erasedValue[F] match
      case _: Float => rng.nextFloat(low, high)
      case _: Double => rng.nextDouble(low, high)
      case _: Int => rng.nextInt(low, high)
      case _: Long => rng.nextLong(low, high)

Output

        case _: Float => rng.nextFloat(): F
                         ^^^^^^^^^^^^^^^
Found:    Float
Required: F

where:    F is a type in method Uniform with bounds <: Float | Double | Int | Long

 Tree:

 rng.nextFloat()

 I tried to show that
   Float
 conforms to
   F
 but none of the attempts shown below succeeded:

   ==> Float  <:  F
     ==> Float  <:  Nothing in frozen constraint  = false

 The tests were made under the empty constraint

Expectation

I expect the constraint not to be empty, specifically for the type match to constrain F to Float.

Partial workaround

inline (low, high) match
        case (low: Float, high: Float) => rng.nextFloat(low, high)

does work for constraining the inputs, but this still fails on the return type without asInstanceOf

[SethTisue]

Note that a similar value-level match doesn't compile either:

scala> def foo[F <: Float | Double | Int | Long](low: F): F =
         low match
           case _: Float => 0F
       
-- [E007] Type Mismatch Error: -------------------------------------------------
3 |    case _: Float => 0F
  |                     ^^
  |Found:    (0.0f : Float)
  |Required: F
  |
  |where:    F is a type in method foo with bounds <: Float | Double | Int | Long
  |
  | longer explanation available when compiling with `-explain`
1 error found

But the compiler is right here, since F might be e.g. Float | Double, it isn't constrained to specifically be one of the alternatives (withdrawn, see @s5bug's remark below)

What's your reasoning that it's different with inline?

[s5bug]

If F =:= (Float | Double) then Float <: F and it should compile, I would think.

[s5bug]

The issue could be that F is a singleton type, then 0F is not a subtype of it.

[SethTisue]

(...as an aside, in general these sorts of attempts to use union types as a substitute for typeclasses seem to (almost?) always run aground...)