Enum Equality

pub enum Equality {
    Equal(Relational, Relational),
    NotEqual(Relational, Relational),
    Primary(Box<Primary>),
}

An equality expression node in the abstract syntax tree.

Represents an equality comparison (=, !=) or a lower-precedence expression that has been flattened in the AST. This enum is part of the AIMX expression hierarchy and implements the ExpressionLike trait.

AST Flattening

The Primary variant represents an optimization where expressions that don’t contain equality operators are flattened to reduce AST depth and improve evaluation performance. This flattening occurs during parsing when an expression doesn’t contain any equality operators.

Variants

Equal(Relational, Relational)

Represents an equality comparison using the = or == operator. The operands are Relational expressions, which have higher precedence.

NotEqual(Relational, Relational)

Represents an inequality comparison using the != operator. The operands are Relational expressions, which have higher precedence.

Primary(Primary)

A flattened primary expression for optimization. This variant is used when the expression doesn’t contain any equality operators.

Examples

use aimx::expressions::{
    equality::Equality,
    relational::Relational,
    primary::Primary,
};
use aimx::{Literal, ExpressionLike, Context};

// This demonstrates how equality expressions can be constructed
// In practice, these would be parsed from text expressions

// Create an equality expression conceptually like: 5 = 5
// Create an inequality expression conceptually like: 5 != 10

See Also

• parse_equality - Function to parse equality expressions
• ExpressionLike - Trait for expression evaluation
• Relational - Higher precedence expression type
• Primary - Flattened primary expression type

Variants

Equal(Relational, Relational)

NotEqual(Relational, Relational)

Primary(Box<Primary>)

Primary flattened AST optimization

Trait Implementations

impl Clone for Equality

fn clone(&self) -> Equality

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Equality

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

Formats the value using the given formatter.

impl Display for Equality

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

Format this equality expression as a string.

This implementation delegates to the write method using a string-based writer with default formatting. The output is suitable for display purposes and debugging.

Format

The formatting follows these conventions:

• Operators are surrounded by spaces: 5 = 5, 5 != 10
• Complex expressions are properly parenthesized
• Literals are formatted according to their type
• Variables and references are displayed as-is

Examples

use aimx::expressions::equality::{Equality, parse_equality};

let expr = parse_equality("5 = 5").unwrap().1;
assert_eq!(expr.to_string(), "5 = 5");

let expr = parse_equality("x > 0 = y < 10").unwrap().1;
assert_eq!(expr.to_string(), "x > 0 = y < 10");

let expr = parse_equality("5").unwrap().1;
assert_eq!(expr.to_string(), "5");

See Also

• ExpressionLike::write - The underlying serialization method
• ExpressionLike::to_formula - For round-trippable formula representation
• ExpressionLike::to_sanitized - For sanitized output

impl ExpressionLike for Equality

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

Evaluate this equality expression within the given context.

This method implements the core evaluation logic for equality expressions. It handles both equality (=) and inequality (!=) comparisons, using type promotion to ensure both operands have compatible types.

Evaluation Strategy

1. Equality Comparison (Equality::Equal):

   • Evaluates both operands using evaluate_and_promote
   • Promotes the right operand to match the left operand’s type
   • Compares values of the same type using == operator
   • Returns true if equal, false otherwise

2. Inequality Comparison (Equality::NotEqual):

   • Evaluates both operands using evaluate_and_promote
   • Promotes the right operand to match the left operand’s type
   • Compares values of the same type using != operator
   • Returns true if not equal, false otherwise

3. Flattened Expression (Equality::Primary):

   • Delegates evaluation to the underlying primary expression

Type Support

Equality operations support these value types:

• Bool - Boolean equality comparison
• Date - DateTime equality comparison
• Number - Numeric equality comparison
• Text - String equality comparison
• Task - Task status equality comparison

Error Handling

Returns an error if:

• Type promotion fails (incompatible types)
• Either operand evaluation fails
• Comparison of unsupported types is attempted

Error messages include type information and the original formula:

"Expected Bool, Date, Number, Task or Text, found Type1 = Type2 ~formula"

Arguments

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

Returns

Returns a Result<Value> containing:

• Value::Literal(Literal::Bool(true)) if comparison evaluates to true
• Value::Literal(Literal::Bool(false)) if comparison evaluates to false
• An error if evaluation fails

Examples

use aimx::expressions::equality::{Equality, parse_equality};
use aimx::{ExpressionLike, Context, Literal, Value};

let mut context = Context::new();

// Evaluate equality: 5 = 5
let expr = parse_equality("5 = 5").unwrap().1;
let result = expr.evaluate(&mut context).unwrap();
assert_eq!(result, Value::Literal(Literal::Bool(true)));

// Evaluate inequality: 5 != 10
let expr = parse_equality("5 != 10").unwrap().1;
let result = expr.evaluate(&mut context).unwrap();
assert_eq!(result, Value::Literal(Literal::Bool(true)));

// Evaluate with type promotion: 5 = "5"
let expr = parse_equality("5 = \"5\"").unwrap().1;
let result = expr.evaluate(&mut context).unwrap();
assert_eq!(result, Value::Literal(Literal::Bool(true)));

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

Write this equality expression to the provided writer.

This method serializes the expression to a text representation using the writer’s current formatting mode. The writer handles indentation, operator spacing, and other formatting concerns.

Serialization Strategy

• Equality Comparison (Equality::Equal):

  • Writes left operand
  • Writes " = " operator with spaces
  • Writes right operand

• Inequality Comparison (Equality::NotEqual):

  • Writes left operand
  • Writes " != " operator with spaces
  • Writes right operand

• Flattened Expression (Equality::Primary):

  • Delegates writing to the underlying primary expression

Arguments

• writer - The writer to serialize the expression to

Examples

use aimx::expressions::equality::{Equality, parse_equality};
use aimx::{Writer, PrintMode, Prefix};

// This demonstrates the general pattern for writing equality expressions
// In practice, these would be used internally by the expression evaluator

// Writing an equality expression like "5 = 5"
// Writing an inequality expression like "5 != 10"

fn to_sanitized(&self) -> String

Convert this equality expression to a sanitized string representation.

This method produces a string with special characters escaped to make it safe for various contexts like JSON output, HTML embedding, or other contexts where escaping is required.

Returns

A sanitized string representation of this expression.

fn to_formula(&self) -> String

Convert this equality expression to a formula string representation.

This method produces a string with proper quoting and escaping for use in formulas. The output should be round-trippable, meaning it can be parsed back into an equivalent expression.

Returns

A formula string representation of this expression.

impl PartialEq for Equality

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