Sorting: consistently use alg keyword for algorithm selection (#92)

Author: maleadt

docs/src/api/binarysearch.md

@@ -13,7 +13,7 @@ using Metal
 
 # Sorted array
 v = MtlArray(rand(Float32, 100_000))
-AK.merge_sort!(v)
+AK.sort!(v; alg=AK.MergeSort())
 
 # Elements `x` to place within `v` at indices `ix`
 x = MtlArray(rand(Float32, 10_000))

docs/src/api/sort.md

@@ -13,12 +13,6 @@ AcceleratedKernels.sortperm!
 AcceleratedKernels.sortperm
 ```
 
-Specific implementations that the interfaces above forward to:
-- `sample_sort!` - multithreaded CPU sample sort, deferring to Base.sort! on independent slices.
-- `merge_sort!` (in-place), `merge_sort` (out-of-place) - sort arbitrary objects with custom comparisons.
-- `merge_sort_by_key!`, `merge_sort_by_key` - sort a vector of keys along with a "payload", a vector of corresponding values.
-- `merge_sortperm!`, `merge_sortperm`, `merge_sortperm_lowmem!`, `merge_sortperm_lowmem` - compute a sorting index permutation. 
-
 Algorithm choice is available on `sort!` / `sort` / `sortperm!` / `sortperm` with `alg=AK.MergeSort()`,
 `alg=AK.MergeSort(lowmem=true)`, `alg=AK.RadixSort()`, or `alg=AK.SampleSort()`, depending on the
 backend and operation.
@@ -28,16 +22,6 @@ Function signatures:
 AcceleratedKernels.MergeSort
 AcceleratedKernels.RadixSort
 AcceleratedKernels.SampleSort
-AcceleratedKernels.sample_sort!
-AcceleratedKernels.sample_sortperm!
-AcceleratedKernels.merge_sort!
-AcceleratedKernels.merge_sort
-AcceleratedKernels.merge_sort_by_key!
-AcceleratedKernels.merge_sort_by_key
-AcceleratedKernels.merge_sortperm!
-AcceleratedKernels.merge_sortperm
-AcceleratedKernels.merge_sortperm_lowmem!
-AcceleratedKernels.merge_sortperm_lowmem
 ```
 
 Example:

src/sort/sort.jl

@@ -73,7 +73,7 @@ arguments are the same as for `Base.sort`.
 
 ## CPU
 CPU settings: use at most `max_tasks` threads to sort the array such that at least `min_elems`
-elements are sorted by each thread. A parallel [`sample_sort!`](@ref) is used, processing
+elements are sorted by each thread. A parallel sample sort is used, processing
 independent slices of the array and deferring to `Base.sort!` for the final local sorts.
 
 Note that the Base Julia `sort!` is mainly memory-bound, so multithreaded sorting only becomes
@@ -88,7 +88,7 @@ algorithm take precedence over this keyword, then backend defaults. `items_per_t
 `RadixSort` and defaults to 2.
 
 ## Algorithm choice
-By default, `sort!` uses [`sample_sort!`](@ref) on CPU backends and [`merge_sort!`](@ref) on GPU
+By default, `sort!` uses sample sort on CPU backends and merge sort on GPU
 backends. Pass `alg=SampleSort()` for the CPU path, `alg=MergeSort()` for the GPU merge-sort path,
 or `alg=RadixSort()` to opt into GPU radix sorting. `RadixSort()` supports 32-bit and 64-bit
 integers and floats with default `lt`/`by`.
@@ -256,8 +256,8 @@ Save into `ix` the index permutation of `v` such that `v[ix]` is sorted. The `lt
 [`sort!`](@ref) with custom by-index comparators.
 
 ## Algorithm choice
-By default, `sortperm!` uses [`sample_sortperm!`](@ref) on CPU backends and [`merge_sortperm!`](@ref)
-on GPU backends. Pass `alg=MergeSort(lowmem=true)` to use the lower-memory GPU permutation path.
+By default, `sortperm!` uses sample sort on CPU backends and merge sort on GPU
+backends. Pass `alg=MergeSort(lowmem=true)` to use the lower-memory GPU permutation path.
 `RadixSort()` does not provide a permutation path.
 """
 function sortperm!(