使用模式在斯卡拉

Question

爲Ordered.compare匹配，我有以下的Scala類：

case class Person(firstName: String, lastName: String, age: Int) 
    extends Ordered[Person] { 
    def compare(that: Person): Int = { 
    if (this.lastName < that.lastName) -1 
    else if (this.lastName > that.lastName) 1 
    else if (this.firstName < that.firstName) -1 
    else if (this.firstName > that.firstName) 1 
    else this.age compare that.age 
    } 
} 

允許通過姓氏，名字，和年齡排序。

如何使用模式匹配來編寫此代碼？我已經提出了以下內容，但有沒有更好的方法？

case class Person(firstName: String, lastName: String, age: Int) 
    extends Ordered[Person] { 
    def compare(that: Person): Int = { 
    that match { 
     case Person(_, thatLastName, _) if this.lastName < thatFile => -1 
     case Person(_, thatLastName, _) if this.lastName > thatFile => 1 

     case Person(thatFirstName, _, _) if this.firstName < thatFirstName => -1 
     case Person(thatFirstName, _, _) if this.firstName > thatFirstName => 1 

     case Person(_, _, thatAge) => this.age compare thatAge 
    } 
    } 
} 

UPDATE：改爲使用Ordering[A]按照Landei的回答是：

implicit val personOrdering = new Ordering[Person] { 
    def compare(first: Person, second:Person): Int = { 
    second match { 
     case Person(_, thatLastName, _) if first.lastName < thatLastName => -1 
     case Person(_, thatLastName, _) if first.lastName > thatLastName => 1 

     case Person(thatFirstName, _, _) if first.firstName < thatFirstName => -1 
     case Person(thatFirstName, _, _) if first.firstName > thatFirstName => 1 

     case Person(_, _, thatAge) => first.age compare thatAge 
    } 
    } 
} 

case class Person(firstName: String, lastName: String, age: Int) 

但似乎尷尬，我只匹配second。我怎樣才能讓它更「優雅」？

Answer 1

Scala中的首選方法是提供一個隱式的Ordering而不是Ordered，它更加靈活，並且不會引發關於繼承的頭痛問題。

關於模式匹配，我沒有看到更好的方法，因爲比較方法的結果是Int，它們不能保證爲-1,0,1。Haskell解決方案返回「枚舉」對象（LT， EQ，GT）更清晰且模式匹配，但似乎Scala遵循C++/Java傳統，出於兼容性原因。

當然你可以推出自己比較「框架」作者：

abstract sealed class CompResult(val toInt:Int) { 
    def andThen(next: => CompResult): CompResult 
} 
case object LT extends CompResult(-1) { 
def andThen(next: => CompResult) = LT 
} 
case object EQ extends CompResult(0) { 
    def andThen(next: => CompResult) = next 
} 
case object GT extends CompResult(1) { 
    def andThen(next: => CompResult) = GT 
} 

implicit def int2Comp(n:Int) = 
    if (n == 0) EQ else if (n < 0) LT else GT 


(("sdkfhs" compareTo "fldgkjdfl"):CompResult) match { 
    case LT => println("less") 
    case EQ => println("same") 
    case GT => println("more") 
} 

你的情況，你可以寫：

case class Person(firstName: String, lastName: String, age: Int) 
    extends Ordered[Person] { 
    def compare(that: Person): Int = { 
    (this.lastName compareTo that.lastName). 
    andThen (this.firstName compareTo that.firstName). 
    andThen (this.age compare that.age).toInt 
    } 
}