8684 add shortcut sort procs (#9174)

* Stdlib: Algorithm: Add shortcut versions of sort, sorted, and isSorted procs.
* Add tests for sort, sorted, and isSorted procs from algorithm module.
* Merge sort tests into tsortcall.nim, remove tsort.nim.
* Stdlib: Algorithm: Add shortcut versions of sort, sorted, and isSorted procs.
* Add tests for sort, sorted, and isSorted procs from algorithm module.
* Merge sort tests into tsortcall.nim, remove tsort.nim.

lib/pure/algorithm.nim

@@ -297,15 +297,10 @@ func sort*[T](a: var openArray[T],
       dec(m, s*2)
     s = s*2
 
-func sort*[T](a: var openArray[T], order = SortOrder.Ascending) =
-  ## sorts an openarray in-place with a default lexicographical ordering.
-  runnableExamples:
-    var s = @[1,3,2,5,4]
-    s.sort
-    doAssert s == @[1,2,3,4,5]
-  sort(a, system.cmp, order)
+proc sort*[T](a: var openArray[T], order = SortOrder.Ascending) = sort[T](a, system.cmp[T], order)
+  ## Shortcut version of ``sort`` that uses ``system.cmp[T]`` as the comparison function.
 
-func sorted*[T](a: openArray[T], cmp: proc(x, y: T): int {.closure.},
+proc sorted*[T](a: openArray[T], cmp: proc(x, y: T): int {.closure.},
                 order = SortOrder.Ascending): seq[T] =
   ## returns ``a`` sorted by ``cmp`` in the specified ``order``.
   runnableExamples:
@@ -320,14 +315,9 @@ func sorted*[T](a: openArray[T], cmp: proc(x, y: T): int {.closure.},
     result[i] = a[i]
   sort(result, cmp, order)
 
-func sorted*[T](a: openArray[T], order = SortOrder.Ascending): seq[T] =
-  ## returns ``a`` sorted with default lexicographical ordering.
-  runnableExamples:
-    let orig = @[2,3,1,2]
-    let copy = orig.sorted()
-    doAssert orig == @[2,3,1,2]
-    doAssert copy == @[1,2,2,3]
-  return sorted(a, system.cmp, order)
+proc sorted*[T](a: openArray[T], order = SortOrder.Ascending): seq[T] =
+  ## Shortcut version of ``sorted`` that uses ``system.cmp[T]`` as the comparison function.
+  sorted[T](a, system.cmp[T], order)
 
 template sortedByIt*(seq1, op: untyped): untyped =
   ## Convenience template around the ``sorted`` proc to reduce typing.
@@ -373,12 +363,9 @@ func isSorted*[T](a: openArray[T],
     if cmp(a[i],a[i+1]) * order > 0:
       return false
 
-func isSorted*[T](a: openArray[T], order = SortOrder.Ascending): bool =
-  ## checks whether ``a`` is sorted with a default lexicographical ordering.
-  runnableExamples:
-    let test = @[1,1,2,3,5,8]
-    doAssert test.isSorted()
-  result = isSorted(a, system.cmp, order)
+proc isSorted*[T](a: openarray[T], order = SortOrder.Ascending): bool =
+  ## Shortcut version of ``isSorted`` that uses ``system.cmp[T]`` as the comparison function.
+  isSorted(a, system.cmp[T], order)
 
 proc product*[T](x: openArray[seq[T]]): seq[seq[T]] =
   ## produces the Cartesian product of the array. Warning: complexity

tests/stdlib/tsortcall.nim

@@ -1,5 +1,65 @@
 import algorithm
-
-proc foosort(ships: var seq[int]) = sort(ships, system.cmp[int])
+import unittest
 
 
+suite "test sort, sorted, and isSorted procs":
+  proc foosort(ships: var seq[int]) = sort(ships, system.cmp[int])
+
+  type
+    User = object
+      name: string
+      age: int
+
+  func newUser(name: string, age: int): User =
+    result.name = name
+    result.age = age
+
+  proc compareUsers(x, y: User): int =
+    if x.age == y.age: return 0
+    if x.age < y.age: return -1
+    return 1
+
+  setup:
+    var
+      unSortedIntSeq = @[1, 4, 3, 5, -1]
+      unSortedUserSeq = @[newUser("Andreas", 34), newUser("Alice", 12), newUser("Bob", 23)]
+
+    let
+      sortedIntSeq = @[-1, 1, 3, 4, 5]
+      sortedUserSeq = @[newUser("Alice", 12), newUser("Bob", 23), newUser("Andreas", 34)]
+
+  test "test the shortcut versions of sort, sorted, and isSorted":
+    check(not unSortedIntSeq.isSorted)
+    check sorted(unSortedIntSeq) == sortedIntSeq
+    check sorted(unSortedIntSeq).isSorted
+
+    unSortedIntSeq.sort()
+    check unSortedIntSeq == sortedIntSeq
+    check unSortedIntSeq.isSorted
+
+  test "test the shortcut versions with descending sort order":
+    check(not unSortedIntSeq.isSorted(SortOrder.Descending))
+    check sorted(unSortedIntSeq, SortOrder.Descending) == reversed sortedIntSeq
+    check sorted(unSortedIntSeq).isSorted(SortOrder.Descending)
+
+    unSortedIntSeq.sort(SortOrder.Descending)
+    check unSortedIntSeq == reversed sortedIntSeq
+    check unSortedIntSeq.isSorted(SortOrder.Descending)
+
+  test "test the versions that accept a custom compareUsers function":
+    check(not unSortedUserSeq.isSorted(compareUsers))
+    check sorted(unSortedUserSeq, compareUsers) == sortedUserSeq
+    check sorted(unSortedUserSeq, compareUsers).isSorted(compareUsers)
+
+    unSortedUserSeq.sort(compareUsers)
+    check unSortedUserSeq == sortedUserSeq
+    check unSortedUserSeq.isSorted(compareUsers)
+
+  test "test the long versions with descending sort order":
+    check(not unSortedUserSeq.isSorted(compareUsers, SortOrder.Descending))
+    check sorted(unSortedUserSeq, compareUsers, SortOrder.Descending) == reversed sortedUserSeq
+    check sorted(unSortedUserSeq, compareUsers,
+                  SortOrder.Descending).isSorted(compareUsers, SortOrder.Descending)
+    unSortedUserSeq.sort(compareUsers, SortOrder.Descending)
+    check unSortedUserSeq == reversed sortedUserSeq
+    check unSortedUserSeq.isSorted(compareUsers, SortOrder.Descending)