按多个条件排序的Scala习惯用法

Question

我想这样做：

class Foo extends Ordered[Foo] {
   val x
   val y
   val z
   .
   .
   .
   .
   def compare(that: Foo) = {
      val c0 = this.length compareTo that.length          // primary comparison
      lazy val c1 = this.x compareTo that.x               // secondary comparison
      lazy val c2 = this.y.size compareTo that.y.size     // tertiary comparison
      lazy val c3 = this.z.head compareTo that.z.head     // final tie breaker
      if (c0 != 0) c0 else if (c1 != 0) c1 else if (c2 != 0) c2 else if (c3 != 0) c3 else c4
   }    
}

我在想有没有更干净的方法来写这种东西。我期待一些东西像Ordering.multipleBy（排序：有序[A]*）签名，它需要一个可比变量并选择第一个非零。

Answer 1

我能想到的最好的办法是：

def compare(that: Foo) = multiCompare(
  this.length compareTo that.length      // primary comparison
  this.x      compareTo that.x,          // secondary comparison
  this.y.size compareTo that.y.size,     // tertiary comparison
  this.z.head compareTo that.z.head,     // final tie breaker
)

def multiCompare(c: ( => Int)*) = c find {_ != 0} getOrElse 0

Answer 2

如果你想要最高速度——我知道不是你要求的！-并且仍然清晰，你可以

def compare(that: Foo): Int = {
  this.length compareTo that.length match { case 0 =>; case c => return c }
  this.x      compareTo that.x      match { case 0 =>; case c => return c }
  this.y.size compareTo that.y.size match { case 0 =>; case c => return c }
  this.z.head compareTo that.z.head match { case 0 =>; case c => return c }
  0
}

还有各种基于收集的解决方案和其他解决方案，我将留给其他人来解释。（注意所有的样板文件，并注意到您真正需要知道的是每种情况下的。.length，例如，这会激发比较。）

Answer 3

通常最好使用订购而不是订购。订购是一个类型类，比订购灵活得多（如果只是因为订购必须由类型实现要比较，而与订购，您可以在外部定义此）。要为类型定义自然排序（默认的Ordle实例），只需在伴随对象中定义一个隐式排序值。

所以，序言就够了。很好的一点是，当使用排序时，您想要做的事情非常简单，因为元组有一个隐式排序（前提是元组元素本身有一个排序）`：

object Foo {
  implicit val FooOrdering = Ordering.by{ foo: Foo => 
    (foo.length, foo.x, foo.y, foo.z) 
  }
}

此外，还有一种隐式转换，它将任何具有Ordering类型类实例的值转换为Ordered值（请参见Ordered.orderingtooordered），因此我们没有什么特殊的事情可以自动将Foo的任何实例传递给期望有序的函数[Foo]）

更新：关于你的新问题：

稍微相关-是否有任何方法来编写订单？

一种方法是基于排序使用几乎相同的技术。通过和转换为元组，但显式传递要组合的顺序：

val byXOrdering = Ordering.by{ foo: Foo => foo.x }
val byYOrdering = Ordering.by{ foo: Foo => foo.y }
val byZOrdering = Ordering.by{ foo: Foo => foo.z }

// Compose byXOrdering and byYOrdering:
val byXThenYOrdering = Ordering.by{ foo: Foo => (foo, foo) }(Ordering.Tuple2(byXOrdering, byYOrdering))

// Compose byXOrdering and byYOrdering and byZOrdering:
val byXThenYThenZOrdering = Ordering.by{ foo: Foo => (foo, foo, foo) }(Ordering.Tuple3(byXOrdering, byYOrdering, byZOrdering))

但它相对“嘈杂”。仅使用标准库无法找到更好的方法，因此我建议使用我们自己的助手：

final class CompositeOrdering[T]( val ord1: Ordering[T], val ord2: Ordering[T] ) extends Ordering[T] {
  def compare( x: T, y: T ) = {
    val comp = ord1.compare( x, y )
    if ( comp != 0 ) comp else ord2.compare( x, y )
  }
}
object CompositeOrdering {
  def apply[T]( orderings: Ordering[T] * ) = orderings reduceLeft (_ orElse _)
}
implicit class OrderingOps[T]( val ord: Ordering[T] ) extends AnyVal {
  def orElse( ord2: Ordering[T] ) = new CompositeOrdering[T]( ord, ord2 )
}

可以这样使用：

val byXOrdering = Ordering.by{ foo: Foo => foo.x }
val byYOrdering = Ordering.by{ foo: Foo => foo.y }
val byZOrdering = Ordering.by{ foo: Foo => foo.z }

// Compose byXOrdering and byYOrdering:
val byXThenYOrdering = byXOrdering orElse byYOrdering

// Compose byXOrdering and byYOrdering and byZOrdering:
val byXThenYThenZOrdering = byXOrdering orElse byYOrdering orElse byZOrdering

或者更简单，像这样：

// Compose byXOrdering and byYOrdering:
val byXThenYOrdering = CompositeOrdering(byXOrdering, byYOrdering)

// Compose byXOrdering and byYOrdering and byZOrdering:
val byXThenYThenZOrdering = CompositeOrdering(byXOrdering, byYOrdering, byZOrdering)

CompositeOrdering。apply基本上就是您所说的排序。在您的问题中使用multipleBy。