Struct CompileOptions 

pub struct CompileOptions {
    pub source_dir: Option<PathBuf>,
    pub lib_paths: Vec<PathBuf>,
    pub required_outputs: Vec<String>,
    pub strict: bool,
    pub context: String,
    pub cursor_limit: Option<u64>,
    pub ledger: Option<Arc<CompileLedger>>,
    pub resources: Option<ResourceScope>,
    pub engine: Engine,
    pub input_variance: InputVariance,
    pub inferred_externs: Vec<String>,
}

The options every entry point compiles under. A host that names none gets the defaults: no source directory, no library paths, every binding an output, lax typing, the default context label, no cursor limit, and the most compiled engine this build has.

strict refuses what lax compilation warns about, on every engine: an implicit type coercion, a config wire fed from a cycle-time source, a nondeterministic node no volatile output acknowledges, a binding nothing reads, an undeclared coordinate, and a positional module argument. It is also pragma strict at the program’s top scope (polydat_grammar.md §14): strict value checks, strict type checks, and strict name checking hold in the program and in every scope that inherits its pragmas, and a module body follows its own pragmas alone.

engine is a preference, and the only place a caller expresses one. Leaving it alone is the normative path: Engine::default is the most native form the build offers (native code with the jit feature, the closure tier without), so a host that never mentions the field still gets compiled code, and gets faster code for free when a build gains a tier. Naming an engine is for testing, measurement, and demonstration — a differential test that wants the interpreter as the reference, a bench that walks the tiers. A preference the build cannot realize is refused (crate::KernelError::Refused) rather than silently replaced, and every kernel reports what it actually runs through crate::Kernel::engine.

Fields

source_dir: Option<PathBuf>

The directory relative data-file paths resolve against.

lib_paths: Vec<PathBuf>

Library search paths, tried after the source directory and before the embedded standard library.

required_outputs: Vec<String>

The outputs to keep; every output when empty.

strict: bool

Whether to enforce strict validation, pragma strict at the program’s top scope included.

context: String

The diagnostic context label, such as a file name.

cursor_limit: Option<u64>

A limit on every cursor’s extent, if any.

ledger: Option<Arc<CompileLedger>>

The compile ledger to record this program tree in: a host that holds one charges the compile to it; None mints a fresh one, read back through the kernel’s ledger().

resources: Option<ResourceScope>

The resource scope of the program tree: a host that holds one, with or without an accessor installed, hands it here; None gives the tree a fresh, empty one, read back through the kernel’s resources() and installable there.

engine: Engine

The engine to build on. Defaults to Engine::default, the most native form this build has; see the type’s documentation for when to set it and what happens when it cannot be realized.

input_variance: InputVariance

What the compiler does with an input whose type the author did not declare (input_variance.md §4). The default, Fixed, makes the inferred type the input’s and refuses a write of another type.

inferred_externs: Vec<String>

Externs whose declared type the caller inferred rather than the author wrote: the ones a program synthesizer emitted, such as a scope builder’s result and write-through externs. They are open to input_variance as an auto-extern is (input_variance.md §3).

Trait Implementations

impl Clone for CompileOptions

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CompileOptions

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for CompileOptions

fn default() -> Self

Returns the “default value” for a type.