Table, List, Array & Store¶

Table¶

Module: Table — hash map from String keys to values.

Defines a binary type: Table<Value> (the hash map).

  Table creates new validates has transforms add reads get keys

reads lookup(name String, db Table<String>) String
from
    Error.unwrap_or(Table.get(name, db), "unknown")

Array¶

Module: Array — fixed-size contiguous arrays with typed elements. Also accessible via the Sequence module alias.

Array<T> is a flat, unboxed buffer with a fixed length set at creation time. Elements are stored directly (no boxing), making it cache-friendly and suitable for numeric computation, sieves, bitfields, and working buffers.

Unlike List<Value>, an Array<T> has a concrete element type and a fixed size. The two modifiers that matter most:

• Array<T> (default) — copy-on-write: set returns a new array, leaving the original unchanged.
• Array<T>:[Mutable] — in-place mutation: set modifies the array directly and returns the same pointer. Use this for large working buffers updated in a tight loop.

Construction¶

The element type and mutability are inferred from context (the declared type of the receiving variable).

Access¶

Both overloads work identically on mutable (:[Mutable]) and immutable arrays.

Mutation¶

The dispatch between copy-on-write and in-place is resolved by the array's type — no separate function name needed.

Example — immutable (copy-on-write)¶

  Array creates array
  Array reads get length
  Array transforms set

main() Result<Unit, Error>!
from
    flags as Array<Boolean> = array(5, false)
    flags2 as Array<Boolean> = set(flags, 2, true)   // flags unchanged
    size as Integer = length(flags2)
    val as Boolean = get(flags2, 2)
    console(f"size={size} element[2]={val}")

Example — mutable (in-place)¶

  Array creates array
  Array reads get
  Array transforms set

// Sieve of Eratosthenes: count primes up to limit
reads count_primes(limit Integer) Integer
from
    is_composite as Array<Boolean>:[Mutable] = array(limit + 1, false)
    marked0 as Array<Boolean>:[Mutable] = set(is_composite, 0, true)
    marked1 as Array<Boolean>:[Mutable] = set(marked0, 1, true)
    sieved as Array<Boolean>:[Mutable] = sieve_pass(marked1, 2, limit)
    count_true_false(sieved, 2, limit, 0)

The :[Mutable] annotation tells the compiler to use in-place mutation — no intermediate copies are allocated during the sieve loop.

Import aliases¶

Array, Sequence, and List all refer to the same module. The preferred alias depends on context:

• Array — when working with Array<T> (fixed-size buffers)
• List or Sequence — when working with List<Value> (dynamic lists)

// These are equivalent:
  Array creates array
  Sequence creates array

List¶

Module: List — operations on the built-in List<Value> type.

Some operations (contains, index, sort) require concrete element types and have overloads for List<Integer> and List<String>.

Query¶

Search¶

Transform¶

Create¶

  List reads length first transforms sort reverse creates range

reads top_three() List<Integer>
from
    nums as List<Integer> = List.range(1, 100)
    List.reverse(List.sort(nums))

Store¶

Module: Store — persistent key-value storage with versioning and compilation.

Defines four binary types: Store (storage handle), StoreTable (table handle), TableDiff (structural diff), Version (version record).

Store Operations¶

Table Operations¶

Diff and Patch¶

Merge¶

Additional types: Conflict (conflict details), Resolution (resolver decision), MergeResult (merge outcome).

The 3-arg merge detects conflicts and returns them. The 4-arg overload passes each conflict to a resolver callback typed as Verb<Conflict, Resolution>:

// Merge without resolver — conflicts returned in MergeResult
result as MergeResult = Store.merge(base, local_diff, remote_diff)

// Merge with lambda resolver — keep remote on all conflicts
result as MergeResult = Store.merge(base, local_diff, remote_diff, |c| KeepRemote)

Lookup Compilation¶

Integrity and Versioning¶

  Store outputs store inputs table lookup validates store table transforms diff patch merge
  Store reads integrity merged conflicts outputs rollback inputs version
  Store validates merged types Store StoreTable Conflict Resolution MergeResult

inputs load_table(path String, name String) StoreTable!
from
    db as Store = Store.store(path)!
    Store.table(db, name)!

Store-Backed Lookup Types¶

A [Lookup] type with runtime instead of where is backed by a StoreTable. The type definition declares the column schema; data is populated at runtime. See Store-Backed Lookup for the type system details.

  type Color:[Lookup] is String | Integer
    runtime

  Store outputs store inputs table validates store table
    types Store StoreTable

main()!
from
    db as Store = store("/tmp/demo")!
    colors as Color = table(db, "colors")!
    row as Color = Color(Red, "red", 0xFF0000)
    add(colors, row)
    color as Integer = colors:"red"
    console(f"{color}")

The table() call returns a StoreTable which is transparently typed as Color. The column schema (String, Integer) is initialized from the type definition when the table is first loaded. Row construction Color(Red, "red", 0xFF0000) takes the variant name as first argument, followed by values matching each column type. The colors:"red" lookup resolves column indices at compile time.