package core:slice
Source

⌘K
Ctrl+K
or
/

    Types

    Map_Entry ¶
    Source

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

    Map_Entry_Info ¶
    Source

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

    Ordering ¶
    Source

    Ordering :: enum int {
	Less    = -1, 
	Equal   = 0, 
	Greater = 1, 
}
    Related Procedures With Returns

    Constants

    This section is empty.

    Variables

    This section is empty.

    Procedures

    all_of ¶
    Source

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

    all_of_proc ¶
    Source

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

    any_of ¶
    Source

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

    any_of_proc ¶
    Source

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

    as_ptr ¶
    Source

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

    Binary search searches the given slice for the given element.

    If the slice is not sorted, the returned index is unspecified and meaningless.

If the value is found then the returned int is the index of the matching element.
If there are multiple matches, then any one of the matches could be returned.

If the value is not found then the returned int is the index where a matching
element could be inserted while maintaining sorted order.

# Examples

Looks up a series of four elements. The first is found, with a
uniquely determined position; the second and third are not
found; the fourth could match any position in `[1, 4]`.

```
index: int
found: bool

s := []i32{0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55}

index, found = slice.binary_search(s, 13)
assert(index == 9 && found == true)

index, found = slice.binary_search(s, 4)
assert(index == 7 && found == false)

index, found = slice.binary_search(s, 100)
assert(index == 13 && found == false)

index, found = slice.binary_search(s, 1)
assert(index >= 1 && index <= 4 && found == true)
```

For slices of more complex types see: binary_search_by

    binary_search_by ¶
    Source

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

    bytes_from_ptr ¶
    Source

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

    Turn a pointer and a length into a byte slice.

    clone ¶
    Source

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

    copies a slice into a new slice

    clone_to_dynamic ¶
    Source

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

    copies slice into a new dynamic array

    cmp ¶
    Source

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

    cmp_proc ¶
    Source

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

    concatenate ¶
    Source

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

    contains ¶
    Source

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

    count ¶
    Source

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

    count_proc ¶
    Source

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

    dot_product ¶
    Source

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

    enumerated_array ¶
    Source

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

    Convert a pointer to an enumerated array to a slice of the element type

    equal ¶
    Source

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

    fill ¶
    Source

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

    filter ¶
    Source

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

    filter_reverse ¶
    Source

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

    first ¶
    Source

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

    first_ptr ¶
    Source

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

    from_ptr ¶
    Source

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

    Turn a pointer and a length into a slice.

    get ¶
    Source

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

    get_ptr ¶
    Source

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

    has_prefix ¶
    Source

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

    has_suffix ¶
    Source

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

    into_dynamic ¶
    Source

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

    Converts slice into a dynamic array without cloning or allocating memory

    is_empty ¶
    Source

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

    is_sorted ¶
    Source

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

    is_sorted_by ¶
    Source

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

    is_sorted_by_cmp ¶
    Source

    is_sorted_by_cmp :: is_sorted_cmp

    is_sorted_by_key ¶
    Source

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

    is_sorted_cmp ¶
    Source

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

    last ¶
    Source

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

    last_ptr ¶
    Source

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

    length ¶
    Source

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

    linear_search_proc ¶
    Source

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

    map_entries ¶
    Source

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

    map_entry_infos ¶
    Source

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

    map_keys ¶
    Source

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

    map_values ¶
    Source

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

    mapper ¶
    Source

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

    max ¶
    Source

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

    max_index ¶
    Source

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

    Find the index of the (first) maximum element in a slice.

    min ¶
    Source

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

    min_index ¶
    Source

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

    Find the index of the (first) minimum element in a slice.

    min_max ¶
    Source

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

    none_of ¶
    Source

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

    none_of_proc ¶
    Source

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

    prefix_length ¶
    Source

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

    return the prefix length common between slices a and b.

    slice.prefix_length([]u8{1, 2, 3, 4}, []u8{1}) -> 1
