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 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,
    /* 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)

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.)

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 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 from a source directory, walking up parent directories Looks for a workspace Sigil.toml (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 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.