Regole sull'utilizzo un'istruzione case per distruggere una tupla a Scala

Question

Ho il seguente codice:

val xs = List(('a', 1), ('a', 2), ('b', 3), ('b', 4)) 

voglio trasformare questo in una mappa. per esempio. Map('a' -> Seq(1,2), 'b' -> Seq(3,4)). Così procedo a scrivere la trasformazione:

xs.groupBy(_._1) map { 
    case (k, v) => (k, v.map(_._2)) 
} 

Perché la coppia dopo la cartina bisogno di essere un {. Quando ho iniziato, ritenevo di poter fare quanto segue:

xs.groupBy(_._1).map(case (k, v) => (k, v.map(_._2))) 

Ma questo non viene compilato.

Answer 1

sembra che la vera questione qui è quando è possibile utilizzare la parentesi ( al posto delle parentesi graffe { per rappresentare una funzione anonima. Raccomando di dare un'occhiata a Daniel Sobral's answer alla domanda: What is the formal difference in Scala between braces and parentheses, and when should they be used?

Answer 2

Perché .map method accepts a function

Quello che hai effettivamente scritto è

map({ 
    case (k, v) => (k, v.map(_._2)) 
}) 

e il { case (k, v) => (k, v.map(_._2)) } è una definizione scorciatoia per pattern matching funzione anonima (SLS, §8.5) che è one of the function kinds:

val isOdd: PartialFunction[Int, String] = { 
    case x if x % 2 == 1 => x+" is odd" 
} 

val upcastedIsOdd: Function[Int, String] = { 
    case x if x % 2 == 1 => x+" is odd" 
} 

Non è possibile OMMIT parentesi graffe (così avrete sciolto funzione parziale e Patten genicità, corrispondenza), ma si può saltare bretelle semplici (e conservano ancora la funzione parziale), proprio come nel frammento di seguito:

scala> List(1,2,3).take(1) 
//res0: List[Int] = List(1) 
scala> List(1,2,3) take 1 
//res1: List[Int] = List(1)