Enum Ast 

pub enum Ast {
    Num(f64),
    Var(String),
    BinOp(BinOp, Box<Ast>, Box<Ast>),
    UnaryOp(UnaryOp, Box<Ast>),
    Let {
        name: String,
        value: Box<Ast>,
        body: Box<Ast>,
    },
}

Abstract syntax tree node for expressions.

The AST represents the structure of a parsed expression. Use Expr::ast() to access the AST after parsing.

Variants

The available variants depend on enabled features:

• Always: Num, Var, BinOp, UnaryOp
• With func: Call
• With cond: Compare, And, Or, If

Example

use wick_core::{Expr, Ast, BinOp};

let expr = Expr::parse("2 + 3").unwrap();
match expr.ast() {
    Ast::BinOp(BinOp::Add, left, right) => {
        assert!(matches!(left.as_ref(), Ast::Num(2.0)));
        assert!(matches!(right.as_ref(), Ast::Num(3.0)));
    }
    _ => panic!("expected addition"),
}

Variants

Num(f64)

Numeric literal (e.g., 42, 3.14).

Var(String)

Variable reference, resolved at evaluation time.

BinOp(BinOp, Box<Ast>, Box<Ast>)

Binary operation: left op right.

UnaryOp(UnaryOp, Box<Ast>)

Unary operation: op operand.

Let

Local binding: let name = value; body.

Fields

name: String

value: Box<Ast>

body: Box<Ast>

Implementations

impl Ast

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

Returns the set of free variables referenced in this AST node.

Traverses the entire AST and collects all variable names.

Example

use wick_core::{Expr, Ast};

let expr = Expr::parse("sin(x) + y * z").unwrap();
let vars = expr.ast().free_vars();
assert!(vars.contains("x"));
assert!(vars.contains("y"));
assert!(vars.contains("z"));

Trait Implementations

impl Clone for Ast

fn clone(&self) -> Ast

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Ast

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

Formats the value using the given formatter.

impl Display for Ast

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

Formats the value using the given formatter.

impl PartialEq for Ast

fn eq(&self, other: &Ast) -> 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 Ast