Scala Pattern Matching with Sets

Question

Poniższe nie działają.

object Foo { 
    def union(s: Set[Int], t: Set[Int]): Set[Int] = t match { 
     case isEmpty => s 
     case (x:xs) => union(s + x, xs) 
     case _  => throw new Error("bad input") 
    } 
} 

error: not found: type xs

Jak mogę wzór mecz na planie?

Answer 1

No x:xs oznacza x typu xs, więc to nie będzie działać. Ale, niestety, nie można wzorować zestawów dopasowań, ponieważ zestawy nie mają zdefiniowanego porządku. Lub bardziej pragmatycznie, ponieważ nie ma ekstraktora na Set.

Zawsze można definiować własne, choć:

object SetExtractor { 
    def unapplySeq[T](s: Set[T]): Option[Seq[T]] = Some(s.toSeq) 
} 

Na przykład:

scala> Set(1, 2, 3) match { 
    | case SetExtractor(x, xs @ _*) => println(s"x: $x\nxs: $xs") 
    | } 
x: 1 
xs: ArrayBuffer(2, 3) 

Answer 2

Po pierwsze, Twój isEmpty będzie przechwytywał każdy Set, ponieważ jest zmienną w tym kontekście. Stałe zaczynają się od dużej litery w Scali i są traktowane tylko jako stałe, jeśli ten warunek jest spełniony. Tak małe przydzieli jakikolwiek Set do isEmpty (szukałeś EmptySet?)

jak widać here, wydaje się, że dopasowywanie do wzorca nie jest bardzo korzystne dla Set s. powinieneś jawnie przekonwertować Set Do List lub Seq (toList/toSeq)

object Foo { 
    def union(s: Set[Int], t: Set[Int]): Set[Int] = t.toList match { 
     case Nil => s 
     case (x::xs) => union(s + x, xs.toSet) 
     case _  => throw new Error("bad input") 
    } 
} 

Answer 3

Set nie jest case class i nie ma sposobu unapply.

Te dwie rzeczy sugerują, że nie można dopasować wzoru bezpośrednio na Set.
(aktualizacja: chyba zdefiniować własną ściągacza dla Set, jak Daniel poprawnie pokazuje w swojej odpowiedzi)

Powinieneś znaleźć alternatywę, polecam użyciu krotny funkcji

def union(s: Set[Int], t: Set[Int]): Set[Int] = 
    (s foldLeft t) {case (t: Set[Int], x: Int) => t + x} 

to gromadzą się elementy s na t, dodając je pojedynczo

---

składane

Oto docs dla krotnym pracy, jeśli to konieczne dla odniesienia:

foldLeft[B](z: B)(op: (B, A) ⇒ B): B 

Dotyczy operatora binarnego do wartości początkowej i wszystkich elementów tego zbioru, idąc od lewej do prawej.

Uwaga: może zwracać różne wyniki dla różnych serii, chyba że zamówiono podstawowy typ kolekcji. lub operator jest asocjacyjny i przemienny.

B the result type of the binary operator. 
z the start value. 
op the binary operator. 
returns the result of inserting op between consecutive elements of this set, going left to right with the start value z on the left: 

op(...op(z, x_1), x_2, ..., x_n) 
where x1, ..., xn are the elements of this set. 

Answer 4

To co mogę wymyślić:

object Contains { 
    class Unapplier[T](val t: T) { 
    def unapply(s: Set[T]): Option[Boolean] = Some(s contains t) 
    } 
    def apply[T](t: T) = new Unapplier(t) 
} 

object SET { 
    class Unapplier[T](val set: Set[T]) { 
    def unapply(s: Set[T]): Option[Unit] = if (set == s) Some(Unit) else None 
    } 
    def apply[T](ts: T*) = new Unapplier(ts.toSet) 
} 

val Contains2 = Contains(2) 
val SET123 = SET(1, 2, 3) 

Set(1, 2, 3) match { 
    case SET123()   => println("123") 
    case Contains2(true) => println("jippy") 
    case Contains2(false) => println("ohh noo") 
}