Struct Expr 

pub struct Expr { /* private fields */ }

A parsed expression that can be evaluated or inspected.

Expr is the main entry point for the expression language. Parse a string with Expr::parse(), then either evaluate it with Expr::eval() or inspect the AST with Expr::ast().

Example

use wick_core::Expr;
use std::collections::HashMap;

// Parse an expression
let expr = Expr::parse("x^2 + 2*x + 1").unwrap();

// Evaluate with different variable values
let mut vars = HashMap::new();
vars.insert("x".to_string(), 3.0);
assert_eq!(expr.eval(&vars).unwrap(), 16.0);  // 9 + 6 + 1

vars.insert("x".to_string(), 0.0);
assert_eq!(expr.eval(&vars).unwrap(), 1.0);   // 0 + 0 + 1

Implementations

impl Expr

pub fn parse(input: &str) -> Result<Self, ParseError>

Parses an expression from a string.

Errors

Returns ParseError if the input is not a valid expression:

• ParseError::UnexpectedChar for invalid characters
• ParseError::UnexpectedEnd for incomplete expressions
• ParseError::UnexpectedToken for syntax errors
• ParseError::InvalidNumber for malformed numeric literals

Example

use wick_core::{Expr, ParseError};

// Valid expression
assert!(Expr::parse("1 + 2").is_ok());

// Invalid: unexpected character
assert!(matches!(Expr::parse("1 @ 2"), Err(ParseError::UnexpectedChar('@'))));

// Invalid: incomplete expression
assert!(matches!(Expr::parse("1 +"), Err(ParseError::UnexpectedEnd)));

pub fn ast(&self) -> &Ast

Returns a reference to the parsed AST.

Use this to inspect the expression structure or to compile it to a different target (WGSL, Lua, etc.).

pub fn free_vars(&self) -> HashSet<&str>

Returns the set of free variables referenced in the expression.

This is useful for determining which variables need to be provided at evaluation time, or for building dependency graphs.

Example

use wick_core::Expr;

let expr = Expr::parse("x * 2 + y").unwrap();
let vars = expr.free_vars();
assert!(vars.contains("x"));
assert!(vars.contains("y"));
assert_eq!(vars.len(), 2);

pub fn eval(&self, vars: &HashMap<String, f32>) -> Result<f32, EvalError>

Evaluates the expression with the given variables.

This version is available when the func feature is disabled.

Errors

Returns EvalError::UnknownVariable if a variable is not in vars.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.