scala：在条件中指定不同备选方案的快捷方式（运算符isOneOf）

我经常有如下代码

if (operator == Equal || operator == Missing || operator == Unknown) {

为了让它不那么冗长，更具可读性，有时我会发布：

if（列表（相等、缺失、未知）.contains（运算符））{

我知道我也可以发布模式匹配，就像这样

operator match {
  case Equal | Missing | Unknown => {

class ComparableWithIsOneOf[T](val value: T) {
  def isOneOf(values: T*): Boolean = {
    values.contains(value)
  }
}

这带来了另一个层次的嵌套大括号

我想知道是否有这样的方法

if (operator.isOneOf(List(Equal, Missing, Unknown))) {

--

编辑：

要显示如何使用此处显示的不同选项，请执行以下操作：

使用Set作为函数

if (Set(1, 2, 3)(3)) {
  "Gotcha"
} else {
  "no luck..."
}

使用PartialFunction.cond

import PartialFunction.cond

if (cond(3) { case 1 | 2 | 3 => true }) {
  "Gotcha"
} else {
  "no luck..."
}

实施isOneOf

class ComparableWithIsOneOf[T](val value: T) {
  def isOneOf(values: T*): Boolean = {
    values.contains(value)
  }
}
object Comparison {
  object implicits {
    implicit def AnyToComparableWithIsOneOf[T](value: T): ComparableWithIsOneOf[T] = {
      return new ComparableWithIsOneOf(value)
    }
  }
}

import Comparison.implicits._

if (3.isOneOf(1, 2, 3)) {
  "Gotcha"
} else {
  "no luck..."
}

最后，我更喜欢Set（）版本，但我认为最好还是坚持模式匹配，更标准、更惯用……

您可以直接编写

if (Set(Equal, Missing, Unknown)(operator)) { ...

---

设置

功能等。

我们还可以将您的模式匹配解决方案定义为：

自己写：

scala> implicit class IsOneOf[A](a: A) { def isOneOf(as: A*) = as contains a }
defined class IsOneOf

scala> trait Trait
defined trait Trait

scala> case object Equal extends Trait
defined module Equal

scala> case object Missing extends Trait
defined module Missing

scala> case object Unknown extends Trait
defined module Unknown

scala> case object Else extends Trait
defined module Else

scala> def test(t: Trait) = t.isOneOf(Equal, Missing, Unknown)
test: (t: Trait)Boolean

scala> test(Missing)
res25: Boolean = true

scala> test(Else)
res26: Boolean = false

这也是类型安全的：

scala> 1.isOneOf("")
<console>:12: error: type mismatch;
 found   : String("")
 required: Int
              1.isOneOf("")
                        ^

scala>1.isOneOf（“”）
：12：错误：类型不匹配；
找到：字符串（“”）
必填项：Int
1.isOneOf（“”）
^

我试图实现它，这就是我得到的

首先，我用isOneOf方法定义一个泛型类，如下所示

operator match {
  case Equal | Missing | Unknown => {

class ComparableWithIsOneOf[T](val value: T) {
  def isOneOf(values: T*): Boolean = {
    values.contains(value)
  }
}

然后我定义了一个隐式转换器（double nesting Comparison.implicits只是为了简化导入…）

要使用它，我只发布：

import Comparison.implicits._

if (3.isOneOf(1, 2, 3)) {
  "Gotcha"
} else {
  "no luck..."
}

它没有那么多代码，结果是类型安全的

---

无论如何，我认为使用模式匹配更好，我觉得它更惯用…

谢谢，你给了我一些开始的想法（请看一下我的解决方案），但我得到了：19：错误：`隐式'修饰符只能用于值、变量和方法“…您使用的是什么版本的scala？我支持2.9.1。final@opensas在2.10中引入