Package core.list

Packages

package core.list

List

List :: struct (Elem_Type: type_expr) {
    allocator: Allocator
    first: &ListElem(Elem_Type)
    last: &ListElem(Elem_Type)
}

Methods

List.as_iter

List.as_iter :: (list: &List) -> #auto

List.at

List.at :: (list: &List($T), index: i32) -> &T

List.contains

List.contains :: (list: &List, x: list.Elem_Type) -> bool

List.count

List.count :: (list: &List) -> i32

List.fold

List.fold :: (list: &List($T), init: $R, f: (T, R) -> R) -> R

List.free

List.free :: (list: &List) -> void

List.map

List.map :: (list: &List($T), f: (T) -> $R) -> List(R)

List.pop_begin

List.pop_begin :: (list: &List($T), default: T) -> T

List.pop_end

List.pop_end :: (list: &List($T), default: T) -> T

List.push_begin

List.push_begin :: (list: &List, x: list.Elem_Type) -> void

List.push_end

List.push_end :: (list: &List, x: list.Elem_Type) -> void

ListElem

ListElem :: struct (T: type_expr) {
    next: &ListElem(T)
    prev: &ListElem(T)
    data: T
}

as_iter

as_iter :: (list: &List) -> #auto

at :: (list: &List($T), index: i32) -> &T

contains

contains :: (list: &List, x: list.Elem_Type) -> bool

count

count :: (list: &List) -> i32

empty

empty :: (list: &List) -> bool

fold

fold :: (list: &List($T), init: $R, f: (T, R) -> R) -> R

free

free :: (list: &List) -> void

from_array

from_array :: (arr: [] $T, allocator) -> List(T)

make

make :: ($T: type_expr, allocator) -> List(T)

map

map :: (list: &List($T), f: (T) -> $R) -> List(R)

pop_begin

pop_begin :: (list: &List($T), default: T) -> T

pop_begin_opt

pop_begin_opt :: (list: &List($T)) -> ? T

pop_end

pop_end :: (list: &List($T), default: T) -> T

pop_end_opt

pop_end_opt :: (list: &List($T)) -> ? T

push_begin

push_begin :: (list: &List, x: list.Elem_Type) -> void

push_end

push_end :: (list: &List, x: list.Elem_Type) -> void