Can I zip more than two lists together in Scala?

Question

Given the following Scala List:

val l = List(List("a1", "b1", "c1"), List("a2", "b2", "c2"), List("a3", "b3", "c3"))

How can I get:

List(("a1", "a2", "a3"), ("b1", "b2", "b3"), ("c1", "c2", "c3"))

Since zip can only be used to combine two Lists, I think you would need to iterate/reduce the main List somehow. Not surprisingly, the following doesn't work:

scala> l reduceLeft ((a, b) => a zip b)
<console>:6: error: type mismatch;
 found   : List[(String, String)]
 required: List[String]
       l reduceLeft ((a, b) => a zip b)

Any suggestions one how to do this? I think I'm missing a very simple way to do it.

Update: I'm looking for a solution that can take a List of N Lists with M elements each and create a List of M TupleNs.

Update 2: As it turns out it is better for my specific use-case to have a list of lists, rather than a list of tuples, so I am accepting pumpkin's response. It is also the simplest, as it uses a native method.

possible duplicate of [Zip multiple sequences](http://stackoverflow.com/questions/9632094/zip-multiple-sequences) — Suma, Feb 26 '15 at 19:23
Definitely worth noting: http://stackoverflow.com/questions/1683312/is-there-a-safe-way-in-scala-to-transpose-a-list-of-unequal-length-lists — Sudheer Aedama, Jul 20 '15 at 23:28
@VenkatSudheerReddyAedama Also asked by me, five days later. ;-) — pr1001, Jul 22 '15 at 15:47

score 218 · Answer 1 · answered Sep 11 '11 at 06:20

218

scala> (List(1,2,3),List(4,5,6),List(7,8,9)).zipped.toList
res0: List[(Int, Int, Int)] = List((1,4,7), (2,5,8), (3,6,9))

For future reference.

answered Sep 11 '11 at 06:20

Xorlev

8,255
3
30
36

32

This is great for zipping three lists. Shame this doesn't work for more than three list :( – theon Apr 22 '14 at 16:01
2

Do note that this needs to be in a tuple first: `zipped` is not a function of `List`. – Nathaniel Ford Dec 10 '15 at 00:11
9

`zipped` is deprecated in Scala 2.13. in 2.13, do `l1.lazyZip(l2).lazyZip(l3).toList` – Seth Tisue Dec 08 '19 at 23:02

score 36 · Accepted Answer · edited Nov 27 '18 at 08:48

36

I don't believe it's possible to generate a list of tuples of arbitrary size, but the transpose function does exactly what you need if you don't mind getting a list of lists instead.

edited Nov 27 '18 at 08:48

codebox

18,210
7
54
77

answered Nov 03 '09 at 01:16

copumpkin

2,658
16
24

Thanks, that works perfectly! As I go into my specific use case, I see that a list of lists would be better anyway, as I need to map and reduce the various sub-lists. – pr1001 Nov 03 '09 at 01:38
2

@JoshCason in the narrowest sense of "more than two", sure. Three is indeed more than two. I interpreted the question in the broader sense of "more than two", meaning arbitrarily many. And in that case, it is not possible to do what the question wants, unless you reach for `HList`s and the like. – copumpkin May 03 '16 at 12:54
the link in the answer is broken, new link is https://www.scala-lang.org/api/2.12.1/scala/Array.html#transpose[U](implicitasArray:T=%3EArray[U]):Array[Array[U]] – Ramesh Maharjan Jun 22 '18 at 08:52

score 31 · Answer 3 · answered Dec 18 '13 at 05:17

31

So this piece of code won't answer the needs of the OP, and not only because this is a four year old thread, but it does answer the title question, and perhaps someone may even find it useful.

To zip 3 collections:

as zip bs zip cs map { 
  case ((a,b), c) => (a,b,c)
}

answered Dec 18 '13 at 05:17

Bijou Trouvaille

6,775
4
34
41

to do 4 collections looks like: `as zip bs zip cs zip ds map { case ((a,b),c)} map {case ((a,b),c,d)=>(a,b,c,d)}` – James Tobin Aug 25 '16 at 17:59
1

