¿Existe alguna manera más clara de emparejar patrones en las funciones anónimas de Scala?

Question

me encuentro escribiendo código como el siguiente:

val b = a map (entry => 
    entry match { 
     case ((x,y), u) => ((y,x), u) 
    } 
) 

me gustaría escribir de manera diferente, aunque sólo sea esto funcionó:

val c = a map (((x,y) -> u) => 
    (y,x) -> u 
) 

¿Hay alguna manera de poder conseguir algo cerca de esto?

Answer 1

creas o no, esto funciona:

val b = List(1, 2) 
b map({case 1 => "one" 
     case 2 => "two"}) 

puede omitir el p => p match en casos sencillos. Así que esto debería funcionar:

val c = a map {case ((x,y) -> u) => 
    (y,x) -> u 
} 

Answer 2

En el ejemplo citado, la solución más limpia es:

val xs = List((1,2)->3,(4,5)->6,(7,8)->9) 
xs map { case (a,b) => (a.swap, b) } 

Answer 3

val b = a map { case ((x,y), u) => ((y,x), u) } 

Answer 4

En su ejemplo, hay tres semántica sutilmente diferentes que es posible que se va para.

1. Mapa sobre la colección, transformando cada elemento que coincida con un patrón. Lanza una excepción si algún elemento no coincide. Esta semántica se logran con

   val b = a map { case ((x, y), u) => ((y, x), u) } 
   

2. Mapa sobre la colección, transformando cada elemento que coincide con un patrón. En silencio descartar los elementos que no coinciden:

   val b = a collect { case ((x, y), u) => ((y, x), u) } 
   

3. Mapa sobre la colección, la desestructuración de manera segura y luego transformando cada elemento. Estos son la semántica que cabe esperar de una expresión como

   val b = a map (((x, y), u) => ((y, x), u))) 
   

   Desafortunadamente, no hay una sintaxis concisa para lograr esta semántica en Scala. En su lugar, usted tiene que desestructurar a sí mismo:

   val b = a map { p => ((p._1._2, p._1._1), p._2) } 
   

   Uno podría estar tentado a utilizar una definición de valor de desestructuración:

   val b = a map { p => val ((x,y), u) = p; ((y, x), u) } 
   

   Sin embargo, esta versión is no more safe than the one that uses explicit pattern matching. Por esta razón, si quieres la semántica desestructuración de seguridad, la solución más concisa es escribir de forma explícita su colección para prevenir ensanchamiento no deseado y el uso explícito reconocimiento de patrones:

   val a: List[((Int, Int), Int)] = // ... 
   // ... 
   val b = a map { case ((x, y), u) => ((y, x), u) } 
   

   Si la definición a 's parece lejos de su uso (por ejemplo, en una unidad de compilación por separado), se puede minimizar el riesgo por atribuir su tipo en el mapa de llamada:

   val b = (a: List[((Int, Int), Int)]) map { case ((x, y), u) => ((y, x), u) }