array-sort 0.1.1 → 1.0.0

data/lib/array_sort/algorithms/tim_sort.rb

@@ -0,0 +1,335 @@
+# frozen_string_literal: true
+
+module ArraySort
+  # Timsort: finds the runs that are already in order in the data, extends short runs with binary insertion sort, and
+  # merges runs in a carefully balanced order. This is the algorithm behind Python's sorted() and Java's
+  # Arrays.sort for objects.
+  #
+  # Real-world data is often partly sorted, and Timsort takes advantage of it: sorted or reverse-sorted input takes a
+  # single O(n) pass. Merges "gallop" (search exponentially) when one run keeps winning, so merging runs that barely
+  # overlap is cheap too.
+  #
+  # This follows the structure of the reference implementation, including the corrected merge invariants
+  # (de Gouw et al., 2015), but always merges with a temporary copy of the left run rather than choosing the smaller
+  # run, which keeps it simpler at the cost of some extra memory.
+  #
+  # @api private
+  module TimSort
+    # Arrays shorter than this are sorted with binary insertion sort alone.
+    MIN_MERGE = 32
+    # How many consecutive wins by one run switch a merge into galloping mode.
+    MIN_GALLOP = 7
+
+    module_function
+
+    def call(array, compare)
+      Sorter.new(array, compare).sort if array.length > 1
+      array
+    end
+
+    # Holds the state of one sort: the array, the stack of pending runs and the adaptive galloping threshold.
+    class Sorter
+      def initialize(array, compare)
+        @array = array
+        @compare = compare
+        @runs = [] # [start, length] pairs, waiting to be merged
+        @min_gallop = MIN_GALLOP
+      end
+
+      def sort
+        length = @array.length
+        min_run = min_run_length(length)
+        low = 0
+        while low < length
+          run_length = count_run_and_make_ascending(low, length)
+          if run_length < min_run
+            forced = [length - low, min_run].min
+            binary_insertion_sort(low, low + forced, low + run_length)
+            run_length = forced
+          end
+          @runs << [low, run_length]
+          merge_collapse
+          low += run_length
+        end
+        merge_force_collapse
+      end
+
+      private
+
+      def less?(a, b) = @compare.call(a, b).negative?
+
+      # A run length in (MIN_MERGE / 2)..MIN_MERGE such that length / min_run is a power of two or just below one,
+      # which keeps the final merges balanced.
+      def min_run_length(length)
+        remainder = 0
+        while length >= MIN_MERGE
+          remainder |= length & 1
+          length >>= 1
+        end
+        length + remainder
+      end
+
+      # Returns the length of the run starting at +low+, reversing it first if it is strictly descending. (Only
+      # strictly descending runs are reversed, so equal elements never swap places.)
+      def count_run_and_make_ascending(low, high)
+        run_high = low + 1
+        return 1 if run_high == high
+
+        if less?(@array[run_high], @array[low])
+          run_high += 1 while run_high < high && less?(@array[run_high], @array[run_high - 1])
+          reverse_range(low, run_high - 1)
+        else
+          run_high += 1 while run_high < high && !less?(@array[run_high], @array[run_high - 1])
+        end
+        run_high - low
+      end
+
+      def reverse_range(low, high)
+        while low < high
+          @array[low], @array[high] = @array[high], @array[low]
+          low += 1
+          high -= 1
+        end
+      end
+
+      # Sorts +@array[low...high]+, given that +@array[low...start]+ is already sorted.
+      def binary_insertion_sort(low, high, start)
+        (start...high).each do |i|
+          element = @array[i]
+          position = BinaryInsertionSort.upper_bound(@array, @compare, element, low, i)
+          next if position == i
+
+          i.downto(position + 1) { |j| @array[j] = @array[j - 1] }
+          @array[position] = element
+        end
+      end
+
+      # Merges runs at the top of the stack until these hold for the top three run lengths z, y, x:
+      # z > y + x and y > x. That keeps the stack O(log n) deep and the merges balanced.
+      def merge_collapse
+        while @runs.size > 1
+          n = @runs.size - 2
+          if (n.positive? && run_length(n - 1) <= run_length(n) + run_length(n + 1)) ||
+             (n > 1 && run_length(n - 2) <= run_length(n - 1) + run_length(n))
+            n -= 1 if run_length(n - 1) < run_length(n + 1)
+          elsif run_length(n) > run_length(n + 1)
+            break
+          end
+          merge_at(n)
+        end
+      end
+
+      def merge_force_collapse
+        while @runs.size > 1
+          n = @runs.size - 2
+          n -= 1 if n.positive? && run_length(n - 1) < run_length(n + 1)
+          merge_at(n)
+        end
+      end
+
+      def run_length(index) = @runs[index][1]
+
+      # Merges the runs at stack positions +index+ and +index + 1+.
+      def merge_at(index)
+        base1, length1 = @runs[index]
+        base2, length2 = @runs[index + 1]
+        @runs[index] = [base1, length1 + length2]
+        @runs.delete_at(index + 1)
+
+        # Elements of run 1 that are no larger than run 2's first element are already in place.
+        skipped = gallop_right(@array[base2], @array, base1, length1, 0)
+        base1 += skipped
+        length1 -= skipped
+        return if length1.zero?
+
+        # Likewise, elements of run 2 that are no smaller than run 1's last element are already in place.
+        length2 = gallop_left(@array[base1 + length1 - 1], @array, base2, length2, length2 - 1)
+        return if length2.zero?
+
+        merge_low(base1, length1, base2, length2)
+      end
+
+      # Merges two adjacent runs by copying the first into a temporary array and merging back from the front.
+      def merge_low(base1, length1, base2, length2)
+        temp = @array[base1, length1]
+        cursor1 = 0 # into temp
+        cursor2 = base2 # into @array
+        dest = base1
+        min_gallop = @min_gallop
+
+        catch(:done) do
+          @array[dest] = @array[cursor2]
+          dest += 1
+          cursor2 += 1
+          length2 -= 1
+          throw :done if length2.zero? || length1 == 1
+
+          loop do
+            count1 = 0 # consecutive wins by run 1
+            count2 = 0 # consecutive wins by run 2
+
+            # One element at a time, until one run wins MIN_GALLOP times in a row.
+            loop do
+              if less?(@array[cursor2], temp[cursor1])
+                @array[dest] = @array[cursor2]
+                dest += 1
+                cursor2 += 1
+                count2 += 1
+                count1 = 0
+                length2 -= 1
+                throw :done if length2.zero?
+              else
+                @array[dest] = temp[cursor1]
+                dest += 1
+                cursor1 += 1
+                count1 += 1
+                count2 = 0
+                length1 -= 1
+                throw :done if length1 == 1
+              end
+              break if count1 >= min_gallop || count2 >= min_gallop
+            end
+
+            # Galloping: find how far each run's winning streak goes with an exponential search, and copy it in bulk.
+            loop do
+              count1 = gallop_right(@array[cursor2], temp, cursor1, length1, 0)
+              count1.times do
+                @array[dest] = temp[cursor1]
+                dest += 1
+                cursor1 += 1
+              end
+              length1 -= count1
+              throw :done if length1 <= 1
+
+              @array[dest] = @array[cursor2]
+              dest += 1
+              cursor2 += 1
+              length2 -= 1
+              throw :done if length2.zero?
+
+              count2 = gallop_left(temp[cursor1], @array, cursor2, length2, 0)
+              count2.times do
+                @array[dest] = @array[cursor2]
+                dest += 1
+                cursor2 += 1
+              end
+              length2 -= count2
+              throw :done if length2.zero?
+
+              @array[dest] = temp[cursor1]
+              dest += 1
+              cursor1 += 1
+              length1 -= 1
+              throw :done if length1 == 1
+
+              min_gallop -= 1
+              break if count1 < MIN_GALLOP && count2 < MIN_GALLOP
+            end
+            # Leaving galloping mode makes it a little harder to re-enter.
+            min_gallop = [min_gallop, 0].max + 2
+          end
+        end
+        @min_gallop = [min_gallop, 1].max
+
+        if length1 == 1
+          # Run 1's last element is larger than everything left in run 2, which slides down to make room for it.
+          length2.times do
+            @array[dest] = @array[cursor2]
+            dest += 1
+            cursor2 += 1
+          end
+          @array[dest] = temp[cursor1]
+        else
+          # Run 2 is exhausted, so the rest of run 1 fills the gap. (Nothing is left at all only if the comparison is
+          # inconsistent, in which case every element is still in the array.)
+          length1.times do
+            @array[dest] = temp[cursor1]
+            dest += 1
+            cursor1 += 1
+          end
+        end
+      end
+
+      # Returns the leftmost position in +array[base, length]+ where +key+ could be inserted keeping it sorted, i.e. the
+      # number of elements less than +key+. The search starts at +base + hint+ and gallops outwards from there.
+      def gallop_left(key, array, base, length, hint)
+        last_offset = 0
+        offset = 1
+        if less?(array[base + hint], key)
+          # Gallop right until array[base + hint + last_offset] < key <= array[base + hint + offset].
+          max_offset = length - hint
+          while offset < max_offset && less?(array[base + hint + offset], key)
+            last_offset = offset
+            offset = (offset * 2) + 1
+          end
+          offset = [offset, max_offset].min
+          last_offset += hint
+          offset += hint
+        else
+          # Gallop left until array[base + hint - offset] < key <= array[base + hint - last_offset].
+          max_offset = hint + 1
+          while offset < max_offset && !less?(array[base + hint - offset], key)
+            last_offset = offset
+            offset = (offset * 2) + 1
+          end
+          offset = [offset, max_offset].min
+          last_offset, offset = hint - offset, hint - last_offset
+        end
+
+        # Binary search: array[base + last_offset] < key <= array[base + offset].
+        last_offset += 1
+        while last_offset < offset
+          mid = last_offset + ((offset - last_offset) / 2)
+          if less?(array[base + mid], key)
+            last_offset = mid + 1
+          else
+            offset = mid
+          end
+        end
+        offset
+      end
+
+      # Like #gallop_left, but returns the rightmost position, i.e. the number of elements less than or equal to
+      # +key+. Placing a run-2 element after equal run-1 elements is what keeps merges stable.
+      def gallop_right(key, array, base, length, hint)
+        last_offset = 0
+        offset = 1
+        if less?(key, array[base + hint])
+          # Gallop left until array[base + hint - offset] <= key < array[base + hint - last_offset].
+          max_offset = hint + 1
+          while offset < max_offset && less?(key, array[base + hint - offset])
+            last_offset = offset
+            offset = (offset * 2) + 1
+          end
+          offset = [offset, max_offset].min
+          last_offset, offset = hint - offset, hint - last_offset
+        else
+          # Gallop right until array[base + hint + last_offset] <= key < array[base + hint + offset].
+          max_offset = length - hint
+          while offset < max_offset && !less?(key, array[base + hint + offset])
+            last_offset = offset
+            offset = (offset * 2) + 1
+          end
+          offset = [offset, max_offset].min
+          last_offset += hint
+          offset += hint
+        end
+
+        # Binary search: array[base + last_offset] <= key < array[base + offset].
+        last_offset += 1
+        while last_offset < offset
+          mid = last_offset + ((offset - last_offset) / 2)
+          if less?(key, array[base + mid])
+            offset = mid
+          else
+            last_offset = mid + 1
+          end
+        end
+        offset
+      end
+    end
+  end
+
+  register :tim, TimSort, title: 'Timsort', stable: true,
+                          best: 'n', average: 'n log n', worst: 'n log n', space: 'n'
+end

