Enum BinOp

pub enum BinOp {
    Le(Le),
    Ge(Ge),
    Eq(EqEq),
    Neq(Ne),
    Or(OrOr),
    And(AndAnd),
    Assign(Eq),
    AddAssign(PlusEq),
    SubAssign(MinusEq),
    MulAssign(StarEq),
    DivAssign(SlashEq),
    RemAssign(PercentEq),
    BitAndAssign(AndEq),
    BitOrAssign(OrEq),
    BitXorAssign(CaretEq),
    SarAssign(Shr, Ge),
    ShlAssign(ShlEq),
    ShrAssign(ShrEq),
    Sar(Shr, Gt),
    Shr(Shr),
    Shl(Shl),
    BitAnd(And),
    BitOr(Or),
    BitXor(Caret),
    Lt(Lt),
    Gt(Gt),
    Add(Plus),
    Sub(Minus),
    Pow(Star, Star),
    Mul(Star),
    Div(Slash),
    Rem(Percent),
}

A binary operator: +, +=, &.

Variants

Le(Le)

<=

Ge(Ge)

>=

Eq(EqEq)

==

Neq(Ne)

!=

Or(OrOr)

||

And(AndAnd)

&&

Assign(Eq)

=

AddAssign(PlusEq)

+=

SubAssign(MinusEq)

-=

MulAssign(StarEq)

*=

DivAssign(SlashEq)

/=

RemAssign(PercentEq)

%=

BitAndAssign(AndEq)

&=

BitOrAssign(OrEq)

|=

BitXorAssign(CaretEq)

^=

SarAssign(Shr, Ge)

>>>=

ShlAssign(ShlEq)

<<=

ShrAssign(ShrEq)

>>=

Sar(Shr, Gt)

>>>

Shr(Shr)

>>

Shl(Shl)

<<

BitAnd(And)

&

BitOr(Or)

|

BitXor(Caret)

^

Lt(Lt)

<

Gt(Gt)

>

Add(Plus)

+

Sub(Minus)

-

Pow(Star, Star)

**

Mul(Star)

*

Div(Slash)

/

Rem(Percent)

%

Implementations

impl BinOp

pub fn new_le(span: Span) -> BinOp

Creates a new Le operator with the given span.

pub fn new_ge(span: Span) -> BinOp

Creates a new Ge operator with the given span.

pub fn new_eq(span: Span) -> BinOp

Creates a new Eq operator with the given span.

pub fn new_neq(span: Span) -> BinOp

Creates a new Neq operator with the given span.

pub fn new_or(span: Span) -> BinOp

Creates a new Or operator with the given span.

pub fn new_and(span: Span) -> BinOp

Creates a new And operator with the given span.

pub fn new_assign(span: Span) -> BinOp

Creates a new Assign operator with the given span.

pub fn new_add_assign(span: Span) -> BinOp

Creates a new AddAssign operator with the given span.

pub fn new_sub_assign(span: Span) -> BinOp

Creates a new SubAssign operator with the given span.

pub fn new_mul_assign(span: Span) -> BinOp

Creates a new MulAssign operator with the given span.

pub fn new_div_assign(span: Span) -> BinOp

Creates a new DivAssign operator with the given span.

pub fn new_rem_assign(span: Span) -> BinOp

Creates a new RemAssign operator with the given span.

pub fn new_bit_and_assign(span: Span) -> BinOp

Creates a new BitAndAssign operator with the given span.

pub fn new_bit_or_assign(span: Span) -> BinOp

Creates a new BitOrAssign operator with the given span.

pub fn new_bit_xor_assign(span: Span) -> BinOp

Creates a new BitXorAssign operator with the given span.

pub fn new_sar_assign(span: Span) -> BinOp

Creates a new SarAssign operator with the given span.

pub fn new_shl_assign(span: Span) -> BinOp

Creates a new ShlAssign operator with the given span.

pub fn new_shr_assign(span: Span) -> BinOp

Creates a new ShrAssign operator with the given span.

pub fn new_sar(span: Span) -> BinOp

Creates a new Sar operator with the given span.

pub fn new_shr(span: Span) -> BinOp

Creates a new Shr operator with the given span.

pub fn new_shl(span: Span) -> BinOp

Creates a new Shl operator with the given span.

pub fn new_bit_and(span: Span) -> BinOp

Creates a new BitAnd operator with the given span.

pub fn new_bit_or(span: Span) -> BinOp

Creates a new BitOr operator with the given span.

pub fn new_bit_xor(span: Span) -> BinOp

