Struct Expression 

pub struct Expression<N: Num> {
    pub string: String,
    pub ctx: Context<N>,
    pub term: Term<N>,
}

The main Expression struct. Contains the string that was originally requested to be parsed, the context the Expression was parsed with, and the Term the raw form was parsed as. For just the parsed version of the expression, use the Term enum.

Fields

string: String

The original string passed into this expression

ctx: Context<N>

Context the expression was parsed with

term: Term<N>

The term this string has been parsed as

Implementations

impl<N: Num + 'static> Expression<N>

pub fn parse(raw: &str) -> Result<Self, ParseError>

Parse a string into an expression

Examples found in repository

examples/basic.rs (line 19)

fn main() {
	println!("MEXPRP Test Calculator\n---------------------");
	loop {
		let mut buf = String::new();
		print!("> ");
		io::stdout().flush().unwrap();
		io::stdin().read_line(&mut buf).unwrap();

		// Parse the expression (with the default context)
		let expr: Expression<f64> = match Expression::parse(&buf) {
			Ok(expr) => expr,
			Err(e) => {
				println!("Failed to parse expression: {}", e);
				continue;
			}
		};

		// Evaluate the expression or print the error if there was one
		match expr.eval() {
			Ok(val) => println!("\t= {}", val),
			Err(e) => println!("Failed to evaluate the expression: {}", e),
		}
	}
}

pub fn parse_ctx(raw: &str, ctx: Context<N>) -> Result<Self, ParseError>

Parse a string into an expression with the given context

Examples found in repository

examples/context.rs (line 39)

fn main() {
	// A context holds data that can be used in an expression
	let mut context: Context<f64> = Context::new();
	// Add a variable "x" to the context with the value 5.4
	context.set_var("x", 5.4);
	// Add a function "sum" to the context that returns the sum of it's arguments. A closure is passed
	// in that takes twp arguments: args: &[Term], which is a slice if the arguments passed into the
	// function, and ctx: &Context, which is a reference to the context which the expression is being
	// evaluated with. The item passed in can be anything that implements the `Func` trait. There exists
	// a blanket impl for Fn(&[Term], &Context) -> Calculation which allows you to pass in closures in
	// that format.
	context.set_func(
		"sum",
		|args: &[Term<f64>], ctx: &Context<f64>| -> Calculation<f64> {
			if args.len() < 1 {
				return Err(MathError::IncorrectArguments);
			};

			let mut sum = Answer::Single(0.0);
			for arg in args {
				let b = arg.eval_ctx(ctx)?;
				sum = sum.op(&b, |a, b| Num::add(a, b, ctx))?;
			}

			Ok(sum)
		},
	);

	let raw = "2 * sum(x, 7, 400)";
	// The expression needs to be parsed with the context in order do decide if some names are functions
	// or variables.
	let expr = Expression::parse_ctx(raw, context).unwrap();
	// The expression also needs to be evaluated with a context. This context can be different than the
	// one it was parsed with, but if it is missing something that is necessary for evaluation the
	// evaluation will fail.
	println!("{} = {}", raw, expr.eval().unwrap())
}

pub fn eval(&self) -> Calculation<N>

Evaluate the expression

Examples found in repository

examples/basic.rs (line 28)

fn main() {
	println!("MEXPRP Test Calculator\n---------------------");
	loop {
		let mut buf = String::new();
		print!("> ");
		io::stdout().flush().unwrap();
		io::stdin().read_line(&mut buf).unwrap();

		// Parse the expression (with the default context)
		let expr: Expression<f64> = match Expression::parse(&buf) {
			Ok(expr) => expr,
			Err(e) => {
				println!("Failed to parse expression: {}", e);
				continue;
			}
		};

		// Evaluate the expression or print the error if there was one
		match expr.eval() {
			Ok(val) => println!("\t= {}", val),
			Err(e) => println!("Failed to evaluate the expression: {}", e),
		}
	}
}

examples/context.rs (line 43)

fn main() {
	// A context holds data that can be used in an expression
	let mut context: Context<f64> = Context::new();
	// Add a variable "x" to the context with the value 5.4
	context.set_var("x", 5.4);
	// Add a function "sum" to the context that returns the sum of it's arguments. A closure is passed
	// in that takes twp arguments: args: &[Term], which is a slice if the arguments passed into the
	// function, and ctx: &Context, which is a reference to the context which the expression is being
	// evaluated with. The item passed in can be anything that implements the `Func` trait. There exists
	// a blanket impl for Fn(&[Term], &Context) -> Calculation which allows you to pass in closures in
	// that format.
	context.set_func(
		"sum",
		|args: &[Term<f64>], ctx: &Context<f64>| -> Calculation<f64> {
			if args.len() < 1 {
				return Err(MathError::IncorrectArguments);
			};

			let mut sum = Answer::Single(0.0);
			for arg in args {
				let b = arg.eval_ctx(ctx)?;
				sum = sum.op(&b, |a, b| Num::add(a, b, ctx))?;
			}

			Ok(sum)
		},
	);

	let raw = "2 * sum(x, 7, 400)";
	// The expression needs to be parsed with the context in order do decide if some names are functions
	// or variables.
	let expr = Expression::parse_ctx(raw, context).unwrap();
	// The expression also needs to be evaluated with a context. This context can be different than the
	// one it was parsed with, but if it is missing something that is necessary for evaluation the
	// evaluation will fail.
	println!("{} = {}", raw, expr.eval().unwrap())
}

pub fn eval_ctx(&self, ctx: &Context<N>) -> Calculation<N>

Evaluate the expression with the given context

Trait Implementations

impl<N: Clone + Num> Clone for Expression<N>

fn clone(&self) -> Expression<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<N: Debug + Num> Debug for Expression<N>

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

Formats the value using the given formatter.

impl<N: Num> Display for Expression<N>

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

Formats the value using the given formatter.

impl<N: Num> From<Expression<N>> for Term<N>

fn from(t: Expression<N>) -> Term<N>

Converts to this type from the input type.