data/lib/array_sort/algorithms/tournament_sort.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ArraySort
+  # Tournament sort: runs a knockout tournament between the elements, where each match is won by the smaller one. The
+  # champion is the smallest element; it is removed and only the matches it played are replayed to find the next.
+  #
+  # Each replay takes log n comparisons. Ties are won by the element that came first, which makes the sort stable.
+  #
+  # @api private
+  module TournamentSort
+    module_function
+
+    def call(array, compare)
+      count = array.length
+      return array if count < 2
+
+      elements = Array.new(array)
+      leaves = 1
+      leaves <<= 1 while leaves < count
+
+      # A complete binary tree stored in an array: node i has children 2i and 2i + 1, leaves are leaves...2 * leaves,
+      # and every node holds the index of the element that won there (nil once that element has been taken).
+      tree = Array.new(2 * leaves)
+      count.times { |i| tree[leaves + i] = i }
+      (leaves - 1).downto(1) { |node| tree[node] = winner(elements, compare, tree[2 * node], tree[(2 * node) + 1]) }
+
+      count.times do |position|
+        champion = tree[1]
+        array[position] = elements[champion]
+
+        node = leaves + champion
+        tree[node] = nil
+        while node > 1
+          node /= 2
+          tree[node] = winner(elements, compare, tree[2 * node], tree[(2 * node) + 1])
+        end
+      end
+      array
+    end
+
+    # Returns whichever of the element indices +left+ and +right+ wins (is smaller). +left+ always comes from earlier
+    # in the array, so it wins ties.
+    def winner(elements, compare, left, right)
+      return right if left.nil?
+      return left if right.nil?
+
+      compare.call(elements[right], elements[left]).negative? ? right : left
+    end
+  end
+
+  register :tournament, TournamentSort, title: 'Tournament sort', stable: true,
+                                        best: 'n log n', average: 'n log n', worst: 'n log n', space: 'n'
+end

