package core:sort

Source

Interface :: struct {
	len:        proc(it: Interface) -> int,
	less:       proc(it: Interface, i, j: int) -> bool,
	swap:       proc(it: Interface, i, j: int),
	collection: rawptr,
}

ORD :: intrinsics.type_is_ordered

bubble_sort :: proc(array: $T/[]$T) {…}

bubble_sort_proc :: proc(array: $T/[]$T, f: proc($T, $T) -> int) {…}

compare_bools :: proc(a, b: bool) -> int {…}

compare_f32s :: proc(a, b: f32) -> int {…}

compare_f64s :: proc(a, b: f64) -> int {…}

compare_i16s :: proc(a, b: i16) -> int {…}

compare_i32s :: proc(a, b: i32) -> int {…}

compare_i64s :: proc(a, b: i64) -> int {…}

compare_i8s :: proc(a, b: i8) -> int {…}

compare_ints :: proc(a, b: int) -> int {…}

compare_strings :: proc(a, b: string) -> int {…}

compare_u16s :: proc(a, b: u16) -> int {…}

compare_u32s :: proc(a, b: u32) -> int {…}

compare_u64s :: proc(a, b: u64) -> int {…}

compare_u8s :: proc(a, b: u8) -> int {…}

compare_uints :: proc(a, b: uint) -> int {…}

heap_sort :: proc(array: $T/[]$T) {…}

heap_sort_proc :: proc(array: $T/[]$T, f: proc($T, $T) -> int) {…}

is_sorted :: proc(it: Interface) -> bool {…}

merge_sort :: proc(array: $T/[]$T) {…}

merge_sort_proc :: proc(array: $T/[]$T, f: proc($T, $T) -> int) {…}

quick_sort :: proc(array: $T/[]$T) {…}

quick_sort_proc :: proc(array: $T/[]$T, f: proc($T, $T) -> int) {…}

reverse_interface :: proc(it: ^Interface) -> Interface {…}

reverse_slice :: proc(array: $T/[]$T) {…}

reverse_sort :: proc(it: Interface) {…}

rotate :: proc(it: Interface, a, m, b: int) {…}

slice :: proc(array: $T/[]$T) {…}

slice_interface :: proc(s: ^$T/[]$T) -> Interface {…}

sort :: proc(it: Interface) {…}

swap_range :: proc(it: Interface, a, b, n: int) {…}