Enum Value 

pub enum Value {
    Void,
    Scalar(f64),
    Matrix(Array2<f64>),
    Complex(f64, f64),
    Str(String),
    StringObj(String),
    Lambda(LambdaFn),
    Function {
        outputs: Vec<String>,
        params: Vec<String>,
        body_source: String,
        locals: IndexMap<String, Value>,
        doc: Option<String>,
    },
    Tuple(Vec<Value>),
    Cell(Vec<Value>),
    Struct(IndexMap<String, Value>),
    StructArray(Vec<IndexMap<String, Value>>),
}

A value held in the variable environment.

Variants

Void

No display value — returned by side-effectful functions like fprintf.

Scalar(f64)

A single real number.

Matrix(Array2<f64>)

A 2-D real matrix (row-major). Scalars are represented as 1×1 matrices only when produced by matrix operations; standalone numbers use Scalar.

Complex(f64, f64)

Complex number re + im*i.

Str(String)

Character array (single-quoted string). Represents a 1×N row of char values.

StringObj(String)

String object (double-quoted string).

Lambda(LambdaFn)

Anonymous function: @(params) expr. Stores a pre-compiled closure that captures the lexical environment at definition time.

Function

Named user-defined function: function [outputs] = name(params) ... end.

The body is stored as raw source text and re-parsed on each call. Named functions execute in an isolated scope (only params are visible, plus built-in constants i, j).

Fields

outputs: Vec<String>

Output variable names in declaration order (e.g. ["y"] for function y = f(x)).

params: Vec<String>

Parameter names in declaration order (e.g. ["x", "n"]).

body_source: String

Raw source text of the function body (text between function header and end).

locals: IndexMap<String, Value>

Local helper functions defined in the same function file (MATLAB-style scoping). Populated when a function file is sourced; empty for inline definitions.

doc: Option<String>

Documentation string extracted from %-prefixed lines immediately before the function keyword. None when no leading comment block is present.

Tuple(Vec<Value>)

Multiple return values from a multi-output function call (internal use).

Produced by calling a function with outputs.len() > 1. Consumed by Stmt::MultiAssign in exec.rs. Not directly user-visible.

Cell(Vec<Value>)

Heterogeneous 1-D container: each element may be any Value.

Created with {1, 'hello', [1 2 3]} syntax. Indexed with c{i} (1-based). 2-D cell arrays are deferred; all cells are flat Vec<Value> for now.

Struct(IndexMap<String, Value>)

Scalar struct: ordered field map, field names preserved in insertion order.

Created with s.field = val or struct('k', v, ...). Fields can hold any Value, including nested structs.

StructArray(Vec<IndexMap<String, Value>>)

1-D array of structs (all sharing the same field schema).

Created with s(i).field = val (1-based). Indexed with s(i) which returns a Value::Struct. s.field collects the field across all elements.

Implementations

impl Value

pub fn as_scalar(&self) -> Option<f64>

Returns the inner f64 if this value is a Value::Scalar, otherwise None.

Examples

use ccalc_engine::env::Value;

assert_eq!(Value::Scalar(3.14).as_scalar(), Some(3.14));
assert_eq!(Value::Void.as_scalar(), None);

Trait Implementations

impl Clone for Value

fn clone(&self) -> Value

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Value

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

Formats the value using the given formatter.

impl PartialEq for Value

fn eq(&self, other: &Value) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Value