Struct Rule 

pub struct Rule { /* private fields */ }

Single AIM rule: identifier, typedef, expression, and value.

Constructors perform identifier-based classification and optional static folding of constant expressions into value.

Implementations

impl Rule

pub fn new( identifier: Arc<str>, typedef: Typedef, expression: Expression, value: Arc<Value>, ) -> Self

Create a new Rule with the given components

Parameters

• identifier: The rule’s unique identifier
• typedef: The type definition for the rule
• expression: The expression that computes the rule’s value
• value: The initial value of the rule

Returns

A new Rule instance with appropriate flags set based on the identifier

Notes

• Automatically performs static evaluation of expressions when possible
• Sets flags based on identifier format (modifier/assignment)

pub fn convert( identifier: Arc<str>, typedef: Arc<str>, formula: Arc<str>, value: Arc<str>, ) -> Self

pub fn parse(&self, input: &str) -> Self

Create a new Rule by parsing operands from a string

This constructor parses the expression/value portion of a rule definition based on the rule’s type definition and assignment status.

Parameters

• input: The string containing the rule’s operands
• identifier: The rule’s identifier
• typedef: The rule’s type definition
• is_assignment: Whether this is an assignment rule

Returns

A new Rule instance with parsed expression and value

Errors

Returns error expressions for incomplete or malformed input

pub fn is_empty(&self) -> bool

Check if the rule is completely empty (no expression and no value)

pub fn is_error(&self) -> bool

Check if the rule contains any errors

pub fn has_expression(&self) -> bool

Check if the rule has a non-empty expression

pub fn identifier(&self) -> Arc<str>

Get the rule’s identifier

pub fn ucid(&self) -> Arc<str>

Get the uppercase form of the identifier.

Non-alphabetic characters (such as _ or digits) are preserved; only alphabetic characters are converted to uppercase.

pub fn lcid(&self) -> Arc<str>

Get the lowercase form of the identifier.

Non-alphabetic characters (such as _ or digits) are preserved; only alphabetic characters are converted to lowercase.

pub fn set_identifier(&mut self, identifier: Arc<str>) -> bool

Set a new identifier for the rule

Updates the identifier and automatically adjusts flags based on the new identifier format

pub fn is_modifier(&self) -> bool

Check if this is a modifier rule (all uppercase identifier)

pub fn is_assignment(&self) -> bool

Check if this is an assignment rule (identifier starts with underscore)

pub fn typedef(&self) -> &Typedef

Get the rule’s type definition

pub fn set_typedef(&mut self, typedef: Typedef) -> bool

Set a new type definition for the rule

Resets the value to empty and marks the rule as touched

Returns

true if the rule changed, else false

pub fn expression(&self) -> &Expression

Get the rule’s expression

pub fn set_expression(&mut self, expression: Expression) -> bool

Set a new expression for the rule

Marks the rule as touched if the expression differs from the current one

Returns

true if the rule changed, else false

pub fn value(&self) -> Arc<Value>

Get the rule’s current value

pub fn set_value(&mut self, value: Arc<Value>) -> Result<()>

Set the rule’s value

Parameters

The value to set. Must match typedef unless empty or error.

This function does not set special typedef values.

Returns

Ok(()) if the value matches the rule’s type, Err otherwise

pub fn rename_node(&self, identifier: Arc<str>) -> Result<Self>

pub fn is_format(&self) -> bool

Check if this is a format rule

pub fn is_eval(&self) -> bool

Check if this is an evaluation rule

pub fn set_pass(&mut self) -> Result<()>

Mark an evaluation rule as passing

Only affects rules with Eval type definitions

Returns

true if the rule changed, else false

pub fn set_fail(&mut self) -> Result<()>

Mark an evaluation rule as failing

Only affects rules with Eval type definitions

Returns

true if the rule changed, else false

pub fn is_node(&self) -> bool

Check if this is a node rule

pub fn get_node(&self) -> Option<Node>

Get the node from this rule if it is a node rule

Returns

Some(Node) if this is a node rule with a node value, None otherwise

pub fn get_instance(&self) -> Option<Instance>

pub fn print(&self, writer: &mut Writer)

Write the rule’s complete definition to a writer

Outputs the rule in AIM format: identifier: typedef = expression $value

Trait Implementations

impl Clone for Rule

fn clone(&self) -> Rule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Rule

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

Formats the value using the given formatter.

impl Display for Rule

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

Display the rule’s content (expression or value) for user-facing output

impl ExpressionLike for Rule

fn evaluate(&self, context: &mut dyn ContextLike) -> Result<Arc<Value>>

Evaluate the rule’s expression and return a Value, handling errors gracefully, or if empty, return the rule’s value.

• If expression is non-empty, this evaluates the expression.
• If expression is empty, this returns a clone of the stored value.

This method evaluates the rule expression in the given context.

• If the expression is empty, returns the stored value.
• If the expression is non-empty, delegates to the underlying ExpressionLike::evaluate implementation.

Arguments

• context - The evaluation context providing variable values and function implementations

Returns

Returns a Value representing the result of evaluation. If evaluation succeeds, returns the computed value. If evaluation fails, returns an Errata value containing error information.

See Also

• ExpressionLike::evaluate - The underlying evaluation method that returns Result
• Value - The result type returned by evaluation

fn to_formula(&self) -> String

Return the formula-string representation (round-trippable by the parser).

impl PartialEq for Rule

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

fn write(&self, writer: &mut Writer)

Serialize this expression with the given Writer.

fn to_stringized(&self) -> String

Return a string representation (raw unsafe output).

fn to_sanitized(&self) -> String

Return a sanitized string representation (escaped for safe output).

fn to_expressionized(&self) -> String

Return a sanitized string representation (escaped for safe output).

impl StructuralPartialEq for Rule