Enum BinaryOp 

pub enum BinaryOp {
    Eq,
    Ne,
    Ge,
    Gt,
    Le,
    Lt,
    Add,
    Sub,
}

A binary operator: comparison or arithmetic.

Used by ExprBinaryOp to specify the operation applied between two expressions.

Examples

use toasty_core::stmt::BinaryOp;

let op = BinaryOp::Eq;
assert!(op.is_eq());
assert_eq!(op.to_string(), "=");

// Negation
assert_eq!(op.negate(), Some(BinaryOp::Ne));

// Commutation (swapping operands)
assert_eq!(BinaryOp::Lt.commute(), Some(BinaryOp::Gt));
assert_eq!(BinaryOp::Add.commute(), Some(BinaryOp::Add));
assert_eq!(BinaryOp::Sub.commute(), None);

Variants

Eq

Equality (=).

Ne

Inequality (!=).

Ge

Greater than or equal (>=).

Gt

Greater than (>).

Le

Less than or equal (<=).

Lt

Less than (<).

Add

Arithmetic addition (+).

Sub

Arithmetic subtraction (-).

Implementations

impl BinaryOp

pub fn is_eq(self) -> bool

Returns true if this is the equality operator.

pub fn is_ne(self) -> bool

Returns true if this is the inequality operator.

pub fn is_arithmetic(self) -> bool

Returns true if this is an arithmetic operator (+, -).

pub fn negate(self) -> Option<BinaryOp>

Returns the logical negation of this operator, if one exists.

Only comparison operators have a logical negation; arithmetic operators return None.

• = → !=
• != → =
• < → >=
• >= → <
• > → <=
• <= → >

pub fn commute(self) -> Option<BinaryOp>

Returns the operator that gives an equivalent result when the operands are swapped, or None if the operator is not commutative.

For example, 5 < x becomes x > 5, so Lt.commute() returns Some(Gt). Symmetric operators (Eq, Ne, Add) return themselves. Sub is not commutative (a - b ≠ b - a) and returns None.

Trait Implementations

impl Clone for BinaryOp

fn clone(&self) -> BinaryOp

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BinaryOp

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

Formats the value using the given formatter.

impl Display for BinaryOp

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

Formats the value using the given formatter.

impl Hash for BinaryOp

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for BinaryOp

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

impl Eq for BinaryOp

impl StructuralPartialEq for BinaryOp