Enum NodeInner

pub enum NodeInner {
    Const(Const),
    Unary(Unary),
    Binary(Binary),
    Var(Var),
    Piecewise(Piecewise),
}

Concrete varieties of a node which together compose an AST.

Variants

Const(Const)

Some constant value, like a coefficient or offset.

Unary(Unary)

An operation which takes a single operand.

Binary(Binary)

An operation which takes two operands.

Var(Var)

Some unknown value.

Piecewise(Piecewise)

A piecewise function.

Implementations

impl NodeInner

pub fn new_const<V>(v: V) -> NodeInner

where V: Into<TyValue>,

Creates a new constant node with the given value.

pub fn new_var<S>(ident: S) -> NodeInner

where S: Into<String>,

Creates a new variable node with the given identifier.

pub fn as_const(&self) -> Option<&Const>

Returns a ref to the inner Const if this node is that variant.

pub fn as_unary(&self) -> Option<&Unary>

Returns a ref to the inner Unary if this node is that variant.

pub fn as_binary(&self) -> Option<&Binary>

Returns a ref to the inner Binary if this node is that variant.

pub fn as_var(&self) -> Option<&Var>

Returns a ref to the inner Var if this node is that variant.

pub fn pretty_str(&self, parent_precedence: Option<usize>) -> String

Returns a neatly-formatted string representation of the AST.

Trait Implementations

impl AstNode for NodeInner

fn returns(&self) -> Option<Ty>

Returns the type of the value this node yields.

fn descendant_types(&self) -> impl Iterator<Item = Option<Ty>>

Returns the types of the operands of this node.

fn finite_eval<C>(&self, ctx: &C) -> Result<TyValue, EvalError>

where C: EvalContext,

Attempts to evaluate the AST to a single finite value.

fn eval<C>( &self, ctx: &C, ) -> Result<Box<dyn Iterator<Item = Result<TyValue, EvalError>> + '_>, EvalError>

where C: EvalContext,

Evaluates all possible values of the AST.

fn eval_interval<C>( &self, ctx: &C, ) -> Result<Box<dyn Iterator<Item = Result<(TyValue, TyValue), EvalError>> + '_>, EvalError>

where C: EvalContextInterval,

Interval variant of AstNode::eval.

fn walk(&self, depth_first: bool, cb: &mut impl FnMut(&NodeInner) -> bool)

Recursively executes the given function on every node in the AST. The walk will end early if the given function returns false and the invocation was not depth first.

fn walk_mut( &mut self, depth_first: bool, cb: &mut impl FnMut(&mut NodeInner) -> bool, )

Recursively executes the given function on every node in the AST. The walk will end early if the given function returns false and the invocation was not depth first.

fn as_inner(&self) -> &NodeInner

Returns the concrete variant this AST node represents.

fn iter_children(&self) -> impl Iterator<Item = &NodeInner>

Iterates through the child nodes of this node.

fn get<I>(&self, i: I) -> Option<&NodeInner>

where I: Iterator<Item = usize>,

Returns the nested child described by the given sequence.

fn get_mut<I>(&mut self, i: I) -> Option<&mut NodeInner>

where I: Iterator<Item = usize>,

Returns the mutable NodeInner described by the given path sequence.

fn parsing_precedence(&self) -> Option<(bool, usize)>

Returns whether the operator is left-associative, and its precedence.

impl Clone for NodeInner

fn clone(&self) -> NodeInner

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for NodeInner

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

Formats the value using the given formatter.

impl Display for NodeInner

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

Formats the value using the given formatter.

impl From<Binary> for NodeInner

fn from(n: Binary) -> NodeInner

Converts to this type from the input type.

impl From<Const> for NodeInner

fn from(n: Const) -> NodeInner

Converts to this type from the input type.

impl From<Node> for NodeInner

fn from(n: Node) -> NodeInner

Converts to this type from the input type.

impl From<NodeInner> for Node

fn from(n: NodeInner) -> Node

Converts to this type from the input type.

impl From<Piecewise> for NodeInner

fn from(p: Piecewise) -> NodeInner

Converts to this type from the input type.

impl From<Unary> for NodeInner

fn from(n: Unary) -> NodeInner

Converts to this type from the input type.

impl From<Var> for NodeInner

fn from(n: Var) -> NodeInner

Converts to this type from the input type.

impl Hash for NodeInner

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for NodeInner

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

impl StructuralPartialEq for NodeInner