Enum BinOp

#[non_exhaustive]
pub enum BinOp {
    Add(Plus),
    Sub(Dash),
    Div(Div),
    Mul(Star),
    Rem(Perc),
    Eq(EqEq),
    Neq(BangEq),
    Gt(Gt),
    Lt(Lt),
    Gte(GtEq),
    Lte(LtEq),
    As(As),
    Is(Is),
    IsNot(IsNot),
    And(AmpAmp),
    Or(PipePipe),
    Shl(LtLt),
    Shr(GtGt),
    BitAnd(Amp),
    BitXor(Caret),
    BitOr(Pipe),
    AddAssign(PlusEq),
    SubAssign(DashEq),
    MulAssign(StarEq),
    DivAssign(SlashEq),
    RemAssign(PercEq),
    BitAndAssign(AmpEq),
    BitXorAssign(CaretEq),
    BitOrAssign(PipeEq),
    ShlAssign(LtLtEq),
    ShrAssign(GtGtEq),
    DotDot(DotDot),
    DotDotEq(DotDotEq),
}

A binary operation.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Add(Plus)

Addition a + b.

Sub(Dash)

Subtraction a - b.

Div(Div)

Division a / b.

Mul(Star)

Multiplication a * b.

Rem(Perc)

Remainder operator a % b.

Eq(EqEq)

Equality check a == b.

Neq(BangEq)

Inequality check a != b.

Gt(Gt)

Greater-than check a > b.

Lt(Lt)

Less-than check a < b.

Gte(GtEq)

Greater-than or equal check a >= b.

Lte(LtEq)

Less-than or equal check a <= b.

As(As)

Type coercion a as b.

Is(Is)

Instance of test a is b.

IsNot(IsNot)

Negated instance of test a is not b.

And(AmpAmp)

Lazy and operator &&.

Or(PipePipe)

Lazy or operator ||.

Shl(LtLt)

Bitwise left shift operator a << b.

Shr(GtGt)

Bitwise right shift operator a >> b.

BitAnd(Amp)

Bitwise and operator a & b.

BitXor(Caret)

Bitwise xor operator a ^ b.

BitOr(Pipe)

Bitwise or operator a | b.

AddAssign(PlusEq)

Add assign a += b.

SubAssign(DashEq)

Sub assign a -= b.

MulAssign(StarEq)

Multiply assign operation a *= b.

DivAssign(SlashEq)

Div assign a /= b.

RemAssign(PercEq)

Remainder assign a %= b.

BitAndAssign(AmpEq)

Bitwise and assign a &= b.

BitXorAssign(CaretEq)

Bitwise xor assign a ^= b.

BitOrAssign(PipeEq)

Bitwise or assign a |= b.

ShlAssign(LtLtEq)

Left shift assign a <<= b.

ShrAssign(GtGtEq)

Right shift assign a >>= b.

DotDot(DotDot)

a .. b.

DotDotEq(DotDotEq)

a ..= b.

Trait Implementations

impl Clone for BinOp

fn clone(&self) -> BinOp

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BinOp

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

Formats the value using the given formatter.

impl Display for BinOp

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

Formats the value using the given formatter.

impl Hash for BinOp

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

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 OptionSpanned for BinOp

fn option_span(&self) -> Option<Span>

Get the optional span of the type.

impl PartialEq for BinOp

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

fn peek(p: &mut Peeker<'_>) -> bool

Peek the parser for the given token.

impl Spanned for BinOp

fn span(&self) -> Span

Get the span of the type.

impl ToTokens for BinOp

fn to_tokens( &self, context: &mut MacroContext<'_, '_, '_>, stream: &mut TokenStream, ) -> Result<()>

Turn the current item into tokens.

impl TryClone for BinOp

fn try_clone(&self) -> Result<Self>

Try to clone the current value, raising an allocation error if it’s unsuccessful.

fn try_clone_from(&mut self, source: &Self) -> Result<(), Error>

Performs copy-assignment from source.

impl Copy for BinOp

impl Eq for BinOp

impl StructuralPartialEq for BinOp