Enum Relational

pub enum Relational {
    Less(Additive, Additive),
    LessOrEqual(Additive, Additive),
    Greater(Additive, Additive),
    GreaterOrEqual(Additive, Additive),
    Primary(Box<Primary>),
}

Represents a relational expression in the AIMX grammar.

Relational expressions perform comparisons between values using operators like less than, greater than, less than or equal, and greater than or equal. These expressions form part of the expression hierarchy and can be used in conditional statements and boolean logic.

The Relational enum uses AST flattening optimization, where it includes variants for lower-precedence expressions. This allows efficient evaluation without deep recursion.

Variants

Comparison Variants

• Less - Less than comparison: left < right
• LessOrEqual - Less than or equal comparison: left <= right
• Greater - Greater than comparison: left > right
• GreaterOrEqual - Greater than or equal comparison: left >= right

AST Flattening Variants

• Primary - Flattened primary expression (optimization)

Examples

use aimx::expressions::relational::{Relational, parse_relational};
use aimx::{ExpressionLike, Context, Value};
 
// Parse and evaluate a relational expression
let (_, expr) = parse_relational("5 < 10").unwrap();
let mut context = Context::new();
let result = expr.evaluate(&mut context).unwrap();
assert_eq!(result.to_string(), "true");

Variants

Less(Additive, Additive)

Less than comparison: left < right

LessOrEqual(Additive, Additive)

Less than or equal comparison: left <= right

Greater(Additive, Additive)

Greater than comparison: left > right

GreaterOrEqual(Additive, Additive)

Greater than or equal comparison: left >= right

Primary(Box<Primary>)

Primary flattened AST optimization

Trait Implementations

impl Clone for Relational

fn clone(&self) -> Relational

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Relational

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

Formats the value using the given formatter.

impl Display for Relational

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

Formats the value using the given formatter.

impl ExpressionLike for Relational

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

Evaluates the relational expression within the given context.

This method performs type-safe comparisons between the left and right operands of the relational expression. It uses type promotion to ensure compatible comparisons and returns a boolean result.

Type Promotion Rules

The evaluation uses evaluate_and_promote to ensure both operands are of comparable types. Supported type comparisons include:

• Numbers: Standard numeric comparison
• Booleans: false (0) < true (1)
• Dates: Chronological order comparison
• Text: Lexicographical comparison
• Tasks: Status-based comparison (converted to numbers)

Errors

Returns an error if:

• The operands are not of comparable types
• Type promotion fails
• Evaluation of sub-expressions fails

Examples

use aimx::expressions::relational::{Relational, parse_relational};
use aimx::{ExpressionLike, Context};
 
let (_, expr) = parse_relational("5 < 10").unwrap();
let mut context = Context::new();
let result = expr.evaluate(&mut context).unwrap();
assert_eq!(result.to_string(), "true");

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

Write this expression to the provided writer.

fn to_sanitized(&self) -> String

Convert this expression to a sanitized string representation.

fn to_formula(&self) -> String

Convert this expression to a formula string representation.

impl PartialEq for Relational

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