Enum BinaryOpKind 

pub enum BinaryOpKind {
    Add,
    Subtract,
    Multiply,
    Pow,
    Divide,
    ExactDivide,
    FloorDivide,
    Modulo,
    Eq,
    NotEq,
    Lt,
    Gt,
    LtEq,
    GtEq,
    And,
    Or,
    Concat,
    SeqConcat,
    ApproxEq,
    BitXor,
    BitAnd,
    BitOr,
    Shl,
    Shr,
}

Binary operation kinds for imperative expressions.

Variants

Add

Subtract

Multiply

Pow

a ** b — exponentiation. Integer power is EXACT (promotes to BigInt on overflow); a Float operand uses powf; a negative integer exponent is a loud error. Binds tighter than * / %, right-associative.

Divide

ExactDivide

EXACT division — the type-directed sibling of BinaryOpKind::Divide. Divide floors (7 / 2 → 3, the integer default); ExactDivide keeps the quotient exact (7 / 2 → 7/2, a Rational). The resolve_divisions pass rewrites Divide → ExactDivide only where the result flows into a Rational context, so existing (floor) code is untouched.

FloorDivide

a // b — FLOOR division, rounding toward negative infinity (-7 // 2 → -4). Distinct from BinaryOpKind::Divide, which truncates toward zero (-7 / 2 → -3); the two agree when the operands share a sign. Exact (promotes to BigInt), integer-producing, and immune to the resolve_divisions Rational rewrite — the explicit spelling for “give me the floored integer quotient.”

Modulo

Eq

NotEq

Lt

Gt

LtEq

GtEq

And

Or

Concat

String concatenation (“X combined with Y”)

SeqConcat

Sequence concatenation (“A followed by B”) — merge two sequences into one.

ApproxEq

Tolerant float comparison (“a is approximately b”) — Python-isclose semantics (rel 1e-9, abs floor 1e-12). == stays IEEE bit-exact; this is the EXPLICIT spelling for near-equality.

BitXor

Bitwise XOR: x ^ y (the word xor is the English spelling); on Sets, symmetric difference.

BitAnd

Bitwise AND: x & y; on Sets, intersection.

BitOr

Bitwise OR: x | y; on Sets, union.

Shl

Left shift: “x shifted left by y” → x << y

Shr

Right shift: “x shifted right by y” → x >> y

Trait Implementations

impl Clone for BinaryOpKind

fn clone(&self) -> BinaryOpKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BinaryOpKind

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

Formats the value using the given formatter.

impl Hash for BinaryOpKind

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 BinaryOpKind

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

impl Eq for BinaryOpKind

impl StructuralPartialEq for BinaryOpKind