refactor: rename function in sort (#536)

bubble sort is actually insertion sort

array/fixedarray_sort.mbt

@@ -48,7 +48,7 @@ fn timsort[T : Compare](arr : FixedArraySlice[T]) -> Unit {
   // Short arrays get sorted in-place via insertion sort to avoid allocations.
   let len = arr.length()
   if len <= max_insertion {
-    insertion_sort(arr)
+    FixedArraySlice::insertion_sort(arr)
   }
   let mut end = 0
   let mut start = 0
@@ -79,7 +79,9 @@ fn timsort[T : Compare](arr : FixedArraySlice[T]) -> Unit {
   }
 }
 
-fn insertion_sort[T : Compare](arr : FixedArraySlice[T]) -> Unit {
+fn FixedArraySlice::insertion_sort[T : Compare](
+  arr : FixedArraySlice[T]
+) -> Unit {
   for i = 1, len = arr.length(); i < len; i = i + 1 {
     for j = i; j > 0 && arr[j] < arr[j - 1]; j = j - 1 {
       arr.swap(j, j - 1)
@@ -158,7 +160,7 @@ fn provide_sorted_batch[T : Compare](
     // the sorted region to the left, so we push up MIN_INSERTION_RUN - 1 to the right. Which is
     // more efficient that trying to push those already sorted elements to the left.
     let sort_end = minimum(len, start + min_insertion_run)
-    insertion_sort(arr.slice(start, sort_end))
+    FixedArraySlice::insertion_sort(arr.slice(start, sort_end))
     sort_end
   } else {
     end

array/sort.mbt

@@ -37,12 +37,12 @@ fn quick_sort[T : Compare](arr : ArrayView[T], pred : T?, limit : Int) -> Unit {
   let mut pred = pred
   let mut was_partitioned = true
   let mut balanced = true
-  let bubble_sort_len = 16
+  let insertion_sort_len = 16
   while true {
     let len = arr.length()
-    if len <= bubble_sort_len {
+    if len <= insertion_sort_len {
       if len >= 2 {
-        bubble_sort(arr)
+        ArrayView::insertion_sort(arr)
       }
       return
     }
@@ -129,12 +129,8 @@ fn try_bubble_sort[T : Compare](
   true
 }
 
-/// Try to sort the array with bubble sort.
-/// 
-/// It will only tolerate at most 8 unsorted elements. The time complexity is O(n).
-/// 
-/// Returns whether the array is sorted.
-fn bubble_sort[T : Compare](arr : ArrayView[T]) -> Unit {
+/// Used when the array is small enough (<=16) to avoid recursion overhead.
+fn ArrayView::insertion_sort[T : Compare](arr : ArrayView[T]) -> Unit {
   for i = 1; i < arr.length(); i = i + 1 {
     for j = i; j > 0 && arr[j - 1] > arr[j]; j = j - 1 {
       arr.swap(j, j - 1)

array/sort_test.mbt

@@ -51,8 +51,12 @@ test "heap_sort" {
   test_sort(fn(arr) { heap_sort(arr.op_as_view(start=0, end=arr.length())) })?
 }
 
-test "bubble_sort" {
-  test_sort(fn(arr) { bubble_sort(arr.op_as_view(start=0, end=arr.length())) })?
+test "insertion_sort" {
+  test_sort(
+    fn(arr) {
+      ArrayView::insertion_sort(arr.op_as_view(start=0, end=arr.length()))
+    },
+  )?
 }
 
 test "sort" {