Enum ExprKind 

#[non_exhaustive]
pub enum ExprKind {
    CoordinateMapFactor {
        factor: CoordinateMapFactor,
        source: Vec<NamePath>,
        at: Vec<(NamePath, Expr)>,
    },
    Pullback {
        value: Box<Expr>,
        source: Vec<NamePath>,
        at: Vec<(NamePath, Expr)>,
    },
    Evaluate {
        value: Box<Expr>,
        at: Vec<(NamePath, Expr)>,
        side: Option<BoundarySideSyntax>,
    },
    Partial {
        value: Box<Expr>,
        wrt: NamePath,
        holding: Vec<NamePath>,
    },
    Boolean(bool),
    Number(DecimalLiteral),
    Quantity {
        value: DecimalLiteral,
        unit: Box<Expr>,
    },
    Array(Vec<Expr>),
    Tuple(Vec<Expr>),
    Index {
        value: Box<Expr>,
        index: Box<Expr>,
    },
    Slice {
        value: Box<Expr>,
        lower: Box<Expr>,
        upper: Box<Expr>,
    },
    Member {
        value: Box<Expr>,
        member: String,
    },
    Name(String),
    Path(NamePath),
    BoundaryPortSelection {
        port: Box<NamePath>,
        selector: Box<BoundaryPortSelectorSyntax>,
    },
    Unary {
        op: UnaryOp,
        value: Box<Expr>,
    },
    Binary {
        op: BinaryOp,
        left: Box<Expr>,
        right: Box<Expr>,
    },
    Case {
        value: Box<Expr>,
        arms: Vec<CaseArm>,
    },
    Select {
        condition: Box<Expr>,
        then_value: Box<Expr>,
        else_value: Box<Expr>,
    },
    Reduction {
        operation: ReductionOp,
        binder: FamilyBinderSyntax,
        value: Box<Expr>,
    },
    Call {
        callee: NamePath,
        arguments: CallArguments,
    },
}

Recursive parser AST. Canonical residual storage is the lowered DAG.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

CoordinateMapFactor

Differential factor of an explicit map between ordered coordinates.

Fields

factor: CoordinateMapFactor

Signed Jacobian, volume scale, or orientation.

source: Vec<NamePath>

Complete source coordinate inventory.

at: Vec<(NamePath, Expr)>

Complete target coordinate expressions.

Pullback

Pull an invariant scalar along a map between exact coordinate supports.

Fields

value: Box<Expr>

Expression on the target support.

source: Vec<NamePath>

Complete source coordinate inventory.

at: Vec<(NamePath, Expr)>

Target coordinates paired with expressions on the source support.

Evaluate

Bind exact coordinate projections to dimensioned points, without choosing a reconstruction.

Fields

value: Box<Expr>

Analytic expression or represented Field to evaluate.

at: Vec<(NamePath, Expr)>

Exact coordinate bindings and their point expressions.

side: Option<BoundarySideSyntax>

Requested one-sided value for a one-dimensional discontinuous representation.

Partial

An explicit first partial with compile-time independent-input bindings.

Fields

value: Box<Expr>

Explicit expression; aliases retain their ordinary dependencies.

wrt: NamePath

Declared independent value or lexical operator formal.

holding: Vec<NamePath>

Additional held-fixed binding assertions, never runtime arguments.

Boolean(bool)

Boolean truth value, distinct from numeric literals.

Number(DecimalLiteral)

Exact decimal literal, interpreted in its required value-domain context.

Quantity

Numeric literal with an explicit input-unit expression.

Fields

value: DecimalLiteral

Exact decimal value before unit conversion.

unit: Box<Expr>

Unit-catalog expression, independent of value names and dimension aliases.

Array(Vec<Expr>)

Nonempty ordered channel-array elements; rectangularity is checked during lowering.

Tuple(Vec<Expr>)

Compile-time structural tuple; never implicitly a value array or tensor.

Index

Select one channel from a value; index legality is checked during lowering.

Fields

value: Box<Expr>

Value being indexed.

index: Box<Expr>

Authored index expression.

Slice

Nonempty immutable half-open channel slice with explicit static bounds.

Fields

value: Box<Expr>

Complete array value, never a spatial-axis slice.

lower: Box<Expr>

Inclusive nonnegative lower bound.

upper: Box<Expr>

Exclusive upper bound, no larger than the channel extent.

Member

Member of a statically selected indexed component occurrence.

Fields

value: Box<Expr>

member: String

Name(String)

Source identifier.

Path(NamePath)

Qualified lexical or instance-member name.

BoundaryPortSelection

One boundary-family Port selected by an exact boundary spelling.

Fields

port: Box<NamePath>

Port family path.

selector: Box<BoundaryPortSelectorSyntax>

Closed boundary selector.

Unary

Prefix operator.

Fields

op: UnaryOp

Operator.

value: Box<Expr>

Operand.

Binary

Infix operator.

Fields

op: BinaryOp

Operator.

left: Box<Expr>

Left operand.

right: Box<Expr>

Right operand.

Case

Exhaustive value selection over one nominal enumeration.

Fields

value: Box<Expr>

Value whose exact enum determines the required patterns.

arms: Vec<CaseArm>

Authored-order explicit tag arms; no wildcard or pattern binding.

Select

Lazy value selection; both branches remain authored expressions.

Fields

condition: Box<Expr>

Boolean scalar predicate.

then_value: Box<Expr>

Value selected when the predicate is true.

else_value: Box<Expr>

Value selected when the predicate is false.

Reduction

Ordered reduction over one nonempty bounded nominal index set.

Fields

operation: ReductionOp

Scalar reduction operation, evaluated in index-set order.

binder: FamilyBinderSyntax

Lexical member binding and exact set name.

value: Box<Expr>

Scalar expression evaluated for each member.

Call

Qualified named operator with one or more ordered arguments.

Fields

callee: NamePath

Structurally qualified operator name.

arguments: CallArguments

Nonempty ordered arguments.

Trait Implementations

§

impl Clone for ExprKind

Signature links:CloneExprKind

§

fn clone(&self) -> ExprKind

Signature links:cloneExprKind

Returns a duplicate of the value.

§

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

Signature links:unstableSourceclone_from

Performs copy-assignment from source.

§

impl Debug for ExprKind

Signature links:DebugExprKind

§

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

Signature links:fmtFormatterResult()Error

Formats the value using the given formatter.

§

impl PartialEq for ExprKind

Signature links:PartialEqExprKind

§

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

Signature links:eqExprKindbool

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

§

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

Signature links:unstableSourcene&Rhsbool

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

impl StructuralPartialEq for ExprKind