data/lib/array_sort/algorithms/tree_sort.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module ArraySort
+  # Tree sort: inserts every element into a binary search tree, then reads them back in order.
+  #
+  # The tree is an AVL tree, which rebalances itself on every insertion so that sorted input doesn't degrade it into a
+  # linked list (the classic O(n²) trap of tree sort). Equal elements are inserted to the right of each other, so an
+  # in-order walk returns them in their original order and the sort is stable.
+  #
+  # @api private
+  module TreeSort
+    Node = Struct.new(:value, :left, :right, :height)
+    private_constant :Node
+
+    module_function
+
+    def call(array, compare)
+      root = nil
+      array.each { |element| root = insert(root, element, compare) }
+
+      index = 0
+      each_in_order(root) do |value|
+        array[index] = value
+        index += 1
+      end
+      array
+    end
+
+    def insert(node, value, compare)
+      return Node.new(value, nil, nil, 1) if node.nil?
+
+      if compare.call(value, node.value).negative?
+        node.left = insert(node.left, value, compare)
+      else
+        node.right = insert(node.right, value, compare)
+      end
+      rebalance(node)
+    end
+
+    # Walks the tree in order without recursion.
+    def each_in_order(node)
+      stack = []
+      while node || !stack.empty?
+        while node
+          stack.push(node)
+          node = node.left
+        end
+        node = stack.pop
+        yield node.value
+        node = node.right
+      end
+    end
+
+    def height(node) = node ? node.height : 0
+
+    def balance(node) = height(node.left) - height(node.right)
+
+    def update_height(node)
+      node.height = [height(node.left), height(node.right)].max + 1
+      node
+    end
+
+    # Restores the AVL property (subtree heights differ by at most one) at +node+ and returns the subtree's new root.
+    # Rotations never change the in-order sequence, so they preserve both sorting and stability.
+    def rebalance(node)
+      update_height(node)
+      case balance(node)
+      when 2
+        node.left = rotate_left(node.left) if balance(node.left).negative?
+        rotate_right(node)
+      when -2
+        node.right = rotate_right(node.right) if balance(node.right).positive?
+        rotate_left(node)
+      else
+        node
+      end
+    end
+
+    def rotate_right(node)
+      pivot = node.left
+      node.left = pivot.right
+      pivot.right = update_height(node)
+      update_height(pivot)
+    end
+
+    def rotate_left(node)
+      pivot = node.right
+      node.right = pivot.left
+      pivot.left = update_height(node)
+      update_height(pivot)
+    end
+  end
+
+  register :tree, TreeSort, title: 'Tree sort (AVL)', stable: true,
+                            best: 'n log n', average: 'n log n', worst: 'n log n', space: 'n'
+end

