Refactoring

Author: skozlov

src/main/scala/com/github/skozlov/algorithms/sort/FunctionalSort.scala

@@ -7,7 +7,7 @@ import scala.reflect.ClassTag
 /** Sort which puts ordered elements into the output sequence and does not
   * modify the input sequence.
   */
-trait FunctionalSort {
+trait FunctionalSort[A] {
 
   /** Sorts the input sequence putting elements into the output sequence. Input
     * sequence will not be modified.
@@ -19,7 +19,7 @@ trait FunctionalSort {
     * @throws IllegalArgumentException
     *   if the input and output sequences have different sizes
     */
-  def sortFunctionally[A: Ordering](in: Slice[A], out: WritableSlice[A]): Unit
+  def sortFunctionally(in: Slice[A], out: WritableSlice[A])(implicit ordering: Ordering[A]): Unit
 
   /** Sorts the input sequence putting elements into the new array. Input
     * sequence will not be modified.
@@ -28,7 +28,7 @@ trait FunctionalSort {
     * @return
     *   array which contains sorted elements
     */
-  def sortFunctionally[A: Ordering: ClassTag](in: Slice[A]): Array[A] = {
+  def sortFunctionally(in: Slice[A])(implicit ordering: Ordering[A], classTag: ClassTag[A]): Array[A] = {
     val out = Array.ofDim[A](in.size)
     sortFunctionally(in, WritableSlice(out)())
     out

src/main/scala/com/github/skozlov/algorithms/sort/InPlaceSort.scala

@@ -2,6 +2,6 @@ package com.github.skozlov.algorithms.sort
 
 import com.github.skozlov.commons.collection.WritableSlice
 
-trait InPlaceSort {
-  def sortInPlace[A: Ordering](elements: WritableSlice[A]): Unit
+trait InPlaceSort[A] {
+  def sortInPlace(elements: WritableSlice[A])(implicit ordering: Ordering[A]): Unit
 }

src/main/scala/com/github/skozlov/algorithms/sort/InsertionSort.scala

@@ -14,8 +14,8 @@ import scala.math.Ordered.orderingToOrdered
   * @see
   *   [[https://en.wikipedia.org/wiki/Insertion_sort]]
   */
-object InsertionSort extends InPlaceSort with FunctionalSort with StableSort {
-  private def sort[A: Ordering](in: Slice[A], out: WritableSlice[A]): Unit = {
+class InsertionSort[A] extends InPlaceSort[A] with FunctionalSort[A] with StableSort {
+  private def sort(in: Slice[A], out: WritableSlice[A])(implicit ordering: Ordering[A]): Unit = {
     require(
       in.size == out.size,
       s"in and out have different sizes: ${in.size} and ${out.size}",
@@ -61,14 +61,14 @@ object InsertionSort extends InPlaceSort with FunctionalSort with StableSort {
     }
   }
 
-  override def sortInPlace[A: Ordering](elements: WritableSlice[A]): Unit = {
+  override def sortInPlace(elements: WritableSlice[A])(implicit ordering: Ordering[A]): Unit = {
     sort(in = elements, out = elements)
   }
 
-  override def sortFunctionally[A: Ordering](
+  override def sortFunctionally(
       in: Slice[A],
       out: WritableSlice[A],
-  ): Unit = {
+  )(implicit ordering: Ordering[A]): Unit = {
     sort(in, out)
   }
 }

src/main/scala/com/github/skozlov/algorithms/sort/MergeSort.scala

@@ -15,14 +15,16 @@ import scala.math.Ordered.orderingToOrdered
   * @see
   *   [[https://en.wikipedia.org/wiki/Merge_sort]]
   */
-object MergeSort {
+class MergeSort[A] {
+  import MergeSort._
+  
   // noinspection ScalaWeakerAccess
   @tailrec
-  def merge[A: Ordering](
+  final def merge(
       in1: Slice[A],
       in2: Slice[A],
       out: WritableSlice[A],
-  ): Unit = {
+  )(implicit ordering: Ordering[A]): Unit = {
     require(
       out.size == in1.size + in2.size,
       s"out size = ${out.size} is not sum of in1 size = ${in1.size} and in2 size = ${in2.size}",
@@ -36,17 +38,12 @@ object MergeSort {
     }
   }
 
-  class SmallChunkSort(val chunkSize: Int, val sort: FunctionalSort) {
-    require(chunkSize >= 0, "Negative chunk size: " + chunkSize)
-  }
-
-  def sortWithBuffers[A: Ordering](
+  def sortWithBuffers(
       input: Slice[A],
       primaryBuffer: WritableSlice[A],
       secondaryBuffer: WritableSlice[A],
-      smallChunkSort: SmallChunkSort =
-        SmallChunkSort(chunkSize = 5, sort = InsertionSort),
-  ): WritableSlice[A] = {
+      smallChunkSort: SmallChunkSort[A] = SmallChunkSort(chunkSize = 5, sort = InsertionSort[A]),
+  )(implicit ordering: Ordering[A]): WritableSlice[A] = {
     require(
       primaryBuffer.size == input.size,
       s"Size mismatch: input = ${input.size}, primary buffer = ${primaryBuffer.size}",
@@ -121,12 +118,12 @@ object MergeSort {
     }
   }
 
-  def sortWithBuffer[A: Ordering](
+  def sortWithBuffer(
       input: WritableSlice[A],
       buffer: WritableSlice[A],
-      smallChunkSort: SmallChunkSort =
-        SmallChunkSort(chunkSize = 5, sort = InsertionSort),
-  ): WritableSlice[A] = {
+      smallChunkSort: SmallChunkSort[A] =
+        SmallChunkSort(chunkSize = 5, sort = InsertionSort[A]),
+  )(implicit ordering: Ordering[A]): WritableSlice[A] = {
     sortWithBuffers(
       input = input,
       primaryBuffer = buffer,
@@ -135,3 +132,9 @@ object MergeSort {
     )
   }
 }
+
+object MergeSort {
+  class SmallChunkSort[A](val chunkSize: Int, val sort: FunctionalSort[A]) {
+    require(chunkSize >= 0, "Negative chunk size: " + chunkSize)
+  }
+}

src/test/scala/com/github/skozlov/algorithms/sort/SortTest.scala

@@ -40,7 +40,7 @@ class SortTest extends Test {
     }
   }
 
-  private def testInPlaceSort(sort: InPlaceSort): Unit = {
+  private def testInPlaceSort(sort: InPlaceSort[(Int, Int)]): Unit = {
     val arrays: Seq[Array[(Int, Int)]] = cases map { _.toArray }
     val results: Seq[Seq[(Int, Int)]] = for (array <- arrays) yield {
       sort.sortInPlace(WritableSlice(array)())
@@ -49,7 +49,7 @@ class SortTest extends Test {
     checkResults(results, sort.isInstanceOf[StableSort])
   }
 
-  private def testFunctionalSort(sort: FunctionalSort): Unit = {
+  private def testFunctionalSort(sort: FunctionalSort[(Int, Int)]): Unit = {
     val inputsAndOutputsAfterSort: Seq[(Array[(Int, Int)], Array[(Int, Int)])] =
       for {
         _case: Seq[(Int, Int)] <- cases
@@ -64,7 +64,7 @@ class SortTest extends Test {
   }
 
   test("insertion sort") {
-    testInPlaceSort(InsertionSort)
-    testFunctionalSort(InsertionSort)
+    testInPlaceSort(InsertionSort())
+    testFunctionalSort(InsertionSort())
   }
 }