Enum LogicalOperator 

pub enum LogicalOperator {
    And,
    Or,
}

Defines the type of logical operation.

Used by the LogicalOp variant of AstExpr to specify which logical operation should be performed with short-circuit evaluation semantics.

Short-Circuit Evaluation

Short-circuit evaluation is an optimization technique where the second operand of a logical operation is evaluated only when necessary:

• For && (AND): If the left operand is false, the result is false regardless of the right operand, so the right operand is not evaluated.

• For || (OR): If the left operand is true, the result is true regardless of the right operand, so the right operand is not evaluated.

This behavior is particularly useful for:

1. Performance optimization - avoid unnecessary calculation
2. Conditional execution - control evaluation of expressions
3. Safe guards - prevent errors (e.g., division by zero)

Boolean Representation

In this expression engine, boolean values are represented as floating-point numbers:

• 0.0 represents false
• Any non-zero value (typically 1.0) represents true

Variants

And

Logical AND (&&) - evaluates to true only if both operands are true. Short-circuits if the left operand is false.

Examples:

• 1 && 1 evaluates to 1.0 (true)
• 1 && 0 evaluates to 0.0 (false)
• 0 && expr evaluates to 0.0 without evaluating expr

Or

Logical OR (||) - evaluates to true if either operand is true. Short-circuits if the left operand is true.

Examples:

• 1 || 0 evaluates to 1.0 (true)
• 0 || 0 evaluates to 0.0 (false)
• 1 || expr evaluates to 1.0 without evaluating expr

Trait Implementations

impl Clone for LogicalOperator

fn clone(&self) -> LogicalOperator

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LogicalOperator

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

Formats the value using the given formatter.

impl Display for LogicalOperator

Implements Display for LogicalOperator to use in error messages.

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

Formats the value using the given formatter.

impl PartialEq for LogicalOperator

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