Match type not simplified in return position

Compiler version

3.1.1, 3.1.2-RC1

Minimized code

import scala.compiletime.ops.int.*

type Fill[N <: Int, A] <: Tuple = N match {
  case 0 => EmptyTuple
  case S[n] => A *: Fill[n, A]
}

sealed trait SeqToTuple[N <: Int] {
  def apply[A](s: Seq[A]): Fill[N, A]
}
implicit val emptyToZero: SeqToTuple[0] = new SeqToTuple[0] {
  override def apply[A](s: Seq[A]): EmptyTuple = EmptyTuple
}
implicit def successorToSuccessor[N <: Int](implicit pred: SeqToTuple[N]): SeqToTuple[S[N]] = new SeqToTuple[S[N]] {
  override def apply[A](s: Seq[A]): Fill[S[N], A] =
    s.head *: pred(s.tail) // Scala doesn't know that `A *: Fill[N, A]` = `Fill[S[N], A]` for some reason
}

Output

Found:    A *: Fill[N, A]
Required: Fill[compiletime.ops.int.S[N], A]

where:    N is a type in method successorToSuccessor with bounds <: Int

Expectation

Scala recognizes that Fill[S[N], A] = A *: Fill[N, A] (as it is a case of the match type) and lets the program compile.

[bishabosha]

I think really the issue is that 0 and S[n] are not treated like independent class types, for example, if we substitute Int for some Nat enum then the example works unchanged:

enum Nat {
  case Zero
  case Succ[N <: Nat](pred: N)
}

object Nat {
  type FromInt[I <: Int] <: Nat = I match {
    case 0 => Nat.Zero.type
    case compiletime.ops.int.S[n] => Nat.Succ[FromInt[n]] 
  }
}

/// begin of example

import scala.compiletime.ops.int.*

type Fill[N <: Nat, A] <: Tuple = N match {
  case Nat.Zero.type => EmptyTuple
  case Nat.Succ[n] => A *: Fill[n, A]
}

sealed trait SeqToTuple[N <: Nat] {
  def apply[A](s: Seq[A]): Fill[N, A]
}
implicit val emptyToZero: SeqToTuple[Nat.Zero.type] = new SeqToTuple[Nat.Zero.type] {
  override def apply[A](s: Seq[A]): EmptyTuple = EmptyTuple
}
implicit def successorToSuccessor[N <: Nat](implicit pred: SeqToTuple[N]): SeqToTuple[Nat.Succ[N]] = new SeqToTuple[Nat.Succ[N]] {
  override def apply[A](s: Seq[A]): Fill[Nat.Succ[N], A] =
    s.head *: pred(s.tail) // Scala doesn't know that `A *: Fill[N, A]` = `Fill[S[N], A]` for some reason
}
                                                                                                                                                    
// scala> summon[SeqToTuple[Nat.FromInt[3]]](List(1,2,3,4,5))
// val res1: Int *: Int *: Int *: EmptyTuple = (1,2,3)

[s5bug]

Awesome! Thanks for the insights.