Scala - kann Ausbeute mit einer for-Schleife mehrfach verwendet werden?

Question

Ein Beispiel:

val l = List(1,2,3) 
val t = List(-1,-2,-3) 

Kann ich etwas tun?

for (i <- 0 to 10) yield (l(i)) yield (t(i)) 

Grundsätzlich möchte ich für jede Iteration mehrere Ergebnisse liefern.

Answer 1

Es ist nicht klar, wonach Sie fragen - was Sie erwarten, dass die Semantik des multiplen Ertrags ist. Eine Sache ist jedoch, dass Sie wahrscheinlich nie Indizes verwenden möchten, um durch eine Liste zu navigieren - jeder Aufruf von t (i) ist O (i) zur Ausführung.

hier ist also eine Möglichkeit, dass Sie für

scala> val l = List(1,2,3); val t = List(-1,-2,-3) 
l: List[Int] = List(1, 2, 3) 
t: List[Int] = List(-1, -2, -3) 

scala> val pairs = l zip t 
pairs: List[(Int, Int)] = List((1,-1), (2,-2), (3,-3)) 

fragen könnte Und hier ist eine andere Möglichkeit, dass Sie

scala> val crossProduct = for (x <- l; y <- t) yield (x,y) 
crossProduct: List[(Int, Int)] = List((1,-1), (1,-2), (1,-3), (2,-1), (2,-2), (2,-3), (3,-1), (3,-2), (3,-3)) 

Die später zu fragen, könnte nur syntaktischer Zucker ist für

scala> val crossProduct2 = l flatMap {x => t map {y => (x,y)}} 
crossProduct2: List[(Int, Int)] = List((1,-1), (1,-2), (1,-3), (2,-1), (2,-2), (2,-3), (3,-1), (3,-2), (3,-3)) 

Eine dritte Möglichkeit ist es, sie zu verschachteln

scala> val interleaved = for ((x,y) <- l zip t; r <- List(x,y)) yield r 
interleaved: List[Int] = List(1, -1, 2, -2, 3, -3, 4, -4, 5, -5, 6, -6, 7, -7, 8, -8, 9, -9, 10, -10) 

Das für Syntax Zucker ist

scala> val interleaved2 = l zip t flatMap {case (x,y) => List(x,y)} 
interleaved2: List[Int] = List(1, -1, 2, -2, 3, -3, 4, -4, 5, -5, 6, -6, 7, -7, 8, -8, 9, -9, 10, -10) 

Answer 2

Anscheinend nicht. Ich bekomme einen Kompilierfehler, wenn ich es versuche.

Es sieht aus wie für .. Ertrag ist ein Ausdruck. Sie können nicht zwei Erträge haben, da das nicht wirklich Teil des Ausdrucks ist.

Wenn Sie mehrere Werte erhalten möchten, warum sie nicht als Tupel oder Liste ausgeben?

Zum Beispiel:

for(t <- List(1,2,3); l <- List(-1,-2,-3)) 
    yield (t, l) 

Answer 3

Vielleicht Ausbeute ist nicht der beste Weg zu gehen? Vielleicht könnte hier ein einfaches Anhängen eines Arrays verwendet werden.

Answer 4

Nein, Sie können nicht mehrere Yield-Klauseln verwenden, aber es gibt Workarounds. Zum Beispiel:

for (i <- 0 to 10; 
    r <- List(l(i), t(i))) 
yield r 

Sie können Nest-Comprehensions, natürlich, aber das wäre in einer Liste von Listen von Elementen führen, was ich nicht glaube, ist, was Sie wollen.

Answer 5

Hier ist eine Art unabhängige Lösung für eine unbekannte, unterschiedliche Anzahl von Elementen in einer unbekannten Anzahl von Listen:

def xproduct (xx: List [List[_]]) : List [List[_]] = 
    xx match { 
    case aa :: bb :: Nil => 
     aa.map (a => bb.map (b => List (a, b))).flatten  
    case aa :: bb :: cc => 
     xproduct (bb :: cc).map (li => aa.map (a => a :: li)).flatten 
    case _ => xx 
} 

für 2 Listen es ist überentwickelt. Sie könnten es aber anrufen

xproduct (List (l, t)) 

Answer 6

Erträge können geschachtelt werden, was dazu führen würde ...

for (i <- 0 to 3) yield { 
    for (j <- 0 to 2) yield (i,j) 
} 

in einem Vektor von Vector:

scala.collection.immutable.IndexedSeq[scala.collection.immutable.IndexedSeq[(Int, Int)]] 
= Vector(Vector((0,0), (0,1), (0,2)), Vector((1,0), (1,1), (1,2)), Vector((2,0), (2,1), (2,2)), Vector((3,0), (3,1), (3,2))) 

for (i <- 0 to 3; 
    j <- 0 to 2) yield (i,j) 

Die abgeflachte Lösung ist semantisch anders.