blocks|key|4283257|text|如果你使用shapeless，我想this正是你所需要的。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|4283258|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/milessabin/shapeless|1|https://github.com/milessabin/shapeless/blob/master/examples/src/main/scala/shapeless/examples/flatten.scala^0|5|9|0|H|4|1|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]|$A|R|B|S|1|T]]|C|$]]|$1|D|3|-4|5|6|7|U|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]]]

If you use <a href="https://github.com/milessabin/shapeless" rel="noreferrer">shapeless</a>, <a href="https://github.com/milessabin/shapeless/blob/master/examples/src/main/scala/shapeless/examples/flatten.scala" rel="noreferrer">this</a> is exactly what you need, I think.

blocks|key|454072|text|Tupple上没有展平。但是如果你知道它的结构，你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|454073|implicit+def+flatten1[A,+B,+C](t:+((A,+B),+C)):+(A,+B,+C)+=+(t._1._1,+t._1._2,+t._2)
implicit+def+flatten2[A,+B,+C](t:+(A,+(B,+C))):+(A,+B,+C)+=+(t._1,+t._2._1,+t._2._2)|code-block|syntax|javascript|454074|这将展平任何类型的Tupple。还可以将implicit关键字添加到定义中。这只适用于三个元素。可以展平Tupple，如下所示：|454075|(1,+("hello",+42.0))+++=>+(1,+"hello",+42.0)
(("test",+3.7f),+"hi")+=>+("test",+3.7f,+"hi")|454076|多个嵌套的Tupple不能展平到地面，因为在返回类型中只有三个元素：|454077|((1,+(2,+3)),4)++++++++=>+(1,+(2,+3),+4)|454078|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

There is no flatten on a Tupple. But if you know the structure, you can do something like this:

<pre><code>implicit def flatten1[A, B, C](t: ((A, B), C)): (A, B, C) = (t._1._1, t._1._2, t._2)
implicit def flatten2[A, B, C](t: (A, (B, C))): (A, B, C) = (t._1, t._2._1, t._2._2)
</code></pre>

This will flatten Tupple with any types. You can also add the implicit keyword to the definition. This works only for three elements. You can flatten Tupple like:

<pre><code>(1, ("hello", 42.0)) =&gt; (1, "hello", 42.0)
(("test", 3.7f), "hi") =&gt; ("test", 3.7f, "hi")
</code></pre>

Multiple nested Tupple cannot be flatten to the ground, because there are only three elements in the return type:

<pre><code>((1, (2, 3)),4) =&gt; (1, (2, 3), 4)
</code></pre>

blocks|key|3802784|text|不确定这样做的效率，但您可以使用tuple.productIterator.toList将Tuple转换为List，然后flatten嵌套列表：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3802785|scala>+val+tuple+=+("top",+("nested",+42.0))
tuple:+(String,+(String,+Double))+=+(top,(nested,42.0))

scala>+tuple.productIterator.map({
+++++%7C+++case+(item:+Product)+=>+item.productIterator.toList
+++++%7C+++case+(item:+Any)+=>+List(item)
+++++%7C+}).toList.flatten
res0:+List[Any]+=+List(top,+nested,+42.0)|code-block|syntax|javascript|3802786|entityMap^0|G|S|19|5|1H|4|1O|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|L|$]]

Not sure about the effiency of this, but you can convert <code>Tuple</code> to <code>List</code> with <code>tuple.productIterator.toList</code>, then <code>flatten</code> the nested lists:

<pre><code>scala&gt; val tuple = ("top", ("nested", 42.0))
tuple: (String, (String, Double)) = (top,(nested,42.0))

scala&gt; tuple.productIterator.map({
 | case (item: Product) =&gt; item.productIterator.toList
 | case (item: Any) =&gt; List(item)
 | }).toList.flatten
res0: List[Any] = List(top, nested, 42.0)
</code></pre>

blocks|key|3803032|text|的补充|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3803033|粘贴此实用程序代码：|offset|length|style|BOLD|3803034|import+shapeless._
import+ops.tuple.FlatMapper
import+syntax.std.tuple._
trait+LowPriorityFlatten+extends+Poly1+{
++implicit+def+default[T]+=+at[T](Tuple1(_))
}
object+flatten+extends+LowPriorityFlatten+{
++implicit+def+caseTuple[P+<:+Product](implicit+lfm:+Lazy[FlatMapper[P,+flatten.type]])+=
++++at[P](lfm.value(_))
}|code-block|syntax|javascript|3803035|然后，您可以展平任何嵌套的元组：|3803036|scala>+val+a+=+flatten(((1,2),((3,4),(5,(6,(7,8))))))
a:+(Int,+Int,+Int,+Int,+Int,+Int,+Int,+Int)+=+(1,2,3,4,5,6,7,8)|3803037|3803038|3803039|请注意，此解决方案不适用于自定义的case+class类型，该类型将在输出中转换为String。|blockquote|CODE|3803040|3803041|scala>+val+b=flatten(猫(“c”)，狗(“d”))，猫(“c”))+b：(String，String，String)+=+(c，d，c)|3803042|entityMap^0|0|0|A|0|0|0|0|0|0|H|A|15|6|0|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|12|8|@$D|13|E|14|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|15|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|16|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|17|8|@]|9|@]|A|$K|L]]|$1|Q|3|-4|5|6|7|18|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|T|5|U|7|1A|8|@$D|1B|E|1C|F|V]|$D|1D|E|1E|F|V]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|1G|8|@]|9|@]|A|$]]|$1|Z|3|-4|5|6|7|1H|8|@]|9|@]|A|$]]]|10|$]]

