package core:slice

Source

Map_Entry :: struct($Key: typeid, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {}

Map_Entry_Info :: struct($Key: typeid, $Value: typeid) where intrinsics.type_is_valid_map_key(Key) {}

Ordering :: enum int {
	Less    = -1, 
	Equal   = 0, 
	Greater = 1, 
}

all_of :: proc(s: $T/[]$T, value: $T) -> bool {…}

all_of_proc :: proc(s: $T/[]$T, f: proc(_: $T) -> bool) -> bool {…}

any_of :: proc(s: $T/[]$T, value: $T) -> bool {…}

any_of_proc :: proc(s: $T/[]$T, f: proc(_: $T) -> bool) -> bool {…}

as_ptr :: proc(array: $T/[]$T) -> [^]$T {…}

binary_search :: proc(array: $T/[]$T, key: $T) -> (index: int, found: bool) {…}

bytes_from_ptr :: proc "contextless" (ptr: rawptr, byte_count: int) -> []u8 {…}

clone :: proc(a: $T/[]$T, allocator := context.allocator) -> ([]$T, runtime.Allocator_Error) #optional_ok {…}

clone_to_dynamic :: proc(a: $T/[]$T, allocator := context.allocator) -> ([dynamic]$T, runtime.Allocator_Error) #optional_ok {…}

cmp :: proc(a, b: $T) -> Ordering {…}

cmp_proc :: proc($E: typeid) -> proc(_: typeid, _: typeid) -> Ordering {…}

concatenate :: proc(a: []$T/[]$T, allocator := context.allocator) -> (res: $T/[]$T, err: runtime.Allocator_Error) #optional_ok {…}

contains :: proc(array: $T/[]$T, value: $T) -> bool {…}

count :: proc(s: $T/[]$T, value: $T) -> (n: int) {…}

count_proc :: proc(s: $T/[]$T, f: proc(_: $T) -> bool) -> (n: int) {…}

dot_product :: proc(a, b: $T/[]$T) -> (r: $T, ok: bool) {…}

enumerated_array :: proc(ptr: ^$T) -> []$T {…}

equal :: proc(a, b: $T/[]$T) -> bool {…}

fill :: proc(array: $T/[]$T, value: $T) {…}

filter :: proc(s: $T/[]$T, f: proc(_: $T) -> bool, allocator := context.allocator) -> $T/[]$T {…}

first :: proc(array: $T/[]$T) -> $T {…}

first_ptr :: proc(array: $T/[]$T) -> ^$T {…}

from_ptr :: proc "contextless" (ptr: ^$T, count: int) -> []$T {…}

get :: proc(array: $T/[]$T, index: int) -> (value: $T, ok: bool) {…}

get_ptr :: proc(array: $T/[]$T, index: int) -> (value: ^$T, ok: bool) {…}

has_prefix :: proc(array: $T/[]$T, needle: $T) -> bool {…}

has_suffix :: proc(array: $T/[]$T, needle: $T) -> bool {…}

into_dynamic :: proc(a: $T/[]$T) -> [dynamic]$T {…}

is_empty :: proc(a: $T/[]$T) -> bool {…}

is_sorted :: proc(array: $T/[]$T) -> bool {…}

is_sorted_by :: proc(array: $T/[]$T, less: proc(i, j: $T) -> bool) -> bool {…}

is_sorted_by_cmp :: is_sorted_cmp

is_sorted_by_key :: proc(array: $T/[]$T, key: proc(_: $T) -> $T) -> bool {…}

is_sorted_cmp :: proc(array: $T/[]$T, cmp: proc(i, j: $T) -> Ordering) -> bool {…}

last :: proc(array: $T/[]$T) -> $T {…}

last_ptr :: proc(array: $T/[]$T) -> ^$T {…}

length :: proc(a: $T/[]$T) -> int {…}

linear_search :: proc(array: $T/[]$T, key: $T) -> (index: int, found: bool) {…}

linear_search_proc :: proc(array: $T/[]$T, f: proc(_: $T) -> bool) -> (index: int, found: bool) {…}

map_entries :: proc(m: $T/map[$T]$T, allocator := context.allocator) -> (entries: []Map_Entry($Key, $Value), err: runtime.Allocator_Error) {…}

map_entry_infos :: proc(m: $T/map[$T]$T, allocator := context.allocator) -> (entries: []Map_Entry_Info($Key, $Value)) {…}

map_keys :: proc(m: $T/map[$T]$T, allocator := context.allocator) -> (keys: []$T, err: runtime.Allocator_Error) {…}

map_values :: proc(m: $T/map[$T]$T, allocator := context.allocator) -> (values: []$T, err: runtime.Allocator_Error) {…}

mapper :: proc(s: $T/[]$T, f: proc(_: $T) -> $T, allocator := context.allocator) -> (r: []$T, err: runtime.Allocator_Error) #optional_ok {…}

max :: proc(s: $T/[]$T) -> (res: $T, ok: bool) #optional_ok {…}

min :: proc(s: $T/[]$T) -> (res: $T, ok: bool) #optional_ok {…}

min_max :: proc(s: $T/[]$T) -> (min, max: $T, ok: bool) {…}

none_of :: proc(s: $T/[]$T, value: $T) -> bool {…}

none_of_proc :: proc(s: $T/[]$T, f: proc(_: $T) -> bool) -> bool {…}

prefix_length :: proc(a, b: $T/[]$T) -> (n: int) {…}

ptr_add :: proc(p: $P/^$T, x: int) -> ^$T {…}

ptr_rotate :: proc(left: int, mid: ^$T, right: int) {…}

ptr_sub :: proc(p: $P/^$T, x: int) -> ^$T {…}

ptr_swap_non_overlapping :: proc(x, y: rawptr, len: int) {…}

ptr_swap_overlapping :: proc(x, y: rawptr, len: int) {…}

reduce :: proc(s: $T/[]$T, initializer: $T, f: proc(_: $T, _: $T) -> $T) -> $T {…}

reinterpret :: proc "contextless" ($T: typeid/[]T, s: []T) -> []T {…}

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

reverse_sort :: proc(data: $T/[]$T) {…}

reverse_sort_by :: proc(data: $T/[]$T, less: proc(i, j: $T) -> bool) {…}

reverse_sort_by_cmp :: proc(data: $T/[]$T, cmp: proc(i, j: $T) -> Ordering) {…}

reverse_sort_by_key :: proc(data: $T/[]$T, key: proc(_: $T) -> $T) {…}

rotate_left :: proc(array: $T/[]$T, mid: int) {…}

rotate_right :: proc(array: $T/[]$T, k: int) {…}

scanner :: proc(s: $T/[]$T, initializer: $T, f: proc(_: $T, _: $T) -> $T, allocator := context.allocator) -> (res: []$T, err: runtime.Allocator_Error) #optional_ok {…}

simple_equal :: proc(a, b: $T/[]$T) -> bool {…}

sort :: proc(data: $T/[]$T) {…}

sort_by :: proc(data: $T/[]$T, less: proc(i, j: $T) -> bool) {…}

sort_by_cmp :: proc(data: $T/[]$T, cmp: proc(i, j: $T) -> Ordering) {…}

sort_by_indices_allocate :: proc(data: $T/[]$T, indices: []int, allocator := context.allocator) -> (sorted: $T/[]$T) {…}

sort_by_indices_overwrite :: proc(data: $T/[]$T, indices: []int) {…}

sort_by_key :: proc(data: $T/[]$T, key: proc(_: $T) -> $T) {…}

sort_by_with_indices :: proc(data: $T/[]$T, less: proc(i, j: $T) -> bool, allocator := context.allocator) -> (indices: []int) {…}

sort_with_indices :: proc(data: $T/[]$T, allocator := context.allocator) -> (indices: []int) {…}

split_at :: proc(array: $T/[]$T, index: int) -> (a, b: $T/[]$T) {…}

split_first :: proc(array: $T/[]$T) -> (first: $T, rest: $T/[]$T) {…}

split_last :: proc(array: $T/[]$T) -> (rest: $T/[]$T, last: $T) {…}

stable_sort :: proc(data: $T/[]$T) {…}

stable_sort_by :: proc(data: $T/[]$T, less: proc(i, j: $T) -> bool) {…}

stable_sort_by_cmp :: proc(data: $T/[]$T, cmp: proc(i, j: $T) -> Ordering) {…}

swap :: proc(array: $T/[]$T, a, b: int) {…}

swap_between :: proc(a, b: $T/[]$T) {…}

swap_with_slice :: proc(a, b: $T/[]$T, loc := #caller_location) {…}

to_bytes :: proc "contextless" (s: []$T) -> []u8 {…}

to_dynamic :: clone_to_dynamic

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

sort_by_indices :: proc{
	sort_by_indices_allocate,
	_sort_by_indices,
}