在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

在你的榜樣，有可能會持續三個略有不同的語義。

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中沒有簡潔的語法來實現這些語義。 相反，你必須自己解構：

   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。出於這個原因，如果你想安全解構語義，最簡潔的解決方案是明確地鍵入您的收藏以防止意外擴大和使用明確的模式匹配：

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

   如果a的定義與它的使用遠看似（例如，在一個單獨的編譯單元），你可以在地圖調用歸咎於其類型的風險降到最低：

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