Czy istnieje dokładniejszy sposób porównywania wzorców w anonimowych funkcjach Scala?

Question

znajdę się pisania kodu jak poniżej:

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

chciałbym napisać to w inny sposób, jeśli tylko to działało:

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

Czy jest jakiś sposób mogę uzyskać coś podobnego do tego?

Answer 1

Wierzcie lub nie, to działa:

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

można pominąć p => p match w prostych przypadkach. Tak to powinno działać:

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

Answer 2

w twojej cytowany przykład najczystsze rozwiązanie:

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

W przykładzie, istnieją trzy różne subtelnie semantyka, że ​​można jechać do.

1. Mapuj na kolekcji, przekształcając każdy element pasujący do wzorca. Wyrzuć wyjątek, jeśli dowolny element nie pasuje. Te semantyka są osiągane z

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

2. mapę nad kolekcji, przekształcając każdy element, który pasuje do wzorca. Po cichu usunąć elementy, które nie pasują:

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

3. mapę nad kolekcji, bezpiecznie i demontażu struktury następnie przekształcając każdy element. Są to semantyka że spodziewałbym dla wyrażenia jak

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

   Niestety, nie ma zwięzły składnia do osiągnięcia tych semantykę w Scala. Zamiast tego trzeba destructure siebie:

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

   Jeden może być skłonny do korzystania z definicji wartości dla destructuring:

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

   Jednak ta wersja is no more safe than the one that uses explicit pattern matching. Z tego powodu, jeśli chcesz bezpiecznych semantykę destructuring, najbardziej zwięzły rozwiązaniem jest wyraźnie wpisać swoją kolekcję, aby zapobiec przypadkowemu poszerzenie i używać wyraźny dopasowanie Wzór:

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

   Jeżeli definicja a „s pojawia się daleko od jego wykorzystania (np w osobnej jednostce kompilacji), można zminimalizować ryzyko, przypisując jej typ w zaproszeniu mapy:

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