Basic example basic_evaluation implementation for the Medium article on Ripin-rs

basic_evaluation.rs

use ripin::evaluate::Evaluate;
use ripin::expression::Expression;
use ripin::{Stack, pop_two_operands};

impl Evaluate<MyOperand> for MyEvaluator<MyOperand> {
    type Err = ();

    fn operands_needed(&self) -> usize {
        match *self {
            MyEvaluator::Add | MyEvaluator::Sub => 2,
            _ => unreachable!(), // _Phantom
        }
    }
    fn operands_generated(&self) -> usize {
        match *self {
            MyEvaluator::Add | MyEvaluator::Sub => 1,
            _ => unreachable!(), // _Phantom
        }
    }

    fn evaluate(self, stack: &mut Stack<MyOperand>) -> Result<(), Self::Err> {
        let (a, b) = pop_two_operands(stack).ok_or(())?;
        match self {
            MyEvaluator::Add => {
                match (a, b) {
                    (MyOperand::Number1, MyOperand::Number1) => {
                        Ok(stack.push(MyOperand::Number2))
                    },
                    _ => Err(()),
                }
            },
            MyEvaluator::Sub => {
                match (a, b) {
                    (MyOperand::Number2, MyOperand::Number1) => {
                        Ok(stack.push(MyOperand::Number1))
                    },
                    _ => Err(()),
                }
            }
            _ => unreachable!() // _Phantom
        }
    }
}

type MyExpression = Expression<MyOperand, MyEvaluator<MyOperand>>;

let expr_str = "1 + 1";
let tokens = expr_str.split_whitespace();
let expr = MyExpression::from_iter(tokens).unwrap();

match expr.evaluate() {
    Ok(MyOperand::Number2) => (),
    _ => panic!("Wrong result !"),
}