Collections

Array<T>

The built-in dynamic array type. All Seen programs have access to Array<T>.

Construction

let arr = Array<Int>()                // empty
let arr = [1, 2, 3, 4, 5]            // literal
let arr = Array<Int>.withLength(100)  // pre-sized

Methods

Method	Return	Description
push(value: T)	Void	Append element
pop()	T	Remove and return last element
get(index: Int)	T	Get element at index
set(index: Int, value: T)	Void	Set element at index
length()	Int	Number of elements

Runtime Array Functions

Function	Description
seen_arr_new_str()	Create empty string array
seen_arr_new_ptr()	Create empty pointer array
seen_arr_push_str(arr, s)	Push string
seen_arr_push_i64(arr, val)	Push integer
seen_arr_push_f64(arr, val)	Push float
seen_arr_push_ptr(arr, ptr)	Push pointer
seen_arr_get_str(arr, idx)	Get string at index
seen_arr_get_i64(arr, idx)	Get integer at index
seen_arr_set_i64(arr, idx, val)	Set integer at index
seen_arr_set_str(arr, idx, s)	Set string at index
seen_arr_length(arr)	Get array length

Example

var names = Array<String>()
names.push("Alice")
names.push("Bob")
names.push("Charlie")

for name in names {
    println("Hello, {name}!")
}

Vec<T>

Contiguous vector with amortized O(1) push/pop and O(1) indexed access. Vec<T> is the preferred performance-oriented growable sequence when callers need repeated get, set, iteration, or conversion back to Array<T>.

import collections.vec

Construction

let v = Vec<Int>.new()
let v = Vec<Int>.withCapacity(1000)

Methods

Method	Return	Description
push(value: T)	Void	Append element
pop()	T	Remove last
get(index: Int)	T	Get by index
set(index: Int, value: T)	Void	Set by index
len()	Int	Length
isEmpty()	Bool	Check empty
capacity()	Int	Total capacity
clear()	Void	Remove all elements
reverse()	Void	Reverse in place

HashMap<K, V>

Robin-hood hashing hash map. Iteration order is non-deterministic.

Generic keys in the source fallback hash through their stable string form, so supported primitive and string keys no longer collapse into a single bucket. For string-heavy workloads, StringHashMap<V> still avoids generic conversion overhead and uses byte-wise hashing directly.

import collections.hash_map

Construction

let map = HashMap<String, Int>()
let map = HashMap<String, Int>.withCapacity(100)

Methods

Method	Return	Description
insert(key: K, value: V)	Void	Insert or update
get(key: K)	Option<V>	Lookup by key
getOrDefault(key: K, defaultValue: V)	V	Lookup without allocating an Option result
containsKey(key: K)	Bool	Probe without allocating an Option result
getUnchecked(key: K)	V	Direct lookup for hot paths after containsKey; missing keys are caller error
remove(key: K)	Option<V>	Remove by key
len()	Int	Number of entries
isEmpty()	Bool	Check empty
clear()	Void	Remove all entries

Runtime HashMap Functions

4 variants per operation (key types: int_int, int_str, str_int, str_str):

Function	Description
hashmap_new_*()	Create new map
hashmap_new_*_with_capacity(cap)	Create with capacity
hashmap_insert_*(map, key, val)	Insert
hashmap_get_*(map, key)	Lookup
hashmap_getUnchecked_*(map, key)	Direct lookup without constructing an Option wrapper
hashmap_remove_*(map, key)	Remove
hashmap_clear_*(map)	Clear all entries
hashmap_size_*(map)	Get size

Example

var scores = HashMap<String, Int>()
scores.insert("Alice", 95)
scores.insert("Bob", 87)
scores.insert("Charlie", 92)

let alice = scores.get("Alice")
if alice.isSome() {
    println("Alice's score: {alice.unwrap()}")
}

BTreeMap<K, V>

Ordered map based on B-tree. Keys are kept sorted.

import collections.btree_map

Same interface as HashMap, but with ordered iteration.

Runtime BTreeMap Functions

4 variants (int_int, int_str, str_int, str_str):

Function	Description
btreemap_new_*()	Create new map
btreemap_insert_*(map, key, val)	Insert (maintains order)
btreemap_get_*(map, key)	Lookup
btreemap_remove_*(map, key)	Remove
btreemap_clear_*(map)	Clear
btreemap_size_*(map)	Size

