Struct Interpreter 

pub struct Interpreter {

    pub globals: Rc<RefCell<Environment>>,
    pub environment: Rc<RefCell<Environment>>,
    pub types: HashMap<String, TypeDef>,
    pub variant_constructors: HashMap<String, (String, String, usize)>,
    pub default_structs: HashMap<String, StructDef>,
    pub output: Vec<String>,
    pub program_args: Option<Vec<String>>,
    pub current_module: Option<String>,
    pub current_self_type: Option<String>,
    pub generic_type_bindings: HashMap<String, String>,
    pub current_source_dir: Option<String>,
    pub loaded_crates: HashSet<String>,
    pub loading_crates: HashSet<String>,
    pub project_root: Option<PathBuf>,
    pub workspace_members: HashMap<String, PathBuf>,
    pub drop_types: HashSet<String>,
    pub linear_state: LinearTypeState,
    pub mutable_vars: RefCell<HashSet<String>>,
    pub var_types: RefCell<HashMap<String, (String, Vec<String>)>>,
    pub type_context: TypeConstructionContext,
    pub ir_functions: RefCell<Vec<Value>>,
    pub ir_traits: RefCell<Vec<Value>>,
    pub ir_modules: RefCell<Vec<Value>>,
    pub ir_constants: RefCell<Vec<Value>>,
    pub ir_impls: RefCell<Vec<Value>>,
    pub source_code: RefCell<String>,
    pub user_macros: RefCell<HashMap<String, (Vec<String>, String, HashMap<String, String>)>>,
    pub source_text: Option<String>,
    pub function_spans: HashMap<String, Span>,
    pub trait_defs: Vec<TraitDef>,
    pub impl_blocks: Vec<ImplBlock>,
    pub const_defs: Vec<(String, Span)>,
    pub crate_modules: HashSet<String>,
    pub crate_name: Option<String>,
    pub crate_alias: Option<String>,
    pub const_generic_params: HashMap<String, Vec<String>>,
    pub const_generic_deferred_consts: HashMap<String, Expr>,
    /* private fields */
}

The Sigil interpreter

Fields

globals: Rc<RefCell<Environment>>

Global environment

environment: Rc<RefCell<Environment>>

Current environment

types: HashMap<String, TypeDef>

Type definitions

variant_constructors: HashMap<String, (String, String, usize)>

Variant constructors: qualified_name -> (enum_name, variant_name, arity)

default_structs: HashMap<String, StructDef>

Structs with #[derive(Default)]

output: Vec<String>

Output buffer (for testing)

program_args: Option<Vec<String>>

Program arguments (overrides env::args when set)

current_module: Option<String>

Current module prefix for registering definitions

current_self_type: Option<String>

Current Self type (when inside an impl block)

generic_type_bindings: HashMap<String, String>

Generic type parameter bindings (e.g., T -> “F16” during dtype_info·() call)

current_source_dir: Option<String>

Current source directory for resolving relative module paths

loaded_crates: HashSet<String>

Loaded crates registry (crate_name -> true if loaded)

loading_crates: HashSet<String>

Crates currently being loaded (for circular dependency detection)

project_root: Option<PathBuf>

Project root directory (where Sigil.toml is located)

workspace_members: HashMap<String, PathBuf>

Workspace members: crate_name -> relative path from project root

drop_types: HashSet<String>

Types that implement Drop trait - call drop() when they go out of scope

linear_state: LinearTypeState

Linear type tracking state (for no-cloning theorem enforcement)

mutable_vars: RefCell<HashSet<String>>

Variables declared as mutable (let mut)

var_types: RefCell<HashMap<String, (String, Vec<String>)>>

Variable type annotations (for generic type checking on Vec, etc.)

type_context: TypeConstructionContext

Type-directed construction context (for Tensor, Linear<N, M>, etc.)

ir_functions: RefCell<Vec<Value>>

Function definitions for IR export (with span info)

ir_traits: RefCell<Vec<Value>>

Trait definitions for IR export (trait_name -> TraitDef)

ir_modules: RefCell<Vec<Value>>

Module definitions for IR export

ir_constants: RefCell<Vec<Value>>