@JamesTobin, u shorten to `as zip bs zip cs zip ds map {case (((a,b),c),d)=>(a,b,c,d) }` – keepscoding May 12 '17 at 02:31
Nice for lists of varying type. – F. P. Freely Aug 31 '17 at 03:07

score 11 · Answer 4 · answered Nov 03 '09 at 00:06

11

Yes, with zip3.

answered Nov 03 '09 at 00:06

Harold L

4,968
25
27

2

Thanks, but it only works with 3 lists. I'm looking for a solution that can take a List of N Lists with M elements each and create a List of M TupleNs. – pr1001 Nov 03 '09 at 00:13

score 6 · Answer 5 · edited Jul 01 '18 at 17:32

6

transpose does the trick. A possible algorithm is:

def combineLists[A](ss:List[A]*) = {
    val sa = ss.reverse;
    (sa.head.map(List(_)) /: sa.tail)(_.zip(_).map(p=>p._2 :: p._1))
}

For example:

combineLists(List(1, 2, 3), List(10,20), List(100, 200, 300))
// => List[List[Int]] = List(List(1, 10, 100), List(2, 20, 200))

The answer is truncated to the size of the shortest list in the input.

combineLists(List(1, 2, 3), List(10,20))
// => List[List[Int]] = List(List(1, 10), List(2, 20))

edited Jul 01 '18 at 17:32

rogermenezes

1,083
8
11

answered Oct 29 '12 at 18:34

W.P. McNeill

13,777
9
63
94

1

this answer almost does the trick, however, it reverse the elements. Can you suggest an improved version that produces the output in the expected order? thanks – fracca Jun 12 '13 at 15:51
Modified version that retains the order: ```def combineLists[A](ss:List[A]*) = { val sa = ss.reverse; (sa.head.map(List(_)) /: sa.tail)(_.zip(_).map(p=>p._2 :: p._1)) }``` – rogermenezes Jun 29 '18 at 22:20

score 5 · Answer 6 · answered Nov 03 '09 at 01:10

Scala treats all of its different tuple sizes as different classes (Tuple1, Tuple2, Tuple3, Tuple4,...,Tuple22) while they do all inherit from the Product trait, that trait doesn't carry enough information to actually use the data values from the different sizes of tuples if they could all be returned by the same function. (And scala's generics aren't powerful enough to handle this case either.)

Your best bet is to write overloads of the zip function for all 22 Tuple sizes. A code generator would probably help you with this.

score 5 · Answer 7 · edited Oct 21 '19 at 13:24

5

I don't believe that's possible without being repetitive. For one simple reason: you can't define the returning type of the function you are asking for.

For instance, if your input was List(List(1,2), List(3,4)), then the return type would be List[Tuple2[Int]]. If it had three elements, the return type would be List[Tuple3[Int]], and so on.

You could return List[AnyRef], or even List[Product], and then make a bunch of cases, one for each condition.

As for general List transposition, this works:

def transpose[T](l: List[List[T]]): List[List[T]] = l match {
  case Nil => Nil
  case Nil :: _ => Nil
  case _ => (l map (_.head)) :: transpose(l map (_.tail))
}

edited Oct 21 '19 at 13:24

nader.h

498
2
16

answered Nov 03 '09 at 02:03

Daniel C. Sobral

284,820
82
479
670

This won't work for arbitrary sized lists. For example: transpose(List(List("a", "b"), List("c"))) – Sudheer Aedama Mar 12 '15 at 17:56
1

@VenkatSudheerReddyAedama Transposition of incomplete matrices doesn't make sense to me. To take your example, if `c` in line with `a` or with `b`? And how would you represent it being in line with the other? – Daniel C. Sobral Mar 12 '15 at 20:56
Agreed. That's an incomplete matrix. I was looking for something along the lines of zipAll. Say in my case, `c` is in line with `a` (i.e., in-line with index) ? – Sudheer Aedama Mar 12 '15 at 20:59

score 5 · Answer 8 · answered Sep 02 '16 at 09:47

