Enum binjs_es6::ast::BinaryOperator

pub enum BinaryOperator {
    Comma,
    LogicalOr,
    LogicalAnd,
    BitOr,
    BitXor,
    BitAnd,
    Eq,
    Neq,
    StrictEq,
    StrictNeq,
    LessThan,
    LeqThan,
    GreaterThan,
    GeqThan,
    In,
    Instanceof,
    Lsh,
    Rsh,
    Ursh,
    Plus,
    Minus,
    Mul,
    Div,
    Mod,
    Pow,
}

Implementation of string enum BinaryOperator

Variants

Comma

LogicalOr

LogicalAnd

BitOr

BitXor

BitAnd

Eq

Neq

StrictEq

StrictNeq

LessThan

LeqThan

GreaterThan

GeqThan

In

Instanceof

Lsh

Rsh

Ursh

Plus

Minus

Mul

Div

Mod

Pow

Trait Implementations

impl Clone for BinaryOperator

fn clone(&self) -> BinaryOperator

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for BinaryOperator

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

Formats the value using the given formatter.

impl Default for BinaryOperator

fn default() -> Self

Returns the "default value" for a type.

impl<R> Deserialization<BinaryOperator> for Deserializer<R> where
    R: TokenReader, 

fn deserialize(
    &mut self,
    path: &mut IOPath
) -> Result<BinaryOperator, TokenReaderError>

impl<'de> Deserialize<'de> for BinaryOperator

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl PartialEq<BinaryOperator> for BinaryOperator

fn eq(&self, other: &BinaryOperator) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<W> Serialization<BinaryOperator> for Serializer<W> where
    W: TokenWriter, 

fn serialize(
    &mut self,
    value: &BinaryOperator,
    path: &mut IOPath
) -> Result<(), TokenWriterError>

Serialize a piece of data.

impl Serialize for BinaryOperator

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for BinaryOperator

impl<'a> Walker<'a> for BinaryOperator where
    Self: 'a, 

type Output = BinaryOperator

fn walk<V, E, G>(
    &'a mut self,
    _: &mut WalkPath,
    _: &mut V
) -> Result<Option<Self::Output>, E> where
    V: Visitor<E, G>,
    G: WalkGuard<V>,