September Morn Update

Task/Sorting-algorithms-Quicksort/Scala/sorting-algorithms-quicksort-1.scala

@@ -1,11 +1,6 @@
-  def sort(xs: List[Int]): List[Int] = {
-    xs match {
-      case Nil => Nil
-      case x :: xx => {
-        // Arbitrarily partition list in two
-        val (lo, hi) = xx.partition(_ < x)
-        // Sort each half
-        sort(lo) ++ (x :: sort(hi))
-      }
-    }
+  def sort(xs: List[Int]): List[Int] = xs match {
+    case Nil => Nil
+    case head :: tail =>
+      val (less, notLess) = tail.partition(_ < head) // Arbitrarily partition list in two
+      sort(less) ++ (head :: sort(notLess))          // Sort each half
   }

Task/Sorting-algorithms-Quicksort/Scala/sorting-algorithms-quicksort-2.scala

@@ -1,9 +1,6 @@
-  def sort[T](xs: List[T], lessThan: (T, T) => Boolean): List[T] = {
-    xs match {
-      case Nil => Nil
-      case x :: xx => {
-        val (lo, hi) = xx.partition(lessThan(_, x))
-        sort(lo, lessThan) ++ (x :: sort(hi, lessThan))
-      }
-    }
+  def sort[T](xs: List[T], lessThan: (T, T) => Boolean): List[T] = xs match {
+    case Nil => Nil
+    case x :: xx =>
+      val (lo, hi) = xx.partition(lessThan(_, x))
+      sort(lo, lessThan) ++ (x :: sort(hi, lessThan))
   }

Task/Sorting-algorithms-Quicksort/Scala/sorting-algorithms-quicksort-3.scala

@@ -1,9 +1,6 @@
-  def sort[T](xs: List[T])(implicit ord: Ordering[T]): List[T] = {
-    xs match {
-      case Nil => Nil
-      case x :: xx => {
-        val (lo, hi) = xx.partition(ord.lt(_, x))
-        sort[T](lo) ++ (x :: sort[T](hi))
-      }
-    }
+  def sort[T](xs: List[T])(implicit ord: Ordering[T]): List[T] = xs match {
+    case Nil => Nil
+    case x :: xx =>
+      val (lo, hi) = xx.partition(ord.lt(_, x))
+      sort[T](lo) ++ (x :: sort[T](hi))
   }

Task/Sorting-algorithms-Quicksort/Scala/sorting-algorithms-quicksort-4.scala

@@ -1,9 +1,6 @@
-  def sort[T <: Ordered[T]](xs: List[T]): List[T] = {
-    xs match {
-      case Nil => Nil
-      case x :: xx => {
-        val (lo, hi) = xx.partition(_ < x)
-        sort(lo) ++ (x :: sort(hi))
-      }
-    }
+  def sort[T <: Ordered[T]](xs: List[T]): List[T] = xs match {
+    case Nil => Nil
+    case x :: xx =>
+      val (lo, hi) = xx.partition(_ < x)
+      sort(lo) ++ (x :: sort(hi))
   }