Scala 3：类型化元组压缩

我正在尝试将元组压缩在一起并使用匹配类型来获取生成的压缩的确切类型。我有一个匹配类型和功能：

  type Z[A <: Tuple, B <: Tuple] <: Tuple = (A, B) match
    case (EmptyTuple, EmptyTuple) => EmptyTuple
    case (a *: as, b *: bs) => (a, b) *: Z[as, bs]

  def z[A <: Tuple, B <: Tuple](a: A, b: B): Z[A, B] = (a, b) match
    case (EmptyTuple, EmptyTuple) => EmptyTuple
    case (ah *: at, bh *: bt) => (ah, bh) *: z(at, bt)

然而，这两种情况都在z()结果出现错误：Found: EmptyTuple.type Required: test.Tuples.Z[A, B] and Found: (Any, Any) *: test.Tuples.Z[Tuple, Tuple] Required: test.Tuples.Z[A, B]， 分别。我本以为这将是匹配类型的一个非常简单的应用，但显然我错了。我在这里缺少什么？

我还想限制匹配类型和功能z()具有相同长度的元组（例如如何无形'Length可以在 scala 2) 中使用，但也许这是一个单独的问题。

EDIT:

我设法得到了这个功能z()使用显式转换，但我仍然认为必须有一种方法可以避免这种情况：

  def z[A <: Tuple, B <: Tuple, M <: Int](a: A, b: B): Z[A, B] = (a, b) match
    case (ah *: at, bh *: bt) => ((ah, bh) *: z(at, bt)).asInstanceOf[Z[A, B]]
    case (EmptyTuple, EmptyTuple) => EmptyTuple.asInstanceOf[Z[A, B]]

另外，我能够得到该函数的长度方面z()以及，但我很想知道是否有一个更清晰/更简洁的方法来实现这一点（也许不需要定义L) 和 b) 如果有办法将类型参数限制为Z是相同长度的元组：

  type L[T <: Tuple] <: Int = T match
    case EmptyTuple => 0
    case _ *: t => 1 + L[t]

  type Z[A <: Tuple, B <: Tuple] <: Tuple = (A, B) match
    case (EmptyTuple, EmptyTuple) => EmptyTuple
    case (a *: as, b *: bs) => (a, b) *: Z[as, bs]

  def z[A <: Tuple, B <: Tuple, M <: Int](a: A, b: B)(using L[A] =:= L[B]): Z[A, B] = (a, b) match
    case (ah *: at, bh *: bt) => ((ah, bh) *: z(at, bt)).asInstanceOf[Z[A, B]]
    case (EmptyTuple, EmptyTuple) => EmptyTuple.asInstanceOf[Z[A, B]]

  println(z(1 *: true *: EmptyTuple, "seven" *: 9.8 *: EmptyTuple)) // <-- correctly zips tuples: ((1,seven),(true,9.8))

//    println(z(1 *: EmptyTuple, "seven" *: 9.8 *: EmptyTuple)) // <-- results in compile-time error as desired: "Cannot prove that test.Tuples.L[(Int *: EmptyTuple.type)] =:= test.Tuples.L[(String, Double)]..."

编辑2： 所以实际上事实证明元组长度已经被限制为相等，否则匹配类型Z没有解决，所以我想问题只是如何避免强制转换z().

现在匹配类型 https://docs.scala-lang.org/scala3/reference/new-types/match-types.html价值水平有很多限制：

这种匹配表达式的特殊输入模式仅在以下情况下使用： 满足以下条件：

1. 匹配表达式模式没有防护
2. 匹配表达式受检者类型是匹配类型受检者类型的子类型
3. 匹配表达式和匹配类型具有相同的事例数
4. 匹配表达式模式都是类型化模式 https://scala-lang.org/files/archive/spec/2.13/08-pattern-matching.html#typed-patterns，这些类型是=:=到匹配类型中相应的类型模式

你的代码

type Z[A <: Tuple, B <: Tuple] <: Tuple = (A, B) match
  case (EmptyTuple, EmptyTuple) => EmptyTuple
  case (a *: as, b *: bs) => (a, b) *: Z[as, bs]

def z[A <: Tuple, B <: Tuple](a: A, b: B): Z[A, B] = (a, b) match
  case (EmptyTuple, EmptyTuple) => EmptyTuple
  case (ah *: at, bh *: bt) => (ah, bh) *: z(at, bt)

打破条件4。case (EmptyTuple, EmptyTuple) and case (ah *: at, bh *: bt)不是键入的模式。

尝试一下是有意义的

type Z[A <: Tuple, B <: Tuple] <: Tuple = (A, B) match
  case (EmptyTuple, EmptyTuple) => EmptyTuple
  case (a *: as, b *: bs) => (a, b) *: Z[as, bs]

def z[A <: Tuple, B <: Tuple](a: A, b: B): Z[A, B] = (a, b) match
  case _: (EmptyTuple, EmptyTuple) => EmptyTuple
  case t: (_ *: _, _ *: _) => t match
    case (ah *: at, bh *: bt) => (ah, bh) *: z(at, bt)

但不幸的是，由于类型擦除，这不起作用

z((1, "a"), (true, 2.0)) // ()

实际上，case _: (EmptyTuple, EmptyTuple) and case t: (_ *: _, _ *: _)只是case _: (_, _)并匹配一切。如果我们交换箱子z((1, "a"), (true, 2.0))抛出运行时异常（java.lang.IndexOutOfBoundsException: 0).

以下使用嵌套匹配类型/模式匹配的方法似乎有效

type Z[A <: Tuple, B <: Tuple] <: Tuple = A match
  case EmptyTuple => Z1[B]
  case a *: as => Z2[a, as, B]

type Z1[B <: Tuple] <: Tuple = B match
  case EmptyTuple => EmptyTuple

type Z2[A, As <: Tuple, B <: Tuple] <: Tuple = B match
  case b *: bs => (A, b) *: Z[As, bs]

def z[A <: Tuple, B <: Tuple](a: A, b: B): Z[A, B] = a match
  case _: EmptyTuple => z1(b)
  case a1: (_ *: _) => a1 match
    case a2 *: as => z2(a2, as, b)

def z1[B <: Tuple](b: B): Z1[B] = b match
  case _: EmptyTuple => EmptyTuple

def z2[A, As <: Tuple, B <: Tuple](a: A, as: As, b: B): Z2[A, As, B] = b match
  case b1: (_ *: _) => b1 match
    case b2 *: bs => (a, b2) *: z(as, bs)

// compiles
summon[Z[(Int, String), (Boolean, Double)] =:= ((Int, Boolean), (String, Double))]

z((1, "a"), (true, 2.0)) // ((1,true),(a,2.0))

//   doesn't compile
// summon[Z[(Int, String, Long), (Boolean, Double)] =:= ((Int, Boolean), (String, Double))]
// z((1, "a", 3L), (true, 2.0))
//   Match type reduction failed since selector EmptyTuple.type
//   matches none of the cases
//     case b *: bs => (Long, b) *: Z[EmptyTuple.type, bs]

//   doesn't compile
// summon[Z[(Int, String), (Boolean, Double, Long)] =:= ((Int, Boolean), (String, Double))]
// z((1, "a"), (true, 2.0, 3L))
//   Match type reduction failed since selector  Long *: EmptyTuple.type
//   matches none of the cases
//     case EmptyTuple => EmptyTuple 

如何让匹配类型在 Scala 3 中正常工作 https://stackoverflow.com/questions/64434175/how-to-get-match-type-to-work-correctly-in-scala-3

Shapeless3 和注释 https://stackoverflow.com/questions/74355212/shapeless3-and-annotations