SIP-56, to be realized in Scala 3.4.0, introduces some new restrictions to match type reduction.

As it stands, the type-safe zero-overhead physical dimensions library I wrote makes use of match types that will become illegal (according to Scala 3.4.0-RC1 and Nightly compilers).

Can anyone think of a way to make it compliant with SIP-56?

Below is a minimal toy version to illustrate the issue (Scastie link):

```
object OpaqueScope:
/**
* Type that keeps track of the dimension of a quantity.
*
* @tparam Length exponent for the length component of the dim
* @tparam Frequency exponent for the frequency component of the dim
*/
opaque type Dim[Length <: NatT, Frequency <: NatT] = Double
// Physical quantity representing one metre, aka SI unit for length
val metre: Length = 1.0
// Physical quantity representing one Hertz, aka SI unit for frequency
val hertz: Frequency = 1.0
extension[L <: NatT, F <: NatT] (x: Dim[L, F])
// Generic function to multiply any two physical quantities.
def *[Ly <: NatT, Fy <: NatT](y: Dim[Ly, Fy]): Dim[L, F] * Dim[Ly, Fy] = x * y
end OpaqueScope
import OpaqueScope.*
// Multiplies the two given Dims.
type *[D1, D2] = D1 match
case Dim[l1, f1] => D2 match
case Dim[l2, f2] => Dim[Sum[l1, l2], Sum[f1, f2]]
// Convenience alias for the type of physical quantities representing lengths
type Length = Dim[Succ[Zero], Zero]
// Convenience alias for the type of physical quantities representing frequencies
type Frequency = Dim[Zero, Succ[Zero]]
// Convenience alias for the type of physical quantities representing velocities
type Velocity = Length * Frequency
// Physical quantity multiplication example
val oneMetrePerSecond: Velocity = metre * hertz
// Type-level natural numbers
sealed trait NatT
case class Zero() extends NatT
case class Succ[N <: NatT](n: N) extends NatT
// Type-level natural-number sum
type Sum[M <: NatT, N <: NatT] <: NatT = (M, N) match
case (_, Zero) => M
case (Zero, _) => N
case (Succ[predM], Succ[predN]) => Succ[Succ[Sum[predM, predN]]]
```

The issue is that `*`

— the generic function to multiply any two physical quantities — has to be defined within `OpaqueScope`

in order to be able to treat its parameters as doubles.

On the other hand, since it is generic, its return type has to be computed using a match type, which is done with the type-level function `*`

.

However, since `Dim`

is synonymous with `Double`

within `OpaqueScope`

, according to SIP-56, `Dim[L, F] * Dim[Ly, Fy]`

cannot be reduced, leading to a compile-error.

Any thoughts would be greatly appreciated.

Note: this question is a continuation of the conversation with @sjrd that started on this issue.