fork download
  1. abstract class Ordering
  2. case class Less() extends Ordering
  3. case class Equal() extends Ordering
  4. case class Greater() extends Ordering
  5.  
  6. abstract class Order[T] {
  7. def compare(x: T, y: T): Ordering
  8. }
  9.  
  10. object UsualOrder {
  11. implicit object Ord extends Order[Int] {
  12. def compare(x: Int, y: Int): Ordering =
  13. if (x < y) Less() else
  14. if (x == y) Equal() else
  15. Greater()
  16. }
  17. }
  18.  
  19. object ReverseOrder {
  20. implicit object Ord extends Order[Int] {
  21. def compare(x: Int, y: Int): Ordering =
  22. if (x > y) Less() else
  23. if (x == y) Equal() else
  24. Greater()
  25. }
  26. }
  27.  
  28. object OrderedList {
  29. def empty = List()
  30.  
  31. def insert[T](x: T, xs: List[T])(implicit o: Order[T]): List[T] =
  32. xs match {
  33. case Nil => List(x)
  34. case y :: ys =>
  35. o.compare(x, y) match {
  36. case Less() => x :: xs
  37. case Equal() => xs
  38. case Greater() => y :: insert(x, ys)
  39. }
  40. }
  41.  
  42. def merge[T](xs: List[T], ys: List[T])(implicit o: Order[T]): List[T] =
  43. (xs, ys) match {
  44. case (_, Nil) => xs
  45. case (Nil, _) => ys
  46. case (x :: xs1, y :: ys1) =>
  47. o.compare(x, y) match {
  48. case Less() => x :: merge(xs1, ys)
  49. case Equal() => x :: merge(xs1, ys1)
  50. case Greater() => y :: merge(xs, ys1)
  51. }
  52. }
  53. }
  54.  
  55. object Main extends App {
  56. import OrderedList._
  57.  
  58. val xs = {
  59. import UsualOrder._
  60. insert(3, insert(1, insert(2, empty)))
  61. }
  62.  
  63. import ReverseOrder._
  64. val ys = insert(10, insert(8, insert(12, empty)))
  65.  
  66. println(xs)
  67. println(ys)
  68. println(merge(xs, ys))
  69. }
Success #stdin #stdout 0.39s 382016KB
stdin
Standard input is empty
stdout
List(1, 2, 3)
List(12, 10, 8)
List(12, 10, 8, 1, 2, 3)