API Reference roux v#0.2.2

A framework for building incremental mix compilers.

A content-addressed store on disk, safe to share between OS processes: large values kept by digest, an action cache, verifying traces, and scratch directories, with a garbage collector that never takes what a reader is using.

Raised by Roux.Blob.open!/1 for a directory holding a store of another layout: its FORMAT file names another version.

Raised by Roux.Blob.fetch!/2 for a digest the store holds no entry for: never written, collected, or found corrupt.

Verifying traces: a value kept with what computing it observed, reused only while every observation still holds.

Raised by Roux.Blob.open!/1 (and returned by Roux.Blob.open/1) for a store whose files another user could have written: a root, or its FORMAT file, that the current OS user does not own or that is writable by its group or by everyone.

Process-based cancellation of in-flight query computations.

The code a computation runs, named by a digest: what a query's code version is made of (Roux.Query's code: option).

What a computation actually runs, for a test that checks a closure (Roux.Code.closure/2) against it: every module the computation executes must be in the closure of the roots its code version is made of, or an edit to that module would leave stale results in place.

Detects cycles in the query dependency graph at runtime.

Raised when a cycle is detected in the query dependency graph.

Central handle for all framework state.

Preserves ETS tables across Roux.Database.TableOwner crashes.

Supervises the ETS table ownership processes.

Owns all framework ETS tables during normal operation.

Tracked structs with identity that persists across revisions.

Garbage collection of stale memo entries and dead entities.

External values that form the leaves of the dependency graph.

Describes an input: its name and how often it changes (durability).

Raised when reading an input key that has never been set.

Bidirectional mapping from values to unique integer IDs.

Raised when attempting to resolve an intern ID that does not exist.

Convention layer defining what it means to be a "language" in the Roux ecosystem.

Mix compiler integration for Roux languages.

Generic LSP server that delegates IDE features to query-based language implementations. Built on gen_lsp.

Manifest read/write for cross-VM incremental compilation.

Memo table: the cache layer that stores query results.

A single memo table entry recording a cached query result.

Derived query definition and the defquery macro.

Describes a derived query: its name, the module and function that implement it, and any additional options.

Raised when registering a module of queries compiled against a roux whose definition format is not this one's (Roux.Query.format/0): what it generated is not what this roux reads, so none of it runs. format is the module's (nil for a roux older than the stamp: 0.1 and the 0.2 development builds before it), expected this roux's.

Records which queries of a database executed, were served from the memo table, or came back unchanged (early cutoff): what an edit made a graph recompute, for tests that assert the exact recompute set and for harnesses that report it.

Global revision counter and per-durability-level change tracking.

The query execution engine.

Threaded context passed through query execution.

A database's life across runs: opened from the last run's manifest, committed back to it, closed.

Files as inputs: sync/5 brings an input keyed by file up to date with what is on disk, reading only what may have changed.

A value computed from files, kept for as long as the files' stat stamps say they have not changed: memo/4.

Structured event definitions for observability and debugging.

A blob store on a model file system (Roux.Test.ModelFS), for the Concuerror scenarios of test/concurrency/blob_test.ex: the store's directories made, the calling process entered as model OS process "1".

Loops run in peer VMs (separate OS processes) against one store, for Roux.Blob.ReplaceTest and Roux.Blob.VersionsTest: each runs for ms milliseconds and reports what it saw.

A database holding a fan-out over {:upper, "a"}, {:upper, "b"} or both, as a run left it, and the input of "a" changed since: the group is stale. Written directly rather than computed, to keep the scenarios Concuerror explores short (test/concurrency/group_test.ex).

A file system in an ETS table, for the Concuerror scenarios of the blob store (test/concurrency/blob_test.ex): Roux.Blob.IO answers a process's operations from it once the process enter/2s it, so the store's own code runs over a file system whose every step is a scheduling point Concuerror can interleave.

Holds a race in Roux.Blob open: at the file operations a gate names, it runs an action after the operation completed and before the store sees its result. A check-then-act race in the store then happens on every run: the gate is the other process, acting between the check and the act.

Determines whether a cached memo entry is still valid.

Mix compiler task for Roux languages.

Runs Concuerror tests for exhaustive scheduler interleaving exploration.

Generates a Zed editor extension for Roux-powered languages.

Starts the Roux LSP server over stdio.