Scalaの匿名関数でパターンマッチングするためのよりクリーンな方法がありますか？

Question

私は自分自身には、次のようなコードを書く見つける：

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

私はこれだけ働いていた場合、別々にそれを書きたい：

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

は、私がこれに近いものを得ることができる方法はありますか？

Answer 1

は信じられないかもしれませんが、これは動作します：

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

あなたは、単純な例でp => p matchをスキップすることができます。だから、これは動作するはずです：

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

Answer 2

あなたの引用された例では、クリーンなソリューションです：

あなたの例で

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

、あなたがのために行くことも3つの微妙に異なる意味があります。

1. パターンに一致する各要素を変換してマップします。要素が一致しない場合は例外をスローします。これらのセマンティクスは、パターンに一致する各要素を変換してコレクション全体を変換することにより、

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

2. でマップされます。安全に構造化代入し、各要素を変換する、コレクションの

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

3. 地図：サイレント一致していない要素を捨てます。これらは、私は残念ながら

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

   のように表現するために期待されるセマンティクスは、Scalaではこれらのセマンティクスを達成するために何の簡潔な構文はありません。 は代わりに、あなた自身をdestructureする必要があります：

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

   一つは、非構造のために価値の定義を使用するように誘惑されることがあります。

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

   しかし、このバージョンis no more safe than the one that uses explicit pattern matching。 （aの定義は、その使用から遠く見える

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

   場合：あなたは安全な非構造セマンティクスをしたい場合は、このような理由から、最も簡潔な解決策は、明示的に意図しない拡大を防止し、明示的なパターンマッチングを使用するようにあなたのコレクションを入力することです

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