Scala：当两个项目之一满足某些条件时进行模式匹配

Question

我经常编写比较两个对象的代码，并根据它们是否相同或不同（根据它们的不同之处）生成一个值。

所以我可能会写：

val result = (v1,v2) match {
  case (Some(value1), Some(value2)) => "a"
  case (Some(value), None)) => "b"
  case (None, Some(value)) => "b"
  case _ = > "c"
}

第二个和第三个案例实际上是相同的，所以我尝试写：

val result = (v1,v2) match {
  case (Some(value1), Some(value2)) => "a"
  case (Some(value), None)) || (None, Some(value)) => "b"
  case _ = > "c"
}

但没有运气。

我在几个地方遇到这个问题，这只是一个具体的例子，更一般的模式是我有两件事，我想知道其中是否只有一个满足某个谓词，所以我想写像这样的东西：

val result = (v1,v2) match {
  case (Some(value1), Some(value2)) => "a"
  case OneAndOnlyOne(value, v: Option[Foo] => v.isDefined ) => "b"
  case _ = > "c"
}

所以这里的想法是 OneAndOnlyOne 可以配置一个谓词（在本例中是 isDefined ），并且您可以在多个地方使用它。

上面的代码根本不起作用，因为它是反向的，谓词需要传递到提取器中而不是返回。

像这样的事情怎么样？

val result = (v1,v2) match {
  case (Some(value1), Some(value2)) => "a"
  case new OneAndOnlyOne(v: Option[Foo] => v.isDefined )(value) => "b"
  case _ = > "c"
}

with：

class OneAndOnlyOne[T](predicate: T => Boolean) {
  def unapply( pair: Pair[T,T] ): Option[T] = {
    val (item1,item2) = pair
    val v1 = predicate(item1)
    val v2 = predicate(item2)

    if ( v1 != v2 )
      Some( if ( v1 ) item1 else item2 )
    else
      None
  }
}

但是，这不能编译。

任何人都可以找到使该解决方案发挥作用的方法吗？或者提出另一种解决方案？我可能让这件事变得更加复杂:)

Answer 1

我认为您在问两个略有不同的问题。

一个问题是如何在 switch 语句中使用“or”。 ||不起作用； |做。在这种情况下，您不能使用变量（因为通常它们可能匹配不同的类型，这会使类型变得混乱）。所以：

def matcher[T](a: (T,T)) = {
  a match {
    case (Some(x),Some(y)) => "both"
    case (Some(_),None) | (None,Some(_)) => "either"
    case _ => "none"
  }
}

另一个问题是如何避免一遍又一遍地这样做，特别是如果您希望能够获取元组中的值。我在这里为 Option 实现了一个版本，但您可以使用未包装的元组和布尔值。

实现此目的的一个技巧是，在开始匹配值之前预先包装值，然后使用您自己的匹配结构来执行您想要的操作。例如，

class DiOption[+T] {
  def trinary = this
}
case class Both[T](first: T, second:T) extends DiOption[T] { }
case class OneOf[T](it: T) extends DiOption[T] { }
case class Neither() extends DiOption[Nothing] { }
implicit def sometuple2dioption[T](t2: (Option[T],Option[T])): DiOption[T] = {
  t2 match {
    case (Some(x),Some(y)) => Both(x,y)
    case (Some(x),None) => OneOf(x)
    case (None,Some(y)) => OneOf(y)
    case _ => Neither()
  }
}

// Example usage
val a = (Some("This"),None)
a trinary match {
  case Both(s,t) => "Both"
  case OneOf(s) => "Just one"
  case _ => "Nothing"
}

Answer 2

如果您必须支持任意谓词，您可以从中派生（基于 丹尼尔的想法）：

List(v1, v2) filter (_ %2 == 0) match {
    case List(value1, value2) => "a"
    case List(value) => "b"
    case _ => "c"
}

函数的定义：

def filteredMatch[T,R](values : T*)(f : T => Boolean)(p: PartialFunction[List[T], R]) : R = 
    p(List((values filter f) :_* ))

现在你可以像这样使用它：

filteredMatch(v1,v2)(_ %2 == 0){
    case List(value1, value2) => "a"
    case List(value) => "b"
    case _ => "c"
}

我不太确定这是否是一个好主意（即可读）。但这仍然是一个巧妙的练习。

如果您可以匹配元组，那就太好了：case (value1, value2) => ... 而不是列表。

Answer 3

这个怎么样：

    Welcome to Scala version 2.8.0.r20327-b20091230020149 (Java HotSpot(TM) Client VM, Java 1.6.0_17).
Type in expressions to have them evaluated.
Type :help for more information.

scala> def m(v1: Any,v2: Any) = (v1,v2) match {
     |     case (Some(x),Some(y)) => "a"
     |     case (Some(_),None) | (None,Some(_)) => "b"
     |     case _ => "c"
     | }
m: (v1: Any,v2: Any)java.lang.String

scala> m(Some(1),Some(2))
res0: java.lang.String = a

scala> m(Some(1),None)
res1: java.lang.String = b

scala> m(None,None)
res2: java.lang.String = c

scala>

Answer 4

如果您首先将其定义为 val，您应该能够做到这一点：

val MyValThatIsCapitalized = new OneAndOnlyOne(v: Option[Foo] => v.isDefined )
val result = (v1,v2) match {
  case (Some(value1), Some(value2)) => "a"
  case MyValThatIsCapitalized(value) => "b"
  case _ = > "c"
}

正如名称所暗示的，包含提取器对象的 val 的名称必须大写。

Answer 5

在 Scala 2.8 上：

val result = List(v1,v2).flatten match {
  case List(value1, value2) => "a"
  case List(value) => "b"
  case _ = > "c"
}

但是，在 Scala 2.7 上，您需要类型提示才能使其工作。因此，假设 value 是 Int，那么：

val result = (List(v1,v2).flatten : List[Int]) match {
  case List(value1, value2) => "a"
  case List(value) => "b"
  case _ = > "c"
}

有趣的是，我在 Mitch Blevins 回答，这给了我这个想法。 :-)

Answer 6

由于您已经匹配了 (Some(x), Some(y))，因此您可以显式匹配 (None, None)，其余情况为 (Some(x), None) 和 (None, Some(y)) :

def decide [T](v1: Option[T], v2:Option[T]) = (v1, v2) match {
  case (Some (x), Some (y)) => "a"
  case (None, None)         => "c"
  case _                    => "b"
}

val ni : Option [Int] = None 
decide (ni, ni)            // c
decide (Some (4), Some(3)) // a
decide (ni, Some (3))      // b
decide (Some (4), ni)      // b