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(ordering: Ordered[A]*)签名这样的东西,它采用可比较的varargs并选择第一个非零.

Answer 1

通常最好使用Ordering而不是Ordered.Ordering是一个类型类,并且比它更灵活Ordered(如果只是因为Ordered必须通过要比较的类型来实现,而Ordering你可以在外面定义它).要Ordering为您的类型定义自然排序(默认实例),您只需在随播对象中定义隐式排序值.

所以,序言就足够了.好的是,当Ordering你使用你想要做的事情时非常简单,因为元组有一个隐式排序(假设元组元素本身有一个排序)`:

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

此外,还有的是转换一个具有任何价值的隐式转换Ordering类型的类实例为Ordered值(见Ordered.orderingToOrdered),所以我们没有什么特别要做的,自动将能够通过的任何实例Foo给需要的函数Ordered[Foo])

更新:关于你的新问题:

有点相关 - 有没有办法组成订单？

一种方法是使用基本相同的技术Ordering.by并转换为元组,但明确地将顺序传递给compose:

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基本上就是你Ordering.multipleBy在问题中所说的.

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每种情况...... compareBy例如,这会激励a .)