Enum Primary

pub enum Primary {
    Literal(Literal),
    Reference(Reference),
    Parentheses(Expression),
    Postfix(Postfix),
    Unary(Unary),
    Multiplicative(Multiplicative),
    Additive(Additive),
    Relational(Relational),
    Equality(Equality),
    LogicalAnd(LogicalAnd),
    LogicalOr(LogicalOr),
    Conditional(Conditional),
    Closure(Closure),
}

Represents a primary expression in the AIMX grammar.

Primary expressions are the fundamental building blocks of expressions in the AIMX language. They include literal values, variable references, and parenthesized expressions. Primary expressions form the base of the expression hierarchy, with other expression types building upon them.

The Primary enum uses AST flattening optimization, where it includes variants for all higher-level expression types. This allows expressions that consist solely of primary components to be evaluated more efficiently without deep recursion through the expression hierarchy.

Variants

• Literal - A literal value (Bool, Date, Number, Task, Text, or Empty)
• Reference - A variable or field reference
• Parentheses - A parenthesized expression
• Postfix - Postfix operations (method calls, indexing, function calls)
• Unary - Unary operations (logical NOT, arithmetic negation, casts)
• Multiplicative - Multiplicative operations (*, /, %)
• Additive - Additive operations (+, -)
• Relational - Relational operations (<, <=, >, >=)
• Equality - Equality operations (=, !=)
• LogicalAnd - Logical AND operations (&, &&)
• LogicalOr - Logical OR operations (|, ||)
• Conditional - Conditional operations (?, :)
• Closure - Closure operations (=>)

AST Flattening

The flattened variants (Postfix through Closure) are populated during parsing when an expression contains higher-level operators but can be represented efficiently within the Primary enum. This optimization reduces AST depth and improves evaluation performance.

Examples

use aimx::{Primary};
use aimx::expressions::{parse_primary};
use aimx::Literal;

// Parse a literal expression
let (_, primary) = parse_primary("42").unwrap();
assert!(matches!(primary, Primary::Literal(Literal::Number(_))));

// Parse a reference expression
let (_, primary) = parse_primary("variable_name").unwrap();
assert!(matches!(primary, Primary::Reference(_)));

// Parse a parenthesized expression
let (_, primary) = parse_primary("(1 + 2)").unwrap();
assert!(matches!(primary, Primary::Parentheses(_)));

See Also

• crate::expressions::parse_primary - Function to parse primary expressions from text
• ExpressionLike - Trait for expression evaluation
• Literal - Literal value representation
• Reference - Variable reference representation

Variants

Literal(Literal)

A literal value such as a number, text string, boolean, date, or task

Reference(Reference)

A variable or field reference

Parentheses(Expression)

A parenthesized expression

Postfix(Postfix)

Unary(Unary)

Multiplicative(Multiplicative)

Additive(Additive)

Relational(Relational)

Equality(Equality)

LogicalAnd(LogicalAnd)

LogicalOr(LogicalOr)

Conditional(Conditional)

Closure(Closure)

Implementations

impl Primary

pub fn is_literal(&self) -> bool

Check if this primary expression is a literal value.

Returns true if this Primary variant is Literal, false otherwise.

Examples

use aimx::{Primary};
use aimx::expressions::{parse_primary};
use aimx::Literal;

let (_, literal) = parse_primary("42").unwrap();
assert!(literal.is_literal());

let (_, reference) = parse_primary("variable").unwrap();
assert!(!reference.is_literal());

pub fn is_reference(&self) -> bool

Check if this primary expression is a variable or field reference.

Returns true if this Primary variant is Reference, false otherwise.

Examples

use aimx::{Primary};
use aimx::expressions::{parse_primary};

let (_, reference) = parse_primary("variable").unwrap();
assert!(reference.is_reference());

let (_, literal) = parse_primary("42").unwrap();
assert!(!literal.is_reference());

Trait Implementations

impl Clone for Primary

fn clone(&self) -> Primary

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Primary

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

Formats the value using the given formatter.

impl Display for Primary

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

Format this primary expression as a string.

This implementation delegates to the write method using a string-based writer, producing a human-readable representation of the expression.

Arguments

• f - The formatter to write the string representation to

Returns

Returns fmt::Result indicating success or failure of formatting.

impl ExpressionLike for Primary

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

Evaluate this primary expression within the given context.

This method recursively evaluates the primary expression, delegating to the appropriate evaluation methods for each variant. The evaluation follows the AST flattening optimization where higher-level expression variants are evaluated directly without recursion through the expression hierarchy.

Arguments

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

Returns

Returns a Result<Value> containing the evaluated value if successful, or an error if evaluation fails.

Evaluation Strategy

• Literal expressions return their literal value
• Reference expressions look up the variable in the context
• Parentheses expressions evaluate the inner expression
• Flattened variants delegate to their respective evaluation methods

Examples

use aimx::{Primary};
use aimx::expressions::{parse_primary};
use aimx::{ContextLike, ExpressionLike, Literal};

let mut context = aimx::Context::new();
 
// Evaluate a literal
let primary = Primary::Literal(Literal::Number(42.0));
let result = primary.evaluate(&mut context).unwrap();
assert_eq!(result.to_string(), "42");

See Also

• ExpressionLike - The trait being implemented
• Value - The result type returned by evaluation
• ContextLike - The context trait for evaluation

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

Write this primary expression to a Writer for formatting.

This method recursively writes the primary expression to the provided writer, producing a formatted representation suitable for display or serialization.

Arguments

• writer - The writer to write the formatted expression to

Writing Strategy

• Literal expressions write their literal representation
• Reference expressions write the reference path
• Parentheses expressions write parentheses around the inner expression
• Flattened variants delegate to their respective write methods

fn to_sanitized(&self) -> String

Convert this primary expression to a sanitized string representation.

Sanitized expressions are suitable for display purposes and may omit certain implementation details or sensitive information.

Returns

Returns a String containing the sanitized expression representation.

fn to_formula(&self) -> String

Convert this primary expression to its original formula representation.

The formula representation attempts to reconstruct the original expression text as it was parsed, suitable for use in formulas or serialization.

Returns

Returns a String containing the formula representation.

impl PartialEq for Primary

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