Kann ich die Map-Sammlung in Scala mit For-Yield-Syntax zurückgeben?

Question

Ich bin ziemlich neu in Scala, so hoffentlich tolerieren Sie diese Frage in dem Fall, dass Sie es noobish finden :)

ich eine Funktion geschrieben, die eine Seq von Elementen Ausbeute Syntax gibt:

def calculateSomeMetrics(names: Seq[String]): Seq[Long] = { 
    for (name <- names) yield { 
    // some auxiliary actions 
    val metrics = somehowCalculateMetrics() 
    metrics 
    } 
} 

jetzt muss ich es ändern, um eine Karte zurück die ursprünglichen Namen gegen jeden der berechneten Werte zu erhalten:

def calculateSomeMetrics(names: Seq[String]): Map[String, Long] = { ... } 

ich versucht habe die gleiche Ausbeute-Syntax zu verwenden, aber ein Tupel statt eines einzelnen Elements zu erhalten :

def calculateSomeMetrics(names: Seq[String]): Map[String, Long] = { 
    for (name <- names) yield { 
    // Everything is the same as before 
    (name, metrics) 
    } 
} 

jedoch der Compiler interpretiert es Seq[(String, Long)], gemäß der Compiler-Fehlermeldung

type mismatch; 
    found : Seq[(String, Long)] 
    required: Map[String, Long] 

Also ich frage mich, was ist die "kanonische Scala Art und Weise", so etwas zu implementieren?

Answer 1

Entweder:

def calculateSomeMetrics(names: Seq[String]): Map[String, Long] = { 
    (for (name <- names) yield { 
    // Everything is the same as before 
    (name, metrics) 
    }).toMap 
} 

Oder:

names.map { name => 
    // doStuff 
    (name, metrics) 
}.toMap 

Answer 2

Die effiziente Art und Weise unterschiedliche Sammlungstypen schaffen scala.collection.breakOut verwendet. Es arbeitet mit Map s und für Comprehensions zu:

import scala.collection.breakOut 

val x: Map[String, Int] = (for (i <- 1 to 10) yield i.toString -> i)(breakOut) 

x: Map [String, Int] = Karte (8 -> 8, 4 -> 4, 9 -> 9, 5 -> 5, 10 -> 10, 6 -> 6, 1 -> 1, 2 -> 2, 7 -> 7, 3 -> 3)

In Ihrem Fall sollte es funktioniert auch:

import scala.collection.breakOut 

def calculateSomeMetrics(names: Seq[String]): Map[String, Long] = { 
    (for (name <- names) yield { 
    // Everything is the same as before 
    (name, metrics) 
    })(breakOut) 
} 

Vergleich mit toMap Lösungen: vor toMap erstellt ein Zwischenprodukt Seq von Tuple2 s (die übrigens vielleicht eine Map auch in bestimmten Fällen) und dass es die Map erzeugt, während breakOut diese Zwischen Seq Schöpfung läßt und schafft die Map direkt anstelle der Zwischen Seq.

Normalerweise ist dies kein großer Unterschied in der Speicher- oder CPU-Auslastung (+ GC-Druck), aber manchmal sind diese Dinge wichtig.

Answer 3

Mehrere Links hier, auf die mich entweder andere Leute hingewiesen haben oder die ich später herausgefunden habe, indem ich sie in einer einzigen Antwort für meine zukünftige Referenz zusammengestellt habe.

• breakOut - vorgeschlagen von Michał in his comment
• toMap - in this thread
• Großer tiefer Erklärung, wie breakOut Werke - in this answer
  • Beachten Sie jedoch, dass breakOutis going away, wie bereits von Karl