scala中的嵌套元组提取器->；

是否有一个方便的提取器，它是

->

运算符的反射（在数学意义上）

例如，这项工作：

scala> val y = 1 -> 2 -> 3
y: ((Int, Int), Int) = ((1,2),3)

scala> y match { case ((a,b),c) => s"Values are : $a, $b, and $c" }
res0: String = Values are : 1, 2, and 3

但这并不是：

scala> y match { case a -> b -> c => s"Values are : $a, $b, and $c" }
<console>:9: error: not found: value ->
              y match { case a -> b -> c => s"Values are : $a, $b, and $c" }
                                    ^
<console>:9: error: not found: value a
              y match { case a -> b -> c => s"Values are : $a, $b, and $c" }
                                                            ^

scala>y匹配{case a->b->c=>s“值为：$a、$b和$c”}
：9:错误：未找到：值->
y匹配{case a->b->c=>s“值为：$a、$b和$c”}
^
：9:错误：未找到：值a
y匹配{case a->b->c=>s“值为：$a、$b和$c”}
^

当您有许多嵌套元组时，您可以看到这是多么有用。如果您想知道，我的嵌套元组是由外部库生成的，所以我不能自己“展平”y。

试试下一步

scala> y match { case ((z01,z02),z2) => println(s"$z01 -> $z02 -> $z2") }
1 -> 2 -> 3

scala>

下一步试试

scala> y match { case ((z01,z02),z2) => println(s"$z01 -> $z02 -> $z2") }
1 -> 2 -> 3

scala>

---

我试图避免的是您仍在使用的

大小写

后面的嵌套括号。例如，如果嵌套级别为5，则必须编写

（（（（（（z0，z1），z2），z3），z4），z5

，这是一个混乱。相反，我想做

案例z0*z1*z2*z3*z4*z5=>

，其中

*

是一些二进制运算符。在这种情况下不要使用元组。将您的结构转换为树状的

案例类集

s。我试图避免的是

案例

后面的嵌套括号，您仍然在使用它。例如，如果嵌套级别为5，则必须编写

（（（（（（z0，z1），z2），z3），z4），z5

，这是一个混乱。相反，我想做

案例z0*z1*z2*z3*z4*z5=>

，其中

*

是一些二进制运算符。在这种情况下不要使用元组。将您的结构转换为树状的

case类集

s。johny提供的链接给出了答案。但我只是想知道，有什么理由你更喜欢

1->2->3

而不是

（1，2，3）

？如果您使用

1->2->3

，您仍然会不时看到

（（1，2），3）

（在输出或调试中），并且它看起来ugly@johny是的，这是完全相同的问题。谢谢。@Archeg，正如我在问题中所说的，这是因为我从一个外部图书馆以那种形式得到的……对不起，错过了。您可以使用shapeless展平元组：这可能比将这个奇怪的元组保留在表单中要好@johny提供的链接有答案。但我只是想知道，有什么理由你更喜欢

1->2->3

而不是

（1，2，3）

？如果您使用

1->2->3

，您仍然会不时看到

（（1，2），3）

（在输出或调试中），并且它看起来ugly@johny是的，这是完全相同的问题。谢谢。@Archeg，正如我在问题中所说的，这是因为我从一个外部图书馆以那种形式得到的……对不起，错过了。您可以使用shapeless展平元组：这可能比保持这种奇怪的元组形式要好