General type projections through match types

Language Design
1

In the recent discussion about scala 3 migration, the topic of dropped general type projections was brought up.

I understand the general reason for unsoundness, but we have a working and generic enough alternative through match types.

trait Request {
  type Result 
}

object Request {
  type Aux[T] = Request { type Result = T }
  type Result[T <: Request] = T match {
    case Aux[s] => s
  }
}

def foo[T <: Request]: Request.Result[T]

I’m wondering if we could make this pattern more streamlined? Could we use the same logic behind # syntax for type projection? Hence support it again for any type?

2

With path dependent types, you can do the following:

class Request {
  type Result 
}

def foo[T <: Request](t: T): t.Result = ???

To me this makes more sense, as you usually want to interact with values at some point, if only to drive type inference
And if you don’t need a value at runtime, then you could use erased (once it’s official): Erased Definitions

My question is: Are there cases where this is not enough/worse ?