Complement of <a href="https://stackoverflow.com/a/13699521/8932910">answer above</a>
Paste this utility code:
<pre><code>import shapeless._
import ops.tuple.FlatMapper
import syntax.std.tuple._
trait LowPriorityFlatten extends Poly1 {
 implicit def default[T] = at[T](Tuple1(_))
}
object flatten extends LowPriorityFlatten {
 implicit def caseTuple[P &lt;: Product](implicit lfm: Lazy[FlatMapper[P, flatten.type]]) =
 at[P](lfm.value(_))
}
</code></pre>
then you are able to flatten any nested tuple:
<pre><code>scala&gt; val a = flatten(((1,2),((3,4),(5,(6,(7,8))))))
a: (Int, Int, Int, Int, Int, Int, Int, Int) = (1,2,3,4,5,6,7,8)
</code></pre>
<hr />
<blockquote>
Note that this solution does not work for self-defined <code>case class</code> type, which would be converted to <code>String</code> in the output.
<pre><code>scala&gt; val b = flatten(((Cat(&quot;c&quot;), Dog(&quot;d&quot;)), Cat(&quot;c&quot;)))
b: (String, String, String) = (c,d,c)
</code></pre>
</blockquote>

blocks|key|3802897|text|在我看来，简单的模式匹配是可行的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3802898|scala>+val+motto+=+(("dog",+"food"),+"tastes+good")
val+motto:+((String,+String),+String)+=+((dog,food),tastes+good)

scala>+motto+match+{
+++++%7C+case+((it,+really),+does)+=>+(it,+really,+does)
+++++%7C+}
val+res0:+(String,+String,+String)+=+(dog,food,tastes+good)|code-block|syntax|javascript|3802899|或者，如果你有一个这样的元组集合：|3802900|scala>+val+motto+=+List(
+++++%7C+(("dog",+"food"),+"tastes+good"))+:%2B+(("cat",+"food"),+"tastes+bad")
val+motto:+List[((String,+String),+String)]+=+List(((dog,food),tastes+good),+((cat,food),tastes+bad))

scala>+motto.map+{
+++++%7C+case+((one,+two),+three)+=>+(one,+two,+three)
+++++%7C+}
val+res2:+List[(String,+String,+String)]+=+List((dog,food,tastes+good),+(cat,food,tastes+bad))|3802901|我想即使你有几个箱子也会很方便。|3802902|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

In my opinion simple pattern matching would work
<pre><code>scala&gt; val motto = ((&quot;dog&quot;, &quot;food&quot;), &quot;tastes good&quot;)
val motto: ((String, String), String) = ((dog,food),tastes good)

scala&gt; motto match {
 | case ((it, really), does) =&gt; (it, really, does)
 | }
val res0: (String, String, String) = (dog,food,tastes good)
</code></pre>
Or if you have a collection of such tuples:
<pre><code>scala&gt; val motto = List(
 | ((&quot;dog&quot;, &quot;food&quot;), &quot;tastes good&quot;)) :+ ((&quot;cat&quot;, &quot;food&quot;), &quot;tastes bad&quot;)
val motto: List[((String, String), String)] = List(((dog,food),tastes good), ((cat,food),tastes bad))

scala&gt; motto.map {
 | case ((one, two), three) =&gt; (one, two, three)
 | }
val res2: List[(String, String, String)] = List((dog,food,tastes good), (cat,food,tastes bad))
</code></pre>
I think it would be convenient even if you have several cases.

I have a nested tuple structure like <code>(String,(String,Double))</code> and I want to transform it to <code>(String,String,Double)</code>. I have various kinds of nested tuple, and I don't want to transform each manually. Is there any convenient way to do that?

How to flatten a nested tuple?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我有一个像(String,(String,Double))这样的嵌套元组结构，我想把它转换成(String,String,Double)。我有各种各样的嵌套元组，我不想手动转换每个元组。有什么方便的方法可以做到这一点？

问如何展平嵌套的元组？
EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何展平嵌套的元组？EN

回答 5

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何展平嵌套的元组？
EN