std.sort

in-place sorts (introsort, not stable; stable_* merge) and binary search

Asc

pub Asc :: struct($T: type) {
    marker: u8,
}

smallest first

Asc.less

pub less :: fn(self: *Self, a: T, b: T) -> bool

Desc

pub Desc :: struct($T: type) {
    marker: u8,
}

largest first

Desc.less

pub less :: fn(self: *Self, a: T, b: T) -> bool

By

pub By :: struct($T: type) {
    f: fn(T, T) -> bool,
}

f(a, b) true when a goes before b

By.less

pub less :: fn(self: *Self, a: T, b: T) -> bool

asc

pub asc :: fn($T: type, xs: []T)

in place, smallest first; not stable

desc

pub desc :: fn($T: type, xs: []T)

in place, largest first; not stable

by

pub by :: fn($T: type, xs: []T, less: fn(T, T) -> bool)

in place by less; not stable

stable_asc

pub stable_asc :: fn($T: type, xs: []T, scratch: *Arena)

stable, smallest first; allocates an xs.len buffer in scratch

stable_by

pub stable_by :: fn($T: type, xs: []T, less: fn(T, T) -> bool, scratch: *Arena)

stable by less; allocates an xs.len buffer in scratch

is_sorted

pub is_sorted :: fn($T: type, xs: []const T) -> bool

true when ascending

is_sorted_by

pub is_sorted_by :: fn($T: type, xs: []const T, less: fn(T, T) -> bool) -> bool

true when sorted by less

lower_bound

pub lower_bound :: fn($T: type, xs: []const T, key: T) -> usize

first index with xs[i] >= key; xs.len if none

lower_bound_by

pub lower_bound_by :: fn($T: type, xs: []const T, key: T, less: fn(T, T) -> bool) -> usize

lower_bound by less

upper_bound

pub upper_bound :: fn($T: type, xs: []const T, key: T) -> usize

first index with xs[i] > key; xs.len if none

upper_bound_by

pub upper_bound_by :: fn($T: type, xs: []const T, key: T, less: fn(T, T) -> bool) -> usize

upper_bound by less

search

pub search :: fn($T: type, xs: []const T, key: T) -> ?usize

index of the first element equal to key, or null

search_by

pub search_by :: fn($T: type, xs: []const T, key: T, less: fn(T, T) -> bool) -> ?usize

search by less; equal means neither is less