# Enum syn::BinOp

source · [−]

    pub enum BinOp {
    Show 28 variants    Add(Add),
        Sub(Sub),
        Mul(Star),
        Div(Div),
        Rem(Rem),
        And(AndAnd),
        Or(OrOr),
        BitXor(Caret),
        BitAnd(And),
        BitOr(Or),
        Shl(Shl),
        Shr(Shr),
        Eq(EqEq),
        Lt(Lt),
        Le(Le),
        Ne(Ne),
        Ge(Ge),
        Gt(Gt),
        AddEq(AddEq),
        SubEq(SubEq),
        MulEq(MulEq),
        DivEq(DivEq),
        RemEq(RemEq),
        BitXorEq(CaretEq),
        BitAndEq(AndEq),
        BitOrEq(OrEq),
        ShlEq(ShlEq),
        ShrEq(ShrEq),
    }

Expand description

A binary operator: `+`, `+=`, `&`.

This type is available only if Syn is built with the `"derive"` or `"full"` feature.

## Variants

### `Add(Add)`

The `+` operator (addition)

### `Sub(Sub)`

The `-` operator (subtraction)

### `Mul(Star)`

The `*` operator (multiplication)

### `Div(Div)`

The `/` operator (division)

### `Rem(Rem)`

The `%` operator (modulus)

### `And(AndAnd)`

The `&&` operator (logical and)

### `Or(OrOr)`

The `||` operator (logical or)

### `BitXor(Caret)`

The `^` operator (bitwise xor)

### `BitAnd(And)`

The `&` operator (bitwise and)

### `BitOr(Or)`

The `|` operator (bitwise or)

### `Shl(Shl)`

The `<<` operator (shift left)

### `Shr(Shr)`

The `>>` operator (shift right)

### `Eq(EqEq)`

The `==` operator (equality)

### `Lt(Lt)`

The `<` operator (less than)

### `Le(Le)`

The `<=` operator (less than or equal to)

### `Ne(Ne)`

The `!=` operator (not equal to)

### `Ge(Ge)`

The `>=` operator (greater than or equal to)

### `Gt(Gt)`

The `>` operator (greater than)

### `AddEq(AddEq)`

The `+=` operator

### `SubEq(SubEq)`

The `-=` operator

### `MulEq(MulEq)`

The `*=` operator

### `DivEq(DivEq)`

The `/=` operator

### `RemEq(RemEq)`

The `%=` operator

### `BitXorEq(CaretEq)`

The `^=` operator

### `BitAndEq(AndEq)`

The `&=` operator

### `BitOrEq(OrEq)`

The `|=` operator

### `ShlEq(ShlEq)`

The `<<=` operator

### `ShrEq(ShrEq)`

The `>>=` operator

## Trait Implementations

source

### impl Clone for BinOp

source

#### fn clone(&self) -> Self

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from `source`. Read more

source

### impl Parse for BinOp

source

#### fn parse(input: ParseStream<'_>) -> Result<Self>

source

### impl ToTokens for BinOp

source

#### fn to_tokens(&self, tokens: &mut TokenStream)

Write `self` to the given `TokenStream`. Read more

source

#### fn to_token_stream(&self) -> TokenStream

Convert `self` directly into a `TokenStream` object. Read more

source

#### fn into_token_stream(self) -> TokenStream

Convert `self` directly into a `TokenStream` object. Read more

source

### impl Copy for BinOp

## Auto Trait Implementations

### impl RefUnwindSafe for BinOp

### impl !Send for BinOp

### impl !Sync for BinOp

### impl Unpin for BinOp

### impl UnwindSafe for BinOp

## Blanket Implementations

source

### impl<T> Any for T where
T: 'static + ?Sized,

source

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more

source

### impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

source

### impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

source

### impl<T> From<T> for T

const: unstable · source

#### fn from(t: T) -> T

Returns the argument unchanged.

source

### impl<T, U> Into<U> for T where
U: From<T>,

const: unstable · source

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source

### impl<T> Spanned for T where
T: Spanned + ?Sized,

source

#### 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. Read more

source

### impl<T> ToOwned for T where
T: Clone,

#### type Owned = T

The resulting type after obtaining ownership.

source

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

source

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

source

### impl<T, U> TryFrom<U> for T where
U: Into<T>,

#### type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

source

### impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.