sorts: make recursive_insertion_sort generic over Comparable items

Part of #15234

- switch rec_insertion_sort/insert_next to the Comparable/TypeVar-bound
  MutableSequence[T] pattern (in-place sorts bucket) per the convention
  discussed on #15234
- make rec_insertion_sort return the sorted collection and give n a
  default of len(collection), so it can be called with a single
  argument like the other sorts in the shared test battery
- add a string doctest
- register rec_insertion_sort in tests/test_sorts.py's shared SORTS
  battery and the non-comparable-items rejection test

Author: Rokesh2008

sorts/recursive_insertion_sort.py

@@ -4,39 +4,61 @@
 
 from __future__ import annotations
 
+from collections.abc import MutableSequence
+from typing import Any, Protocol, TypeVar
 
-def rec_insertion_sort(collection: list, n: int) -> None:
+
+class Comparable(Protocol):
+    def __lt__(self, other: Any, /) -> bool: ...
+
+
+T = TypeVar("T", bound=Comparable)
+
+
+def rec_insertion_sort[T: Comparable](
+    collection: MutableSequence[T], n: int | None = None
+) -> MutableSequence[T]:
     """
-    Given a collection of numbers and its length, sorts the collections
-    in ascending order
+    Given a collection of comparable elements, sorts the collection in place
+    in ascending order and returns it.
 
     :param collection: A mutable collection of comparable elements
-    :param n: The length of collections
+    :param n: The number of leading elements still to be placed. Defaults to
+        the full length of ``collection`` so the function can be called with
+        a single argument.
+    :return: the same collection ordered by ascending
 
     >>> col = [1, 2, 1]
-    >>> rec_insertion_sort(col, len(col))
+    >>> rec_insertion_sort(col)
+    [1, 1, 2]
     >>> col
     [1, 1, 2]
 
     >>> col = [2, 1, 0, -1, -2]
     >>> rec_insertion_sort(col, len(col))
-    >>> col
     [-2, -1, 0, 1, 2]
 
     >>> col = [1]
-    >>> rec_insertion_sort(col, len(col))
-    >>> col
+    >>> rec_insertion_sort(col)
     [1]
+
+    >>> col = ['d', 'a', 'b', 'e', 'c']
+    >>> rec_insertion_sort(col) == sorted(col)
+    True
     """
+    if n is None:
+        n = len(collection)
+
     # Checks if the entire collection has been sorted
     if len(collection) <= 1 or n <= 1:
-        return
+        return collection
 
     insert_next(collection, n - 1)
     rec_insertion_sort(collection, n - 1)
+    return collection
 
 
-def insert_next(collection: list, index: int) -> None:
+def insert_next[T: Comparable](collection: MutableSequence[T], index: int) -> None:
     """
     Inserts the '(index-1)th' element into place
 
@@ -71,5 +93,5 @@ def insert_next(collection: list, index: int) -> None:
 if __name__ == "__main__":
     numbers = input("Enter integers separated by spaces: ")
     number_list: list[int] = [int(num) for num in numbers.split()]
-    rec_insertion_sort(number_list, len(number_list))
+    rec_insertion_sort(number_list)
     print(number_list)

tests/test_sorts.py

@@ -35,6 +35,7 @@
 from sorts.odd_even_sort import odd_even_sort
 from sorts.patience_sort import patience_sort
 from sorts.quick_sort import quick_sort
+from sorts.recursive_insertion_sort import rec_insertion_sort
 from sorts.selection_sort import selection_sort
 from sorts.shell_sort import shell_sort
 from sorts.stooge_sort import stooge_sort
@@ -66,6 +67,7 @@ def test_heap_sort() -> None:
     odd_even_sort,
     patience_sort,
     quick_sort,
+    rec_insertion_sort,
     selection_sort,
     shell_sort,
     stooge_sort,
@@ -121,6 +123,7 @@ def test_sort_matches_builtin(sort, case) -> None:
         gnome_sort,
         insertion_sort,
         merge_sort,
+        rec_insertion_sort,
         selection_sort,
     ],
     ids=lambda f: f.__name__,