aimx::expressions::equality

Function parse_equality

Source 
pub fn parse_equality(input: &str) -> IResult<&str, Equality>
Expand description

Parse an equality expression from a string slice.

This function is the main entry point for parsing equality expressions. It handles the complete equality grammar rule, including optional whitespace and operator aliases. The parser follows the AIMX precedence rules, where equality operators have lower precedence than relational operators.

§Grammar

The function implements this grammar rule:

equality := relational (S? ('=' | "!=" | '==') S? relational)?

Where S represents optional whitespace.

§Parsing Strategy

  1. First attempts to parse a relational expression
  2. If an equality operator is found, parses the second relational expression
  3. If no equality operator is found, flattens the expression to Primary
  4. Returns the parsed Equality expression and remaining input

§Operator Support

The parser accepts these equality operators:

  • = (equality) - also accepts == as an alias
  • != (inequality)

§AST Flattening

When no equality operator is found, the parser flattens the expression to optimize evaluation performance. This means expressions like 5 or x > y are represented as Equality::Primary rather than creating unnecessary AST nodes.

§Arguments

  • input - The input string slice to parse

§Returns

Returns an [IResult] containing:

  • The remaining unparsed input (if any)
  • The parsed Equality expression

§Examples

§Basic Equality

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

let (remaining, expr) = parse_equality("5 = 5").unwrap();
assert_eq!(remaining, "");
assert!(matches!(expr, Equality::Equal(_, _)));

§Inequality with Whitespace

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

let (remaining, expr) = parse_equality("5 != 10").unwrap();
assert_eq!(remaining, "");
assert!(matches!(expr, Equality::NotEqual(_, _)));

§Operator Aliases

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

// Both '=' and '==' are accepted
let (_, expr1) = parse_equality("5 = 5").unwrap();
let (_, expr2) = parse_equality("5 == 5").unwrap();
assert!(matches!(expr1, Equality::Equal(_, _)));
assert!(matches!(expr2, Equality::Equal(_, _)));

§Complex Expressions

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

// Equality with relational expressions
let (remaining, expr) = parse_equality("x > 0 = y < 10").unwrap();
assert_eq!(remaining, "");
assert!(matches!(expr, Equality::Equal(_, _)));

// Equality with arithmetic expressions
let (remaining, expr) = parse_equality("2 + 3 = 5").unwrap();
assert_eq!(remaining, "");
assert!(matches!(expr, Equality::Equal(_, _)));

§Flattened Expressions

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

// Expressions without equality operators are flattened
let (remaining, expr) = parse_equality("5").unwrap();
assert_eq!(remaining, "");
assert!(matches!(expr, Equality::Primary(_)));

let (remaining, expr) = parse_equality("x > y").unwrap();
assert_eq!(remaining, "");
assert!(matches!(expr, Equality::Primary(_)));

§Chaining Behavior

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

// Equality operations are not chained
let (remaining, expr) = parse_equality("1 = 1 = 1").unwrap();
assert_eq!(remaining, "= 1"); // Only first equality is parsed
assert!(matches!(expr, Equality::Equal(_, _)));

§Error Handling

The function returns [IResult] which can contain parsing errors. Common errors include:

  • Invalid operator syntax
  • Malformed relational expressions
  • Unexpected end of input

§See Also