HashSet<T>

Unordered set backed by HashMap<T, Unit>.

import collections.hashset

BTreeSet<T>

Ordered set backed by BTreeMap<T, Unit>.

import collections.btree_set

LinkedList<T>

Doubly-linked list.

import collections.linked_list

Methods

Method	Return	Description
push_front(value: T)	Void	Add to front
push_back(value: T)	Void	Add to back
pop_front()	T	Remove from front
pop_back()	T	Remove from back
len()	Int	Length

Runtime LinkedList Functions

2 variants (int, str):

Function	Description
linkedlist_new_*()	Create new list
linkedlist_push_front_*(list, val)	Push front
linkedlist_push_back_*(list, val)	Push back
linkedlist_pop_front_*(list)	Pop front
linkedlist_pop_back_*(list)	Pop back
linkedlist_size_*(list)	Size

VecDeque<T>

Double-ended queue with O(1) front/back operations.

import collections.vecdeque

collections/vecdeque currently exposes IntVecDeque for integer queues.

SmallVec<T>

Inline-storage vector that avoids heap allocation for small sizes:

let sv = seen_small_vec_new(8)   // inline capacity of 8
seen_small_vec_push_i64(sv, 42)
let val = seen_small_vec_get_i64(sv, 0)
let len = seen_small_vec_length(sv)
seen_small_vec_clear(sv)

Falls back to heap when inline capacity is exceeded.

StringHashMap<V>

Optimized HashMap<String, V> with string-specific hashing.

import collections.string_hash_map

ByteBuffer

Low-level byte storage for binary data. ByteArray and ByteBuffer use compact runtime-backed byte storage and expose Int values at the API boundary.

import collections.byte_buffer

let bytes = ByteBuffer.withCapacity(1024)
bytes.reserve(4096)
bytes.push(255)
bytes.push(256)   // stored as 0
let value = bytes.get(0)

Byte APIs

Type	Description
ByteArray	Compact growable byte array
ByteBuffer	Convenience wrapper around ByteArray
Int32Buffer / Int64Buffer	Primitive integer buffer APIs backed by compact runtime storage
Float32Buffer / Float64Buffer	Primitive floating-point buffer APIs backed by native float/double storage

Method	Return	Description
capacity()	Int	Current allocated capacity
tryReserve(requiredCapacity)	Bool	Grow backing storage without aborting on allocation failure
reserve(requiredCapacity)	Void	Grow backing storage or panic with a Seen diagnostic
push(value: Int)	Void	Append byte, masked to 0..255
append(other)	Void	Append another byte buffer
get(index: Int)	Int	Read byte
set(index: Int, value: Int)	Void	Write byte
slice(start: Int, end: Int)	same type	Copy a byte range
reverse()	Void	Reverse in place
fill(value: Int)	Void	Fill existing bytes
toArray() / toIntArray()	Array<Int>	Convert to integer byte values

Algorithms

Shared collection algorithms for performance-sensitive integer and floating-point paths.

import collections.algorithms

Module path: collections/algorithms.

Function / Type	Description
binarySearchInt(values, needle)	Return matching index or -1
lowerBoundInt(values, needle)	First insertion slot not less than needle
upperBoundInt(values, needle)	First insertion slot greater than needle
unstableSortInt(values)	In-place introsort with insertion sort for small partitions and a heapsort depth fallback
stableSortInt(values)	Stable sorted copy
radixSortInt(values)	Signed integer radix sort that preserves negative/positive ordering
IntPriorityQueue.min() / .max()	Binary heap priority queues
binarySearchFloat(values, needle)	Return matching float index or -1
lowerBoundFloat(values, needle)	First float insertion slot not less than needle
upperBoundFloat(values, needle)	First float insertion slot greater than needle
unstableSortFloat(values)	In-place introsort for Array<Float>
stableSortFloat(values)	Stable sorted float copy
FloatPriorityQueue.min() / .max()	Binary heap priority queues for floats

BitSet

Compact bit set.

import collections.bit_set

StringBuffer

Mutable string buffer used by parser, compiler, and text-heavy runtime code.

import collections.string_buffer

StdString

collections/std_string provides StdString, a stdlib wrapper around string operations that need a class-style surface.

Pool<T>

Object pool for reusing allocated objects.

import collections.pool