dsa.arr

Growable arrays with checked indexing, optional access, and iteration.

All modules · Writing docstrings

Imports and exports

import core.{Opt, GetItem, SetItem, ToBin}
import mem.{Ptr, Buf, heap}

Arr

kind Arr[T]

A growable sequence of values of type T. len counts initialized elements. Use get for optional access or brackets for access that stops on an invalid index.

let values = Arr[Int].new()
values.push(10)
values.push(20)
print(values.len)
print(values.pop().unwrap())
print(values.get(8).unwrap_or(-1))

2
20
-1

Source, line 25

Arr.buf

buf: Buf[T]

Backing buffer. Changing it directly can violate the array’s invariants.

Source, line 27

Arr.len

len: Int

Number of live elements, from zero through the buffer capacity.

Source, line 29

Arr[@T]

impl Arr[@T]

Source, line 32

Arr[@T].new

func new(): Arr[T]

Create an empty array with an initial capacity of four.

Source, line 34

Arr[@T].push

func push(self, val: T)

Append val, growing the backing allocation when full. Mutates the array.

Source, line 44

Arr[@T].pop

func pop(self): Opt[T]

Remove and return the last value, or Non if empty.

Source, line 55

Arr[@T].get

func get(self, index: Int): Opt[T]

Return the indexed value, or Non for a negative or out-of-range index.

Source, line 64

Arr[@T].set

func set(self, index: Int, val: T): Bool

Replace an existing element. Return false without writing if the index is invalid.

let values = [10, 20]
print(values.set(1, 30))
print(values[1])
print(values.set(9, 50))

true
30
false

Source, line 84

ArrIter

kind ArrIter[T]

An array iterator. Avoid changing the source array while iterating.

Source, line 94

ArrIter.arr

arr: Arr[T]

Array value used by this iterator.

Source, line 96

ArrIter.idx

idx: Int

Index of the next element to visit.

Source, line 98

ArrIter[@T] as Iter[T]

impl ArrIter[@T] as Iter[T]

Source, line 101

ArrIter[@T] as Iter[T].next

func next(self): Opt[T]

Yield the next element and advance, or return Non after the last element.

Source, line 103

Arr[@T] as GetItem[Int, T]

impl Arr[@T] as GetItem[Int, T]

Source, line 113

Arr[@T] as GetItem[Int, T].get_item

func get_item(self, key: Int): T

Implement array[key]. Stop with an error when key is outside 0..len.

Source, line 115

Arr[@T] as SetItem[Int, T]

impl Arr[@T] as SetItem[Int, T]

Source, line 123

Arr[@T] as SetItem[Int, T].set_item

func set_item(self, key: Int, val: T)

Implement array[key] = val. Stop with an error for an invalid index.

Source, line 125

Arr[@T] as ToIter[T]

impl Arr[@T] as ToIter[T]

Source, line 133

Arr[@T] as ToIter[T].to_iter

func to_iter(self): ArrIter[T]

Create an iterator starting at the first element.

Source, line 135

Arr[Byte] as ToBin

impl Arr[Byte] as ToBin

Source, line 140

Arr[Byte] as ToBin.to_bin

func to_bin(self): Bin

Copy the live bytes into an immutable byte string. Available on Arr[Byte].

Source, line 142