impl<R: RuleType> Operator<R>

fn new(rule: R, assoc: Assoc) -> Operator<R>

Creates a new Operator from a Rule and Assoc.

Examples

# use pest::prec_climber::{Assoc, Operator};
# #[allow(non_camel_case_types)]
# #[allow(dead_code)]
# #[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
# enum Rule {
#     plus,
#     minus
# }
Operator::new(Rule::plus, Assoc::Left) | Operator::new(Rule::minus, Assoc::Right);

impl<R> Freeze for Operator<R>

impl<R> RefUnwindSafe for Operator<R>

impl<R> Send for Operator<R>

impl<R> Sync for Operator<R>

impl<R> Unpin for Operator<R>

impl<R> UnsafeUnpin for Operator<R>

impl<R> UnwindSafe for Operator<R>

impl<R: $crate::fmt::Debug + RuleType> Debug for Operator<R>

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

impl<R: RuleType> BitOr for Operator<R>

fn bitor(self: Self, rhs: Self) -> Self

impl<T> Any for Operator<R>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Operator<R>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for Operator<R>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> From for Operator<R>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for Operator<R>

fn into(self: Self) -> U

Calls U::from(self).

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

impl<T, U> TryFrom for Operator<R>

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

impl<T, U> TryInto for Operator<R>

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