Enum NormalFormKind 

pub enum NormalFormKind {
    Leaf(LeafKind),
    Sum(Vec<ArithmeticTerm>),
    Product(Vec<ArithmeticTerm>),
    Subtract(NormalFormId, NormalFormId),
    Divide(NormalFormId, NormalFormId),
    Power(NormalFormId, NormalFormId),
    Modulo(NormalFormId, NormalFormId),
    Negate(NormalFormId),
    Reciprocal(NormalFormId),
    Comparison(NormalFormId, ComparisonComputation, NormalFormId),
    Logical(LogicalConnective, Vec<NormalFormId>),
    Not(NormalFormId),
    MathOp(MathematicalComputation, NormalFormId),
    StepRounding(RoundingMode, NormalFormId, Option<NormalFormId>),
    UnitConversion(NormalFormId, SemanticConversionTarget),
    Veto(VetoExpression),
    DateRelative(DateRelativeKind, NormalFormId),
    DateCalendar(DateCalendarKind, CalendarPeriodUnit, NormalFormId),
    RangeLiteral(NormalFormId, NormalFormId),
    PastFutureRange(DateRelativeKind, NormalFormId),
    RangeContainment(NormalFormId, NormalFormId),
    RangeBound(RangeBound, NormalFormId),
    ResultIsVeto(NormalFormId),
    Now,
    Piecewise(Vec<(NormalFormId, NormalFormId)>),
    OrderedDispatch {
        scrutinee: NormalFormId,
        boundaries: Arc<[DispatchKey]>,
        regions: Vec<DispatchRegion>,
    },
    SpecMember {
        base: NormalFormId,
        path: Vec<String>,
        name: String,
        row: RowRead,
    },
    RowField {
        level: u32,
        identity: SpecIdentity,
        end: RowEnd,
        qualifier: Option<Vec<String>>,
    },
    ListCommand {
        list: NormalFormId,
        op: NormalFormListOp,
        args: Vec<NormalFormId>,
        row_level: Option<u32>,
    },
}

Algebraic structure only. Children are NormalFormId. Hash/Eq drive cons — no source spans or rule-ref identity here (those live on NormalForm).

Variants

Leaf(LeafKind)

Sum(Vec<ArithmeticTerm>)

Product(Vec<ArithmeticTerm>)

Subtract(NormalFormId, NormalFormId)

Divide(NormalFormId, NormalFormId)

Power(NormalFormId, NormalFormId)

Modulo(NormalFormId, NormalFormId)

Negate(NormalFormId)

Reciprocal(NormalFormId)

Comparison(NormalFormId, ComparisonComputation, NormalFormId)

Logical(LogicalConnective, Vec<NormalFormId>)

Logical operands in source order.

Not(NormalFormId)

MathOp(MathematicalComputation, NormalFormId)

StepRounding(RoundingMode, NormalFormId, Option<NormalFormId>)

operand -> round or operand -> round step.

UnitConversion(NormalFormId, SemanticConversionTarget)

Veto(VetoExpression)

DateRelative(DateRelativeKind, NormalFormId)

DateCalendar(DateCalendarKind, CalendarPeriodUnit, NormalFormId)

RangeLiteral(NormalFormId, NormalFormId)

PastFutureRange(DateRelativeKind, NormalFormId)

RangeContainment(NormalFormId, NormalFormId)

RangeBound(RangeBound, NormalFormId)

ResultIsVeto(NormalFormId)

Now

Piecewise(Vec<(NormalFormId, NormalFormId)>)

OrderedDispatch

A Self::Piecewise over one scrutinee, decided by binary search instead of a linear arm scan. Built by [ordered_dispatch], which always records the pre-image as origin, so explanation keeps reading the Piecewise.

Fields

scrutinee: NormalFormId

boundaries: Arc<[DispatchKey]>

Sorted, deduplicated, all of one DispatchKey class. Shared so plan extract / rebuild clones are a refcount bump.

regions: Vec<DispatchRegion>

Exactly [region_count] entries; see [crate::planning::ordered_dispatch].

SpecMember

Read member path.name of the row base yields, in that row’s context.

Fields

base: NormalFormId

path: Vec<String>

name: String

row: RowRead

RowField

Field end of the current row of the instance-list command at level (0 = outermost), read through the template plan of identity.

Fields

level: u32

identity: SpecIdentity

end: RowEnd

qualifier: Option<Vec<String>>

Written list qualifier, preserved for explanation display. None for bare refs.

ListCommand

row_level is set when argument cells read the current list row at that level, through LeafKind::RowValue or Self::RowField.

Fields

list: NormalFormId

op: NormalFormListOp

args: Vec<NormalFormId>

row_level: Option<u32>

Implementations

impl NormalFormKind

pub fn for_each_child(&self, f: impl FnMut(NormalFormId))

Calls f on each child cell id in evaluation order. Piecewise yields cond, body per arm from index 0; OrderedDispatch yields the scrutinee then every region body.

pub fn children(&self) -> Vec<NormalFormId>

Child cell ids in Self::for_each_child order.

Trait Implementations

impl Clone for NormalFormKind

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for NormalFormKind

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

Formats the value using the given formatter.

impl Eq for NormalFormKind

impl Hash for NormalFormKind

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

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 NormalFormKind

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for NormalFormKind