If you don't want to go down the applicative scalaz/cats/(insert your favourite functional lib here) route, pattern matching is the way to go, although the (_, _) syntax is a bit awkward with nesting, so let's change it:

import scala.{Tuple2 => &}

for (i1 & i2 & i3 & i4 <- list1 zip list2 zip list3 zip list4) yield (i1, i2, i3, i4)

The & is an arbitrary choice here, anything that looks nice infix should do it. You'll likely get a few raised eyebrows during code review, though.

It should also work with anything you can zip (e.g. Futures)

Mark Lister · Answer 9 · 2015-03-24T05:36:23.763

2

product-collections has aflatZip operation up to arity 22.

scala> List(1,2,3) flatZip Seq("a","b","c") flatZip Vector(1.0,2.0,3.0) flatZip Seq(9,8,7)
res1: com.github.marklister.collections.immutable.CollSeq4[Int,String,Double,Int] = 
CollSeq((1,a,1.0,9),
        (2,b,2.0,8),
        (3,c,3.0,7))

edited Mar 24 '15 at 05:36

answered Feb 24 '14 at 22:20

Mark Lister

1,063
6
14

score 0 · Answer 10 · answered Dec 11 '14 at 09:26

With Scalaz:

import scalaz.Zip
import scalaz.std.list._

// Zip 3
Zip[List].ap.tuple3(List("a1", "b1"),
                    List("a2", "b2"),
                    List("a3", "b3"))

// Zip 4
Zip[List].ap.tuple4(List("a1", "b1"),
                    List("a2", "b2"),
                    List("a3", "b3"),
                    List("a4", "b4"))

// Zip 5
Zip[List].ap.tuple5(List("a1", "b1"),
                    List("a2", "b2"),
                    List("a3", "b3"),
                    List("a4", "b4"),
                    List("a5", "b5"))

For more than 5:

// Zip 6
Zip[List].ap.apply6(List("a1", "b1"),
                    List("a2", "b2"),
                    List("a3", "b3"),
                    List("a4", "b4"),
                    List("a5", "b5"),
                    List("a6", "b6"))((_, _, _, _, _, _))

// Zip 7
Zip[List].ap.apply7(List("a1", "b1"),
                    List("a2", "b2"),
                    List("a3", "b3"),
                    List("a4", "b4"),
                    List("a5", "b5"),
                    List("a6", "b6"),
                    List("a7", "b7"))((_, _, _, _, _, _, _))

...

// Zip 12
Zip[List].ap.apply12(List("a1", "b1"),
                     List("a2", "b2"),
                     List("a3", "b3"),
                     List("a4", "b4"),
                     List("a5", "b5"),
                     List("a6", "b6"),
                     List("a7", "b7"),
                     List("a8", "b8"),
                     List("a9", "b9"),
                     List("a10", "b10"),
                     List("a11", "b11"),
                     List("a12", "b12"))((_, _, _, _, _, _, _, _, _, _, _, _))

score 0 · Answer 11 · answered Mar 01 '21 at 10:47

Scala 2.12.13 and below

If you know how long the input List is, you can join the list into a Tuple and use Tuple's .zipped method:

val l = List(List("a1", "b1", "c1"), List("a2", "b2", "c2"), List("a3", "b3", "c3"))

println(l match {
  case l1::l2::l3::_ => (l1,l2,l3).zipped.toList
  case _ => throw new IllegalArgumentException("List is not the right length")
}) // List((a1,a2,a3), (b1,b2,b3), (c1,c2,c3))

Scastie Example - 2.12.13

>= Scala 2.13

The above solution is deprecated - use lazyZip instead:

val l = List(List("a1", "b1", "c1"), List("a2", "b2", "c2"), List("a3", "b3", "c3"))

println(l match {
  case l1::l2::l3::_ => (l1 lazyZip l2 lazyZip l3).toList
  case _ => throw new IllegalArgumentException("List is not the right length")
}) // List((a1,a2,a3), (b1,b2,b3), (c1,c2,c3))

Scastie Example - 2.13.0

Can I zip more than two lists together in Scala?

11 Answers11

Scala 2.12.13 and below

>= Scala 2.13

Linked

Related