#expr #eval #calc

bin+lib pupil

Arithmetic expression evaluator

4 releases

Uses old Rust 2015

0.1.3 Aug 25, 2016
0.1.2 Jun 17, 2016
0.1.1 Apr 22, 2016
0.1.0 Apr 21, 2016

#817 in Math

MIT license

874 lines


Arithmetic expression evaluator written in Rust.

It implements a butchered Shunting-yard algorithm.


To build the pupil executable, run cargo build. Append the --release switch as needed for optimized builds.

It has three different use cases:

  • Interactive mode.

    Enter expressions and press enter to evaluate them.

    PATH/TO/CRATE/ROOT> cargo run
    Welcome to pupil, the arithmetic expression evaluator.
    Enter an expression, eg. 2 + 3, and press enter.
    Press ctrl-C to exit.
    >>> 2 + 3
    >>> ^C
  • Provide the expression to evaluate as command line arguments.

    This allows to evaluate a single expression and then exit.

    PATH/TO/CRATE/ROOT> cargo run -- 2 + 3
    Welcome to pupil, the arithmetic expression evaluator.
    Ok: 5
  • Pipe input.

    Evaluates every line as separate expressions and prints the result line by line.

    PATH/TO/CRATE/ROOT> echo 2 + 3 | cargo run


This library can be found on crates.io. In your Cargo.toml put:

pupil = "0.1"

A practical example can be found in src/bin/pupil.rs.

Documentation can be found online here.

Start things off by creating its environment which will hold the available builtins and the last answer.

extern crate pupil;

// Creates an empty environment.
let empty = pupil::Env::new();
// Creates an environment initialized with the default builtins.
let env = pupil::Env::default();

Create an expression and bind it to its environment.

let mut expr = pupil::Expr::new(&env);

// Feed it input, note that you cannot give it partial tokens.
expr.feed("2 +").unwrap();

// Calculate the final result.
let result = expr.result().unwrap();

You can perform the expression evaluation in a single step.

let result = pupil::Expr::new(&env).eval("2 + 3").unwrap();

That’s it.


MIT - See license.txt