slice.prefix_length([]u8{1, 2, 3, 4}, []u8{1, 2, 3}) -> 3
slice.prefix_length([]u8{1, 2, 3, 4}, []u8{2, 3, 4}) -> 0

    ptr_add ¶
    Source

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

    ptr_rotate ¶
    Source

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

    ptr_sub ¶
    Source

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

    ptr_swap_non_overlapping ¶
    Source

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

    ptr_swap_overlapping ¶
    Source

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

    reduce ¶
    Source

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

    reduce_reverse ¶
    Source

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

    reinterpret ¶
    Source

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

    Turn a slice of one type, into a slice of another type.

    Only converts the type and length of the slice itself.
The length is rounded down to the nearest whole number of items.

```
large_items := []i64{1, 2, 3, 4}
small_items := slice.reinterpret([]i32, large_items)
assert(len(small_items) == 8)
```
```
small_items := []byte{1, 0, 0, 0, 0, 0, 0, 0,
					  2, 0, 0, 0}
large_items := slice.reinterpret([]i64, small_items)
assert(len(large_items) == 1) // only enough bytes to make 1 x i64; two would need at least 8 bytes.
```

    repeat ¶
    Source

    repeat :: proc(s: $T/[]$T, count: int, allocator := context.allocator) -> (b: $T/[]$T, err: runtime.Allocator_Error) #optional_ok {…}

    reverse ¶
    Source

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

    reverse_sort ¶
    Source

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

    reverse_sort_by ¶
    Source

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

    reverse_sort_by_cmp ¶
    Source

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

    reverse_sort_by_key ¶
    Source

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

    rotate_left ¶
    Source

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

    rotate_right ¶
    Source

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

    scanner ¶
    Source

    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 ¶
    Source

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

    sort ¶
    Source

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

    sort sorts a slice This sort is not guaranteed to be stable

    sort_by ¶
    Source

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

    sort_by sorts a slice with a given procedure to test whether two values are ordered "i < j" This sort is not guaranteed to be stable

    sort_by_cmp ¶
    Source

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

    sort_by_indices_allocate ¶
    Source

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

    sort_by_indices_overwrite ¶
    Source

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

    sort_by_key ¶
    Source

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

    TODO(bill): Should sort_by_key exist or is sort_by more than enough?

    sort_by_with_indices ¶
    Source

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

    sort_by sorts a slice with a given procedure to test whether two values are ordered "i < j" This sort is not guaranteed to be stable

    sort_with_indices ¶
    Source

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

    sort sorts a slice and returns a slice of the original indices This sort is not guaranteed to be stable

    split_at ¶
    Source

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

    split_first ¶
    Source

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

    split_last ¶
    Source

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

    stable_sort ¶
    Source

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

    stable_sort sorts a slice

    stable_sort_by ¶
    Source

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

    stable_sort_by sorts a slice with a given procedure to test whether two values are ordered "i < j"

    stable_sort_by_cmp ¶
    Source

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

    swap ¶
    Source

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

    swap_between ¶
    Source

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

    swap_with_slice ¶
    Source

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

    to_bytes ¶
    Source

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

    Turn a slice into a byte slice.

    See `slice.reinterpret` to go the other way.

    to_dynamic ¶
    Source

    to_dynamic :: clone_to_dynamic
     

    copies slice into a new dynamic array

    unique ¶
    Source

    unique :: proc(s: $T/[]$T) -> $T/[]$T {…}
     

    'unique' replaces consecutive runs of equal elements with a single copy. The procedures modifies the slice in-place and returns the modified slice.

    unique_proc ¶
    Source

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

    'unique_proc' replaces consecutive runs of equal elements with a single copy using a comparison procedure The procedures modifies the slice in-place and returns the modified slice.

    zero ¶
    Source

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

    Procedure Groups

    sort_by_indices ¶
    Source

    sort_by_indices :: proc{
	sort_by_indices_allocate,
	_sort_by_indices,
}

    Source Files

    Generation Information

    Generated with odin version dev-2024-04 (vendor "odin") Windows_amd64 @ 2024-04-26 21:08:58.630668900 +0000 UTC