在Scala中，有没有一种简洁明了的方法来比较一个值与多个值

Question

假设我有一个变量 x，我想检查它是否等于多个值 a、b、c、d、e 中的任何一个（我的意思是 == 相等，而不是恒等）。

在 SQL 查询中，相同的概念可以通过

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

Scala 中是否有类似的东西来处理，就这么简单？我知道可以使用复杂的表达式在一行中完成此操作，例如构建 HashSet 并检查集合中是否存在，但我更愿意使用简单的构造（如果可用）。

Answer 1

您可以按如下方式实现 in 运算符：

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

Answer 2

我更喜欢 contains(a) 而不是 exists(_ == a)：

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

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

更新：contains 是在 SeqLike，所以上面的代码适用于任何序列。

更新2：这是 包含在SeqLike中：

def contains(elem: Any): Boolean = exists (_ == elem)

Answer 3

假设 Set[A] 也是 A => Boolean，你可以说：

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

为此定义一些 pimpin' 糖实际上非常好：

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

然后你可以像这样编写代码：

x ∈: Set(a, b, c, d, e)

Answer 4

通过综合所有其他答案，我得出了正确答案：

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。

Answer 5

存在：

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

查找和过滤接近：

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

与其他答案一样，我的第一个答案是使用 contains:

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

但后来我想，它只适用于像 4 这样的装箱值，不适用于区分身份和相等的类。为了证明这一点，我写了一个小类，这证明我错了::)

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) 

我明白了，我必须更频繁地使用 equals/eq/== ，才能将这些区别带入我的大脑。

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

恕我直言，答案是最简单的。

Answer 6

Set(a, b, c, d, e)(x) 也有效。我将把这样做的原因留给读者作为练习。 :-)

Answer 7

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)

Answer 8

也适用于 Scala 3 的解决方案：（

implicit class PowerAny[A](a: A) {
  /**
   * 2 in (1,2,3,"foo") -> true
   *
   * 4 in (1,2,3,"foo") -> false
   */
  def in(seq: A*): Boolean = seq.contains(a)
}

我更新其他解决方案之一的请求被拒绝。）