как сделать кортеж из нескольких списков в Scala

Question

У меня есть количество списков, как я могу сделать функцию, которая принимает списки, а затем возвращает кортеж. В настоящее время я делаю это как:

val s1 = List('a','b','c','d')
val s2 = List('1','2','3','4')
val s3 = List("aa","ab","ac","ad")
val s4 = List('e','f','g','h')
val s5 = List('5','6','7','8')
val s6 = List("ba","bb","bc","bd")
val s7 = List("ca","cb","cc","cd")   


val preS3  = s1 zip s2 map{ case (x1,x2) => (x1,x2)}
val preS4  = preS3  zip s3  map{ case (x1,x2) => (x1._1,x1._2,x2)}
val preS5  = preS4  zip s4  map{ case (x1,x2) => (x1._1,x1._2,x1._3,x2)}
val preS6  = preS5  zip s5  map{ case (x1,x2) => (x1._1,x1._2,x1._3,x1._4,x2)}
val preS7  = preS6  zip s6  map{ case (x1,x2) => (x1._1,x1._2,x1._3,x1._4,x1._5,x2)}
val preS8  = preS7  zip s7  map{ case (x1,x2) => (x1._1,x1._2,x1._3,x1._4,x1._5,x1._6,x2)}

Заранее спасибо.

Answer 1

Вот способ, основанный на этом ответе

scala> :paste
// Entering paste mode (ctrl-D to finish)

val s1 = List('a','b','c','d')
val s2 = List('1','2','3','4')
val s3 = List("aa","ab","ac","ad")
val s4 = List('e','f','g','h')
val s5 = List('5','6','7','8')
val s6 = List("ba","bb","bc","bd")
val s7 = List("ca","cb","cc","cd")   

// Exiting paste mode, now interpreting.

s1: List[Char] = List(a, b, c, d)
s2: List[Char] = List(1, 2, 3, 4)
s3: List[String] = List(aa, ab, ac, ad)
s4: List[Char] = List(e, f, g, h)
s5: List[Char] = List(5, 6, 7, 8)
s6: List[String] = List(ba, bb, bc, bd)
s7: List[String] = List(ca, cb, cc, cd)

scala> for (e1 Tuple2 e2 Tuple2 e3 Tuple2 e4 Tuple2 e5 Tuple2 e6 Tuple2 e7 <- s1 zip s2 zip s3 zip s4 zip s5 zip s6 zip s7) yield (e1, e2, e3, e4, e5, e6, e7)
res0: List[(Char, Char, String, Char, Char, String, String)] = List((a,1,aa,e,5,ba,ca), (b,2,ab,f,6,bb,cb), (c,3,ac,g,7,bc,cc), (d,4,ad,h,8,bd,cd))

Answer 2

Это основной алгоритм для трех списков:
(Как вы можете видеть, он заканчивается, как только в любом из списков заканчивается элемент)

def zipThree[A, B, C](as: List[A], bs: List[B], cs: List[C]): List[(A, B, C)] = {
  @annotation.tailrec
  def loop(as: List[A], bs: List[B], cs: List[C], acc: List[(A, B, C)]): List[(A, B, C)] =
    (as, bs, cs) match {
      case (a :: as, b :: bs, c :: cs) =>
        loop(as, bs, cs, (a, b, c) :: acc)

      case _ =>
        // Return as soon as one list ends.
        acc.reverse
    }

  loop(as, bs, cs, acc = List.empty)
}

Выможно использовать это так:

zipThree(List(1, 2), List('a', 'b'), List(true, false))
// res: List[(Int, Char, Boolean)] = List((1, 'a', true), (2, 'b', false))

Что делать с четырьмя, пятью, шестью или более элементами (до 22) ?
Ну, в основном то же самоено с одним дополнительным параметром повсюду.

Эта задача очень повторяющаяся и легко ошибиться со многими списками, я бы порекомендовал вам написать генератор исходного кода для созданияфайл со всеми делами от трех до двадцати двух.

Answer 3

Использование Тип кошек :

import cats.implicits._
(s1, s2, s3, s4, s5, s6, s7).parTupled