Enum rustpython_ast::Operator

pub enum Operator {
    Add,
    Sub,
    Mult,
    MatMult,
    Div,
    Mod,
    Pow,
    LShift,
    RShift,
    BitOr,
    BitXor,
    BitAnd,
    FloorDiv,
}

See also operator

Variants

Add

Sub

Mult

MatMult

Div

Mod

Pow

LShift

RShift

BitOr

BitXor

BitAnd

FloorDiv

Implementations

impl Operator

pub const fn is_add(&self) -> bool

Returns true if self is of variant Add.

pub const fn is_sub(&self) -> bool

Returns true if self is of variant Sub.

pub const fn is_mult(&self) -> bool

Returns true if self is of variant Mult.

pub const fn is_mat_mult(&self) -> bool

Returns true if self is of variant MatMult.

pub const fn is_div(&self) -> bool

Returns true if self is of variant Div.

pub const fn is_mod(&self) -> bool

Returns true if self is of variant Mod.

pub const fn is_pow(&self) -> bool

Returns true if self is of variant Pow.

pub const fn is_l_shift(&self) -> bool

Returns true if self is of variant LShift.

pub const fn is_r_shift(&self) -> bool

Returns true if self is of variant RShift.

pub const fn is_bit_or(&self) -> bool

Returns true if self is of variant BitOr.

pub const fn is_bit_xor(&self) -> bool

Returns true if self is of variant BitXor.

pub const fn is_bit_and(&self) -> bool

Returns true if self is of variant BitAnd.

pub const fn is_floor_div(&self) -> bool

Returns true if self is of variant FloorDiv.

impl Operator

pub const fn operator_add(&self) -> Option<OperatorAdd>

pub const fn operator_sub(&self) -> Option<OperatorSub>

pub const fn operator_mult(&self) -> Option<OperatorMult>

pub const fn operator_mat_mult(&self) -> Option<OperatorMatMult>

pub const fn operator_div(&self) -> Option<OperatorDiv>

pub const fn operator_mod(&self) -> Option<OperatorMod>

pub const fn operator_pow(&self) -> Option<OperatorPow>

pub const fn operator_l_shift(&self) -> Option<OperatorLShift>

pub const fn operator_r_shift(&self) -> Option<OperatorRShift>

pub const fn operator_bit_or(&self) -> Option<OperatorBitOr>

pub const fn operator_bit_xor(&self) -> Option<OperatorBitXor>

pub const fn operator_bit_and(&self) -> Option<OperatorBitAnd>

pub const fn operator_floor_div(&self) -> Option<OperatorFloorDiv>

Trait Implementations

impl Clone for Operator

fn clone(&self) -> Operator

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Operator

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

Formats the value using the given formatter.

impl<T, U> Foldable<T, U> for Operator

type Mapped = Operator

fn fold<F: Fold<T, TargetU = U> + ?Sized>( self, folder: &mut F ) -> Result<Self::Mapped, F::Error>

impl<R> From<Operator> for Ast<R>

fn from(node: Operator) -> Self

Converts to this type from the input type.

impl From<OperatorAdd> for Operator

fn from(_: OperatorAdd) -> Self

Converts to this type from the input type.

impl From<OperatorBitAnd> for Operator

fn from(_: OperatorBitAnd) -> Self

Converts to this type from the input type.

impl From<OperatorBitOr> for Operator

fn from(_: OperatorBitOr) -> Self

Converts to this type from the input type.

impl From<OperatorBitXor> for Operator

fn from(_: OperatorBitXor) -> Self

Converts to this type from the input type.

impl From<OperatorDiv> for Operator

fn from(_: OperatorDiv) -> Self

Converts to this type from the input type.

impl From<OperatorFloorDiv> for Operator

fn from(_: OperatorFloorDiv) -> Self

Converts to this type from the input type.

impl From<OperatorLShift> for Operator

fn from(_: OperatorLShift) -> Self

Converts to this type from the input type.

impl From<OperatorMatMult> for Operator

fn from(_: OperatorMatMult) -> Self

Converts to this type from the input type.

impl From<OperatorMod> for Operator

fn from(_: OperatorMod) -> Self

Converts to this type from the input type.

impl From<OperatorMult> for Operator

fn from(_: OperatorMult) -> Self

Converts to this type from the input type.

impl From<OperatorPow> for Operator

fn from(_: OperatorPow) -> Self

Converts to this type from the input type.

impl From<OperatorRShift> for Operator

fn from(_: OperatorRShift) -> Self

Converts to this type from the input type.

impl From<OperatorSub> for Operator

fn from(_: OperatorSub) -> Self

Converts to this type from the input type.

impl Hash for Operator

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 Node for Operator

const NAME: &'static str = "operator"

const FIELD_NAMES: &'static [&'static str] = _

impl PartialEq<Operator> for OperatorAdd

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Operator> for OperatorBitAnd

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Operator> for OperatorBitOr

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Operator> for OperatorBitXor

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Operator> for OperatorDiv

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Operator> for OperatorFloorDiv

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Operator> for OperatorLShift

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Operator> for OperatorMatMult

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Operator> for OperatorMod

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Operator> for OperatorMult

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Operator> for OperatorPow

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Operator> for OperatorRShift

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Operator> for OperatorSub

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for Operator

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Operator

impl Eq for Operator

impl StructuralPartialEq for Operator