Comment utiliser la compréhension de for en Scala avec des collections inconnues?

Question

Je veux écrire une fonction qui accepte une liste de séquences dans laquelle chaque séquence sera utilisée dans une expression de compréhension.

par exemple.

for (x <- (1 à 10); y <- (1 à 10)) yield List(x,y)

Dans l'expression ci-dessus, je dois savoir à l'avance que je veux une combinaison de x et y. Et si je veux une combinaison de x, y, z ...etc... (un nombre inconnu de combinaisons)? Si je veux 10 combinaisons, je veux coller 10 morceaux de code "x <- (1 à 10)" dans l'expression. Je pense que je peux faire cela avec un macro en Clojure (une façon de coller du code). Comment puis-je faire cela en Scala?

La fonction que je veux écrire a la signature suivante:

combine(list: List[List[Int]])

Le corps de la fonction utilisera chaque élément de la liste à coller dans la compréhension.

J'espère que vous comprenez mon intention.

Answer 1

Si vous voulez calculer le produit cartésien d'une liste de listes, vous pouvez le faire en enchaînant les appels de map et flatMap de manière récursive. C'est ce que font de toute façon les expressions for.

  def prod(l:List[List[Int]]):List[List[Int]] = l match {
    case Nil => List(Nil)
    case l::ls => l.flatMap(i => prod(ls).map(t =>i::t))
  }

Answer 2

Vous savez comment combiner deux choses en une seule, et vous voulez combiner un nombre arbitraire, cela signifie que vous avez besoin d'un fold. La seule modification est que vous voulez commencer avec une liste de singletons, pas une liste d'éléments :

val xss = List(List(1,2,3),List(4,5),List(6,7))
val singletons = xss.head.map(x => List(x))   // List(List(1), ...)
val seqs = (singletons /: xss.tail){ (yss, xs) => for (ys <- yss; x <- xs) yield x :: ys }
seqs.map(_.reverse)

ce qui à la dernière étape imprime

List(List(1, 4, 6), List(1, 4, 7), List(1, 5, 6),
     List(1, 5, 7), List(2, 4, 6), List(2, 4, 7),
     List(2, 5, 6), List(2, 5, 7), List(3, 4, 6),
     List(3, 4, 7), List(3, 5, 6), List(3, 5, 7))