Interface :: Interface

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

bubble_sort_proc :: proc(array: $A/[]$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: $A/[]$T) {…}

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

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

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

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

ORD :: invalid type {…}

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

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

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

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

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

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

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

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