In Scala gibt es eine saubere und einfache Art und Weise zu vergleichen, einen Wert mit mehreren Werten

Sagen, ich habe eine variable x, und ich möchte prüfen, ob es gleich zu einem von mehreren Werten a, b, c, d, e (ich meine die == Gleichheit, nicht Identität).

In einer SQL-Abfrage das gleiche Konzept ist behandelt mit

WHERE x IN (a, b, c, d, e).

Gibt es etwas vergleichbares in Scala das ist so einfach, wie das? Ich weiß, es ist sonst möglich, es zu tun in einer Linie mit einem komplexen Ausdruck wie dem Bau eines HashSet und überprüfung auf die Existenz in der Menge, aber ich würde es vorziehen, verwenden Sie ein einfaches Konstrukt, wenn es verfügbar ist.

InformationsquelleAutor Gigatron | 2011-05-08
  1. 22

    Ich würde lieber contains(a) über exists(_ == a):

    scala> List(3, 4, 5) contains 4
res0: Boolean = true

scala> List(3, 4, 5) contains 6
res1: Boolean = false

    Update: contains definiert ist, in SeqLike, so dass die oben genannten Werke mit einer beliebigen Sequenz.

    Update 2: Hier ist die definition von contains in SeqLike:

    def contains(elem: Any): Boolean = exists (_ == elem)
    • Tut mir Leid, ich habe Sie herunter, weil ich dachte contains würde nur die Arbeit mit Identität, nicht Gleichheit. Ich habe Sie nach unten und begann zu schreiben, ein Beweis mehr in meine Antwort, sondern ich bewies mich falsch. Sorry. 🙂
    • Und ich habe deine Antwort, weil, wie Sie sehen können, in meinem zweiten update contains(a) ist einfach nur Zucker für exists(_ == a) so unsere Antworten sind gleichwertig.
    • Vielleicht ist es einfach Zucker, ich bin süßer, und da Sie bearbeitet Ihre Antwort, ich konnte meine richtige Abstimmung. (Scala " ist nur syntaktischer Zucker für Java, was ist syntaktischer Zucker für assembler ...).
    InformationsquelleAutor Frank S. Thomas
  2. 24

    Könnten Sie implementieren eine in - operator wie folgt:

    scala> implicit def anyWithIn[A](a: A) = new {
     |   def in(as: A*) = as.exists(_ == a)
     | }
anyWithIn: [A](a: A)java.lang.Object{def in(as: A*): Boolean}

scala> 5 in (3, 4, 9, 11)
res0: Boolean = false

scala> 5 in (3, 4, 9, 11, 5)
res1: Boolean = true
    • Das ist wunderschön. Geht gleich in meine eigenen Satz von standard-Erweiterungen, die bis Ende in all meinen Projekten, und wohl auch die Verdienste der standard-Bibliothek Integration
    • Siehe meine Antwort für wie dies zu tun ist der anderen Umgekehrt: also ein pimp A => Boolean schreiben Sie 5 ∈: Set(1, 2, 3, 4, 5)
    • Ordentlich! Dieser sollte gebaut werden-in der nächsten version von Scala. Aber so wie es ist, wäre es erforderlich, explizit importieren oder Erben die implizite Konvertierung überall dort, wo es gebraucht wird, also jetzt werde ich mit der Liste/enthält Technik.
    InformationsquelleAutor missingfaktor
  3. 12

    Gegeben, dass ein Set[A] ist auch ein A => Boolean, können Sie einfach sagen:

    Set(a, b, c, d, e) apply x

    Es ist eigentlich ganz nett, um zu definieren, einige pimpin' Zucker für diese:

    class PredicateW[A](self : A => Boolean) {
  def ∈:(a : A) = self apply a
}
implicit def pred2wrapper[A](p : A => Boolean) = new PredicateW(p)

    Dann können Sie den code schreiben, etwa so:

    x ∈: Set(a, b, c, d, e)
    • Eine andere saubere Lösung, danke. Aber ich habe nicht die ' ∈ ' - symbol auf meiner US-Tastatur!
    InformationsquelleAutor oxbow_lakes
  4. 9

    Durch die Synthese alle anderen Antworten, ich habe mit der richtige Antwort:

    implicit def anyWithIn[A](a: A) = new {
    def ∈(as: A*) = as.contains(a)
}
anyWithIn: [A](a: A)java.lang.Object{def ?(as: A*): Boolean}

5 ∈ (1,3,5)
res1: Boolean = true

    Ta-da.

    • Hey, ich werde Sie verteidigen, als nachweislich besser als jede andere Antwort, die bisher (mehr lesbar als missingfaktor Lösung mehr pimplicious als Oxbow_lakes ist, verständlicher und Dan...)
    InformationsquelleAutor Malvolio
  5. 5

    vorhanden ist:

     List (3, 4, 5).exists (_ == 4)
 //res20: Boolean = true

    finden und filtern nahe kommen:

    List (3, 4, 5).find (_ == 4)
//res16: Option[Int] = Some(4)
List (3, 4, 5).filter (_ == 4)
//res17: List[Int] = List(4)

    Meine erste Antwort war, wie die anderen Antworten, zu verwenden enthalten:

    List (3, 4, 5).contains (4)

    aber dann dachte ich, es wäre nur Arbeit für Box-Werte wie 4, nicht für Klassen, zwischen Identität und Gleichheit. Um das zu beweisen, schrieb ich eine kleine Klasse, die sich mir falsch: 🙂 

    class Ue (val i: Int) { 
  override def equals (other: Any) = other match {
    case o: Ue => i == o.i
    case _ => false }
}

val a = new Ue (4)
//a: Ue = Ue@1e040e5
val b = new Ue (4)
//b: Ue = Ue@1a4548b (no identity)
a == b
//res110: Boolean = true (surprise?) 
a.equals (b)
//res112: Boolean = true (expected)
a.eq (b)
//res113: Boolean = false (expected) 
List (a).contains (b)    
//res119: Boolean = true (surprise)
List (a).exists (_ == b) 
//res120: Boolean = true (expected) 
List (a).exists (_ .eq (b)) 
//res121: Boolean = false (expected)

    Ich sehe, habe ich gleich/eq/== öfter, um die Unterscheidungen in mein Gehirn. 

    List (3, 4, 5).contains (4)

    ist imho die Antwort, die die meisten einfach.

    InformationsquelleAutor user unknown
  6. 4

    Set(a, b, c, d, e)(x) so gut funktioniert. Ich lasse die Gründe für es als eine übung für den Leser. 🙂

    InformationsquelleAutor Daniel C. Sobral
  7. 0
    class Ue (val i: Int) { 
  override def equals (other: Any) = other match {
    case o: Ue => i == o.i
    case _ => false }
}

val a = new Ue (4)
//a: Ue = Ue@1e040e5
val b = new Ue (4)
//b: Ue = Ue@1a4548b (no identity)
a == b
//res110: Boolean = true (surprise?) 
a.equals (b)
//res112: Boolean = true (expected)
a.eq (b)
//res113: Boolean = false (expected) 
List (a).contains (b)    
//res119: Boolean = true (surprise)
List (a).exists (_ == b) 
//res120: Boolean = true (expected) 
List (a).exists (_ .eq (b)) 
//res121: Boolean = false (expected)
    InformationsquelleAutor king of codex
Schreibe einen Kommentar