Creates a new BitXor operator with the given span.

pub fn new_lt(span: Span) -> BinOp

Creates a new Lt operator with the given span.

pub fn new_gt(span: Span) -> BinOp

Creates a new Gt operator with the given span.

pub fn new_add(span: Span) -> BinOp

Creates a new Add operator with the given span.

pub fn new_sub(span: Span) -> BinOp

Creates a new Sub operator with the given span.

pub fn new_pow(span: Span) -> BinOp

Creates a new Pow operator with the given span.

pub fn new_mul(span: Span) -> BinOp

Creates a new Mul operator with the given span.

pub fn new_div(span: Span) -> BinOp

Creates a new Div operator with the given span.

pub fn new_rem(span: Span) -> BinOp

Creates a new Rem operator with the given span.

pub fn peek(input: &ParseBuffer<'_>, lookahead: &Lookahead1<'_>) -> bool

pub const fn as_str(self) -> &'static str

pub const fn as_debug_str(self) -> &'static str

pub const fn is_le(self) -> bool

Returns true if self matches Self::Le.

pub const fn is_ge(self) -> bool

Returns true if self matches Self::Ge.

pub const fn is_eq(self) -> bool

Returns true if self matches Self::Eq.

pub const fn is_neq(self) -> bool

Returns true if self matches Self::Neq.

pub const fn is_or(self) -> bool

Returns true if self matches Self::Or.

pub const fn is_and(self) -> bool

Returns true if self matches Self::And.

pub const fn is_assign(self) -> bool

Returns true if self matches Self::Assign.

pub const fn is_add_assign(self) -> bool

Returns true if self matches Self::AddAssign.

pub const fn is_sub_assign(self) -> bool

Returns true if self matches Self::SubAssign.

pub const fn is_mul_assign(self) -> bool

Returns true if self matches Self::MulAssign.

pub const fn is_div_assign(self) -> bool

Returns true if self matches Self::DivAssign.

pub const fn is_rem_assign(self) -> bool

Returns true if self matches Self::RemAssign.

pub const fn is_bit_and_assign(self) -> bool

Returns true if self matches Self::BitAndAssign.

pub const fn is_bit_or_assign(self) -> bool

Returns true if self matches Self::BitOrAssign.

pub const fn is_bit_xor_assign(self) -> bool

Returns true if self matches Self::BitXorAssign.

pub const fn is_sar_assign(self) -> bool

Returns true if self matches Self::SarAssign.

pub const fn is_shl_assign(self) -> bool

Returns true if self matches Self::ShlAssign.

pub const fn is_shr_assign(self) -> bool

Returns true if self matches Self::ShrAssign.

pub const fn is_sar(self) -> bool

Returns true if self matches Self::Sar.

pub const fn is_shr(self) -> bool

Returns true if self matches Self::Shr.

pub const fn is_shl(self) -> bool

Returns true if self matches Self::Shl.

pub const fn is_bit_and(self) -> bool

Returns true if self matches Self::BitAnd.

pub const fn is_bit_or(self) -> bool

Returns true if self matches Self::BitOr.

pub const fn is_bit_xor(self) -> bool

Returns true if self matches Self::BitXor.

pub const fn is_lt(self) -> bool

Returns true if self matches Self::Lt.

pub const fn is_gt(self) -> bool

Returns true if self matches Self::Gt.

pub const fn is_add(self) -> bool

Returns true if self matches Self::Add.

pub const fn is_sub(self) -> bool

Returns true if self matches Self::Sub.

pub const fn is_pow(self) -> bool

Returns true if self matches Self::Pow.

pub const fn is_mul(self) -> bool

Returns true if self matches Self::Mul.

pub const fn is_div(self) -> bool

Returns true if self matches Self::Div.

pub const fn is_rem(self) -> bool

Returns true if self matches Self::Rem.

Trait Implementations

impl Clone for BinOp

fn clone(&self) -> BinOp

Returns a duplicate 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<(), Error>

Formats the value using the given formatter.

impl Display for BinOp

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

Formats the value using the given formatter.

impl Hash for BinOp

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

fn parse(input: &ParseBuffer<'_>) -> Result<BinOp, Error>

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

fn span(&self) -> Span

Returns a Span covering the complete contents of this syntax tree node, or Span::call_site() if this node is empty.

fn set_span(&mut self, span: Span)

Sets the span of this syntax tree node if it is not empty.

fn with_span(self, span: Span) -> Self

where Self: Sized,

Sets the span of this owned syntax tree node if it is not empty.

impl Copy for BinOp

impl Eq for BinOp