Constant definitions for IR export

ir_impls: RefCell<Vec<Value>>

Impl block definitions for IR export

source_code: RefCell<String>

Source code for span-to-line conversion

user_macros: RefCell<HashMap<String, (Vec<String>, String, HashMap<String, String>)>>

User-defined macro registry: name -> (params, body_tokens) params is a Vec of parameter names (e.g., [“n”] for macro foo($n) {…}) body_tokens is the raw body string to be parsed and evaluated field_map maps struct field names to param names for named patterns (e.g., { key: $param:expr })

source_text: Option<String>

Source text for span-to-line conversion (used by __export_ir)

function_spans: HashMap<String, Span>

Function spans for IR export (function_name -> span)

trait_defs: Vec<TraitDef>

Raw trait definitions for IR export

impl_blocks: Vec<ImplBlock>

Raw impl blocks for IR export

const_defs: Vec<(String, Span)>

Constant definitions for IR export (const_name, span)

crate_modules: HashSet<String>

Modules in current crate for IR export

crate_name: Option<String>

Current crate name for module resolution

crate_alias: Option<String>

Alias for current crate (e.g., “tome” for tome commands)

const_generic_params: HashMap<String, Vec<String>>

Maps type name → const generic parameter names e.g., “Shape1” → [“N”], “Shape2” → [“M”, “N”]

const_generic_deferred_consts: HashMap<String, Expr>

Deferred associated constants for const-generic impl blocks Maps “TypeName·ConstName” → unevaluated AST expression

Implementations

impl Interpreter

pub fn new() -> Self

pub fn set_program_args(&mut self, args: Vec<String>)

Set program arguments (overrides env::args for the running program)

pub fn set_current_module(&mut self, module: Option<String>)

Set current module for registering definitions (module name, not file stem)

pub fn set_current_source_dir(&mut self, dir: Option<String>)

Set current source directory for resolving relative module paths

pub fn set_source_dir(&mut self, dir: String)

Set source directory for the current program (for module resolution) This is the directory containing the entry point file

pub fn set_crate_name(&mut self, name: String)

Set the current crate name (for module prefixing)

pub fn set_crate_alias(&mut self, alias: String)

Set an alias for the current crate (e.g., “tome” for tome commands)

pub fn register_module(&mut self, name: String)

Register a module in the current crate for IR export

pub fn get_program_args(&self) -> Vec<String>

Get program arguments (uses overridden args if set, otherwise env::args)

pub fn discover_project(&mut self, source_dir: &str) -> Result<(), RuntimeError>

Find and parse Sigil.toml/Grimoire.toml from a source directory, walking up parent directories Looks for a workspace config (one with [workspace] section and members)

pub fn load_crate(&mut self, crate_name: &str) -> Result<bool, RuntimeError>

Load an external crate by name

pub fn set_source_code(&mut self, source: String)

Set the source code for span-to-line conversion

pub fn execute(&mut self, file: &SourceFile) -> Result<Value, RuntimeError>

Execute a source file

pub fn execute_definitions( &mut self, file: &SourceFile, ) -> Result<Value, RuntimeError>

Execute a file but only register definitions, don’t auto-call main. Use this when loading files as part of a multi-file workspace.

pub fn evaluate(&mut self, expr: &Expr) -> Result<Value, RuntimeError>

Evaluate an expression

pub fn call_function( &mut self, func: &Function, args: Vec<Value>, ) -> Result<Value, RuntimeError>

pub fn await_value(&mut self, value: Value) -> Result<Value, RuntimeError>

Await a value - if it’s a future, resolve it; otherwise return as-is

pub fn make_future_immediate(&self, value: Value) -> Value

Create a new future from a value

pub fn make_future_lazy(&self, func: Rc<Function>, args: Vec<Value>) -> Value

Create a pending future with lazy computation

pub fn make_future_timer(&self, duration: Duration) -> Value

Create a timer future

pub fn call_function_by_name( &mut self, name: &str, args: Vec<Value>, ) -> Result<Value, RuntimeError>

Call a function by name from the environment

Trait Implementations

impl Default for Interpreter

fn default() -> Self

Returns the “default value” for a type.