sort-comp.scala

sealed trait Order {
  def ===(rhs: Order): Boolean = (this, rhs) match {
    case (GT, GT) => true
    case (EQ, EQ) => true
    case (LT, LT) => true
    case _        => false
  }

  def /==(rhs: Order): Boolean = !(this === rhs)
}
final case object GT extends Order
final case object EQ extends Order
final case object LT extends Order

trait Ord[A] {
  def compare(a1: A, a2: A): Order
  def === (a1: A, a2: A): Boolean = compare(a1, a2) === EQ
  def /== (a1: A, a2: A): Boolean = compare(a1, a2) /== EQ
  def <   (a1: A, a2: A): Boolean = compare(a1, a2) === LT
  def <=  (a1: A, a2: A): Boolean = compare(a1, a2) /== GT
  def >   (a1: A, a2: A): Boolean = compare(a1, a2) === GT
  def >=  (a1: A, a2: A): Boolean = compare(a1, a2) /== LT
}

object Ord {
  implicit class OrdOps[A](a: A)(implicit O: Ord[A]) {
    def === (a2: A): Boolean = O.===(a, a2)
    def /== (a2: A): Boolean = O./==(a, a2)
    def <   (a2: A): Boolean = O.<  (a, a2)
    def <=  (a2: A): Boolean = O.<= (a, a2)
    def >   (a2: A): Boolean = O.>  (a, a2)
    def >=  (a2: A): Boolean = O.>= (a, a2)
  }

  implicit val IntOrd: Ord[Int] = new Ord[Int] {
    def compare(a1: Int, a2: Int): Order =
      if((a1 - a2) <  0)      LT
      else if((a1 - a2) == 0) EQ
      else                    GT
  }
}

object Main extends App {
  import Ord._

  def quickSort[A: Ord](list: List[A]): List[A] = list match {
    case Nil     => Nil
    case x :: xs => quickSort(xs.filter(_ <= x)) ++
                    List(x) ++
                    quickSort(xs.filter(_ >  x))
  }

  println(quickSort(List(3, 2, 1)).mkString(" "))
}