Struct arc_pest::PrecClimber[][src]

pub struct PrecClimber<R> where
    R: RuleType
{ /* fields omitted */ }

List of operators and precedences, which can perform precedence climbing on infix expressions contained in a Pairs. The token pairs contained in the Pairs should start with a primary pair and then alternate between an operator and a primary.

Implementations

impl<R> PrecClimber<R> where
    R: RuleType
[src]

pub fn new(ops: Vec<Operator<R>, Global>) -> PrecClimber<R>[src]

Creates a new PrecClimber from the Operators contained in ops. Every entry in the Vec has precedence index + 1. In order to have operators with same precedence, they need to be chained with | between them.

Examples

PrecClimber::new(vec![
    Operator::new(Rule::plus, Assoc::Left) | Operator::new(Rule::minus, Assoc::Left),
    Operator::new(Rule::times, Assoc::Left) | Operator::new(Rule::divide, Assoc::Left),
    Operator::new(Rule::power, Assoc::Right)
]);

pub fn climb<'i, P, F, G, T>(&self, pairs: P, primary: F, infix: G) -> T where
    F: FnMut(Pair<'i, R>) -> T,
    P: Iterator<Item = Pair<'i, R>>,
    G: FnMut(T, Pair<'i, R>, T) -> T, 
[src]

Performs the precedence climbing algorithm on the pairs in a similar manner to map-reduce. Primary pairs are mapped with primary and then reduced to one single result with infix.

Panics

Panics will occur when pairs is empty or when the alternating primary, operator, primary order is not respected.

Examples

let primary = |pair| {
    consume(pair, climber)
};
let infix = |lhs: i32, op: Pair<Rule>, rhs: i32| {
    match op.rule() {
        Rule::plus => lhs + rhs,
        Rule::minus => lhs - rhs,
        Rule::times => lhs * rhs,
        Rule::divide => lhs / rhs,
        Rule::power => lhs.pow(rhs as u32),
        _ => unreachable!()
    }
};

let result = climber.climb(pairs, primary, infix);

Trait Implementations

impl<R> Debug for PrecClimber<R> where
    R: RuleType + Debug
[src]

Auto Trait Implementations

impl<R> RefUnwindSafe for PrecClimber<R> where
    R: RefUnwindSafe

impl<R> Send for PrecClimber<R> where
    R: Send

impl<R> Sync for PrecClimber<R> where
    R: Sync

impl<R> Unpin for PrecClimber<R> where
    R: Unpin

impl<R> UnwindSafe for PrecClimber<R> where
    R: UnwindSafe

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

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

The type returned in the event of a conversion error.