scala - tablas - comparar dos columnas en excel y extraer lo que no es igual

En Scala, ¿existe una forma clara y sencilla de comparar un valor con varios valores?

Question

Digamos que tengo una variable x, y quiero comprobar si es igual a cualquiera de los valores múltiples a, b, c, d, e (me refiero a la == igualdad, no a la identidad).

En una consulta SQL se maneja el mismo concepto con

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

¿Hay algo equivalente en Scala que sea tan sencillo como eso? Sé que de otra manera es posible hacerlo en una línea con una expresión compleja como construir un HashSet y verificar la existencia en el conjunto, pero prefiero usar una construcción simple si está disponible.

Answer 1

Al sintetizar todas las otras respuestas, he encontrado la respuesta correcta :

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 2

Dado que un Set[A] también es un A => Boolean , solo puedes decir:

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

En realidad, es bastante bueno definir un poco de azúcar de pimpin para esto:

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

Entonces puedes escribir el código así:

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

Answer 3

Podría implementar un operador in siguiente manera:

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 4

Preferiría que contains(a) en lugar de exists(_ == a) :

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

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

Actualización: contains está definido en SeqLike , por lo que lo anterior funciona con cualquier secuencia.

Actualización 2: Aquí está la definición de contains en SeqLike :

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

Answer 5

existe:

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

encontrar y filtrar acercarse:

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

Mi primera respuesta fue, como otras respuestas, utilizar contener:

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

pero luego pensé, solo funcionaría para valores en caja como 4, no para clases, que distinguen identidad e igualdad. Para probarlo, escribí una clase pequeña, que me demostró que estaba equivocada: :)

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) 

Veo, tengo que usar equals / eq / == más a menudo, para obtener las distinciones en mi cerebro.

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

Es la respuesta que es más fácil.

Answer 6

Set(a, b, c, d, e)(x) funciona. Dejaré las razones para ello como un ejercicio para el lector. :-)

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)