data/lib/array_sort/array_methods.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module ArraySort
+  # The methods ArraySort adds to arrays. +require 'array/sort'+ includes this module into +Array+; +using
+  # ArraySort::Refinements+ adds the same methods to +Array+ in one file only.
+  #
+  # For every algorithm name +x+ in {ArraySort.algorithms} there are four methods with the same contract as their
+  # native counterparts:
+  #
+  # [+x_sort(&block)+]     Returns a new sorted array. Comparison sorts accept an optional comparison block.
+  # [+x_sort!(&block)+]    Sorts +self+ in place and returns it.
+  # [+x_sort_by(&block)+]  Returns a new array sorted by the keys the block returns, calling the block once per
+  #                        element. Returns an Enumerator without a block.
+  # [+x_sort_by!(&block)+] Sorts +self+ in place by the keys the block returns. Returns an Enumerator without a block.
+  #
+  # Distribution sorts (counting, radix and bucket sort) don't compare elements, so +x_sort+ and +x_sort!+ raise
+  # ArgumentError when given a block, and every element (or key, for the +_by+ methods) must be an Integer (or for
+  # bucket sort, any finite real number).
+  #
+  # See {ArraySort.algorithm} for each algorithm's stability and complexity.
+  module ArrayMethods
+    # Swap two elements in the array, and returns +self+.
+    #
+    # Negative indices count from the end of the array, as with +Array#[]+.
+    #
+    # @param index1 [Integer] The index of the first element.
+    # @param index2 [Integer] The index of the second element.
+    # @return [Array] +self+
+    # @raise [ArgumentError] If either of the two parameters is not an Integer.
+    # @raise [IndexError] If either index is outside the bounds of the array.
+    def swap(index1, index2)
+      raise ArgumentError, 'Index must be an integer.' unless index1.is_a?(Integer) && index2.is_a?(Integer)
+
+      fetch(index1)
+      fetch(index2)
+      self[index1], self[index2] = self[index2], self[index1] if index1 != index2
+      self
+    end
+
+    # The methods are compiled from source rather than created with define_method so that Refinements can import
+    # them (Refinement#import_methods only accepts methods written in Ruby source). For +name = :merge+ this defines
+    # merge_sort, merge_sort!, merge_sort_by and merge_sort_by!.
+    ArraySort.algorithms.each do |name|
+      module_eval <<~RUBY, __FILE__, __LINE__ + 1 # rubocop:disable Style/DocumentDynamicEvalDefinition
+        def #{name}_sort(&)
+          ArraySort::Core.sort(self, :#{name}, &)
+        end
+
+        def #{name}_sort!(&)
+          ArraySort::Core.sort!(self, :#{name}, &)
+        end
+
+        def #{name}_sort_by(&)
+          return ArraySort::Core.sort_by_enumerator(self, :#{name}, bang: false) unless block_given?
+
+          ArraySort::Core.sort_by(self, :#{name}, &)
+        end
+
+        def #{name}_sort_by!(&)
+          return ArraySort::Core.sort_by_enumerator(self, :#{name}, bang: true) unless block_given?
+
+          ArraySort::Core.sort_by!(self, :#{name}, &)
+        end
+      RUBY
+    end
+  end
+end

data/lib/array_sort/core.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module ArraySort
+  # Shared plumbing behind every public sort method.
+  #
+  # Algorithms come in two kinds (see {Algorithm#kind}):
+  #
+  # * Comparison algorithms respond to +call(buffer, compare)+ and sort +buffer+ in place, where +compare+ is a lambda
+  #   returning a negative, zero or positive Integer.
+  # * Distribution algorithms respond to +call(buffer, key)+ and sort +buffer+ in place by the numeric key that the
+  #   lambda +key+ returns for each element.
+  #
+  # Algorithms only ever change +buffer+ through single-element assignment (+buffer[i] = value+), which is what lets
+  # {ArraySort.trace} record every write. Everything else (copying, frozen checks, key caching for the +_by+ variants,
+  # enumerators) lives here so the algorithms stay focused on the algorithm.
+  #
+  # @api private
+  module Core
+    module_function
+
+    IDENTITY = ->(element) { element }
+    FIRST = ->(pair) { pair[0] }
+    private_constant :IDENTITY, :FIRST
+
+    # Returns a new, sorted copy of +array+.
+    def sort(array, name, &block)
+      algorithm = ArraySort.algorithm(name)
+      buffer = Array.new(array)
+      if algorithm.comparison?
+        algorithm.implementation.call(buffer, comparator(block))
+      else
+        if block
+          raise ArgumentError,
+                "#{name}_sort sorts by numeric key and does not take a comparison block; use #{name}_sort_by instead"
+        end
+
+        algorithm.implementation.call(buffer, IDENTITY)
+      end
+      buffer
+    end
+
+    # Sorts +array+ in place and returns it.
+    #
+    # The work happens on a private copy that replaces the contents of +array+ only once sorting has finished, so if
+    # the comparison raises, +array+ is left exactly as it was (matching +Array#sort!+).
+    def sort!(array, name, &)
+      ensure_mutable!(array)
+      array.replace(sort(array, name, &))
+    end
+
+    # Returns a new copy of +array+ sorted by the keys the block produces.
+    #
+    # Like +Array#sort_by+, the block is called exactly once per element.
+    def sort_by(array, name, &block)
+      algorithm = ArraySort.algorithm(name)
+      keyed = array.map { |element| [block.call(element), element] }
+      by_key = algorithm.comparison? ? ->(a, b) { normalize(a[0] <=> b[0], a[0], b[0]) } : FIRST
+      algorithm.implementation.call(keyed, by_key)
+      keyed.map!(&:last)
+    end
+
+    # Sorts +array+ in place by the keys the block produces and returns it.
+    def sort_by!(array, name, &)
+      ensure_mutable!(array)
+      array.replace(sort_by(array, name, &))
+    end
+
+    # Returns the Enumerator that +_sort_by+ and +_sort_by!+ return when called without a block.
+    #
+    # This is built by hand rather than with +to_enum+ so that it also works under {ArraySort::Refinements}: an
+    # Enumerator made by +to_enum+ calls the method from outside the refined scope, where it doesn't exist.
+    def sort_by_enumerator(array, name, bang:)
+      method = bang ? :sort_by! : :sort_by
+      Enumerator.new(-> { array.size }) do |yielder|
+        public_send(method, array, name) { |element| yielder.yield(element) }
+      end
+    end
+
+    # Wraps a comparison (the user's block, or +<=>+) so that it always returns an Integer, raising the same
+    # +ArgumentError+ as +Array#sort+ when two elements cannot be compared.
+    def comparator(block)
+      if block
+        ->(a, b) { normalize(block.call(a, b), a, b) }
+      else
+        ->(a, b) { normalize(a <=> b, a, b) }
+      end
+    end
+
+    def normalize(result, element1, element2)
+      return result if result.is_a?(Integer)
+
+      sign = result <=> 0 unless result.nil?
+      raise ArgumentError, "comparison of #{element1.class} with #{element2.class} failed" if sign.nil?
+
+      sign
+    end
+
+    # Returns the keys of +array+ under +key+, checking that each one is an Integer.
+    def integer_keys(array, key, algorithm_title)
+      array.map do |element|
+        value = key.call(element)
+        raise ArgumentError, "#{algorithm_title} needs Integer keys, got #{value.class}" unless value.is_a?(Integer)
+
+        value
+      end
+    end
+
+    # Returns the keys of +array+ under +key+, checking that each one is a finite real number.
+    def real_keys(array, key, algorithm_title)
+      array.map do |element|
+        value = key.call(element)
+        unless value.is_a?(Numeric) && value.real? && value.finite?
+          raise ArgumentError, "#{algorithm_title} needs finite real number keys, got #{value.inspect}"
+        end
+
+        value
+      end
+    end
+
+    def ensure_mutable!(array)
+      raise FrozenError.new("can't modify frozen #{array.class}: #{array.inspect}", receiver: array) if array.frozen?
+    end
+  end
+end

data/lib/array_sort/functions.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ArraySort
+  # For every algorithm name +x+ in {ArraySort.algorithms}, ArraySort responds to +x_sort(array, &block)+,
+  # +x_sort!(array, &block)+, +x_sort_by(array, &block)+ and +x_sort_by!(array, &block)+. They behave exactly like
+  # the Array methods of the same name (see {ArrayMethods}) but take the array as an argument, so they work without
+  # patching Array.
+  #
+  # @example
+  #   require 'array_sort'
+  #   ArraySort.merge_sort([3, 1, 2])            # => [1, 2, 3]
+  #   ArraySort.quick_sort_by(%w[ccc a bb], &:size) # => ["a", "bb", "ccc"]
+  ArraySort.algorithms.each do |name|
+    define_singleton_method(:"#{name}_sort") { |array, &block| Core.sort(array, name, &block) }
+    define_singleton_method(:"#{name}_sort!") { |array, &block| Core.sort!(array, name, &block) }
+    define_singleton_method(:"#{name}_sort_by") do |array, &block|
+      block ? Core.sort_by(array, name, &block) : Core.sort_by_enumerator(array, name, bang: false)
+    end
+    define_singleton_method(:"#{name}_sort_by!") do |array, &block|
+      block ? Core.sort_by!(array, name, &block) : Core.sort_by_enumerator(array, name, bang: true)
+    end
+  end
+end