std.pqueue

arena binary heap; O(log n) push/pop; order = any type with less()

Min

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

smallest first

Min.less

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

Max

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

largest first

Max.less

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

By

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

first by f(a, b): true if a comes before b

By.less

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

PriorityQueue

pub PriorityQueue :: struct($T: type, $C: type) {
    region: *Arena,
    data: []T,
    count: usize,
    order: C,
}

• region: where it grows (borrowed)
• data: heap, data[0] first; cap == data.len

PriorityQueue.len

pub len :: fn(self: *Self) -> usize

PriorityQueue.is_empty

pub is_empty :: fn(self: *Self) -> bool

PriorityQueue.peek

pub peek :: fn(self: *Self) -> ?T

next pop result, left in place; null if empty

PriorityQueue.push

pub push :: fn(self: *Self, item: T)

PriorityQueue.push_all

pub push_all :: fn(self: *Self, items: []const T)

push each of items

PriorityQueue.pop

pub pop :: fn(self: *Self) -> ?T

take the first; null if empty

PriorityQueue.items

pub items :: fn(self: *Self) -> []T

unordered; valid until the next push

PriorityQueue.clear

pub clear :: fn(self: *Self)

with

pub with :: fn($T: type, $C: type, a: *Arena, order: C) -> PriorityQueue(T, C)

queue in a; order decides what comes first

min

pub min :: fn($T: type, a: *Arena) -> PriorityQueue(T, Min(T))

smallest first

max

pub max :: fn($T: type, a: *Arena) -> PriorityQueue(T, Max(T))

largest first

by

pub by :: fn($T: type, a: *Arena, less: fn(T, T) -> bool) -> PriorityQueue(T, By(T))

first by less(a, b): true if a comes before b