fix benches and improve compile time

Author: urisinger

libraries/math-parser/benches/bench.rs

@@ -16,7 +16,7 @@ macro_rules! generate_benchmarks {
 
 		fn evaluation_bench(c: &mut Criterion) {
 			$(
-				let expr = ast::Node::try_parse_from_str($input).unwrap().0;
+				let expr = ast::Node::try_parse_from_str($input).unwrap();
 				let context = EvalContext::default();
 
 				c.bench_function(concat!("eval ", $input), |b| {

libraries/math-parser/src/parser.rs

@@ -8,37 +8,26 @@ use num_complex::ComplexFloat;
 use std::num::{ParseFloatError, ParseIntError};
 use thiserror::Error;
 
-/*#[derive(Parser)]
-#[grammar = "./grammer.pest"]
-struct ExprParser;
-
-lazy_static! {
-	static ref PRATT_PARSER: PrattParser<Rule> = {
-		PrattParser::new()
-			.op(Op::infix(Rule::add, Assoc::Left) | Op::infix(Rule::sub, Assoc::Left))
-			.op(Op::infix(Rule::mul, Assoc::Left) | Op::infix(Rule::div, Assoc::Left) | Op::infix(Rule::paren, Assoc::Left))
-			.op(Op::infix(Rule::pow, Assoc::Right))
-			.op(Op::infix(Rule::geq, Assoc::Left) | Op::infix(Rule::leq, Assoc::Left) | Op::infix(Rule::eq, Assoc::Left))
-			.op(Op::postfix(Rule::EOI))
-			.op(Op::prefix(Rule::sqrt))
-			.op(Op::prefix(Rule::neg))
-	};
-}*/
-
-#[derive(Error, Debug)]
-pub enum TypeError {
-	#[error("Invalid BinOp: {0:?} {1:?} {2:?}")]
-	InvalidBinaryOp(Unit, BinaryOp, Unit),
-
-	#[error("Invalid UnaryOp: {0:?}")]
-	InvalidUnaryOp(Unit, UnaryOp),
-}
-
 #[derive(Error, Debug)]
 pub enum ParseError<'src> {
-	/// One or more syntax/lexing errors produced by Chumsky.
 	#[error("Syntax error(s): {0:#?}")]
 	Syntax(Vec<Rich<'src, char>>),
+	#[error("nig")]
+	Nigga(),
+}
+
+#[cfg(not(debug_assertions))] // In release build: skip boxing
+macro_rules! maybe_boxed {
+	($p:expr) => {
+		$p
+	};
+}
+
+#[cfg(debug_assertions)] // In debug build: box for faster compilation
+macro_rules! maybe_boxed {
+	($p:expr) => {
+		$p.boxed()
+	};
 }
 
 impl Node {
@@ -109,7 +98,7 @@ pub fn chumsky_parser<'a>() -> impl Parser<'a, &'a str, Node, chumsky::extra::Er
 				else_block: Box::new(else_b),
 			});
 
-		let atom = choice((conditional, float, constant, call, parens, var));
+		let atom = maybe_boxed!(choice((conditional, float, constant, call, parens, var)));
 
 		let unary = choice((just('-').to(UnaryOp::Neg), just("sqrt").to(UnaryOp::Sqrt)))
 			.padded()
@@ -122,15 +111,16 @@ pub fn chumsky_parser<'a>() -> impl Parser<'a, &'a str, Node, chumsky::extra::Er
 			rhs: Box::new(rhs),
 		});
 
-		let product = pow
-			.clone()
-			.foldl(choice((just('*').to(BinaryOp::Mul), just('/').to(BinaryOp::Div))).padded().then(pow).repeated(), |lhs, (op, rhs)| {
-				Node::BinOp {
-					lhs: Box::new(lhs),
-					op,
-					rhs: Box::new(rhs),
-				}
-			});
+		let product = maybe_boxed!(
+			pow.clone()
+				.foldl(choice((just('*').to(BinaryOp::Mul), just('/').to(BinaryOp::Div))).padded().then(pow).repeated(), |lhs, (op, rhs)| {
+					Node::BinOp {
+						lhs: Box::new(lhs),
+						op,
+						rhs: Box::new(rhs),
+					}
+				})
+		);
 
 		let sum = product.clone().foldl(
 			choice((just('+').to(BinaryOp::Add), just('-').to(BinaryOp::Sub))).padded().then(product).repeated(),
@@ -157,277 +147,6 @@ pub fn chumsky_parser<'a>() -> impl Parser<'a, &'a str, Node, chumsky::extra::Er
 	})
 }
 
-struct NodeMetadata {
-	pub unit: Unit,
-}
-
-impl NodeMetadata {
-	pub fn new(unit: Unit) -> Self {
-		Self { unit }
-	}
-}
-
-/*fn parse_unit(pairs: Pairs<Rule>) -> Result<(Unit, f64), ParseError> {
-	let mut scale = 1.0;
-	let mut length = 0;
-	let mut mass = 0;
-	let mut time = 0;
-
-	for pair in pairs {
-		println!("found rule: {:?}", pair.as_rule());
-		match pair.as_rule() {
-			Rule::nano => scale *= 1e-9,
-			Rule::micro => scale *= 1e-6,
-			Rule::milli => scale *= 1e-3,
-			Rule::centi => scale *= 1e-2,
-			Rule::deci => scale *= 1e-1,
-			Rule::deca => scale *= 1e1,
-			Rule::hecto => scale *= 1e2,
-			Rule::kilo => scale *= 1e3,
-			Rule::mega => scale *= 1e6,
-			Rule::giga => scale *= 1e9,
-			Rule::tera => scale *= 1e12,
-
-			Rule::meter => length = 1,
-			Rule::gram => mass = 1,
-			Rule::second => time = 1,
-
-			_ => unreachable!(), // All possible rules should be covered
-		}
-	}
-
-	Ok((Unit { length, mass, time }, scale))
-}
-
-fn parse_const(pair: Pair<Rule>) -> Literal {
-	match pair.as_rule() {
-		Rule::infinity => Literal::Float(f64::INFINITY),
-		Rule::imaginary_unit => Literal::Complex(Complex::new(0.0, 1.0)),
-		Rule::pi => Literal::Float(std::f64::consts::PI),
-		Rule::tau => Literal::Float(2.0 * std::f64::consts::PI),
-		Rule::euler_number => Literal::Float(std::f64::consts::E),
-		Rule::golden_ratio => Literal::Float(1.61803398875),
-		_ => unreachable!("Unexpected constant: {:?}", pair),
-	}
-}
-
-fn parse_lit(mut pairs: Pairs<Rule>) -> Result<(Literal, Unit), ParseError> {
-	let literal = match pairs.next() {
-		Some(lit) => match lit.as_rule() {
-			Rule::int => {
-				let value = lit.as_str().parse::<i32>()? as f64;
-				Literal::Float(value)
-			}
-			Rule::float => {
-				let value = lit.as_str().parse::<f64>()?;
-				Literal::Float(value)
-			}
-			Rule::unit => {
-				let (unit, scale) = parse_unit(lit.into_inner())?;
-				return Ok((Literal::Float(scale), unit));
-			}
-			rule => unreachable!("unexpected rule: {:?}", rule),
-		},
-		None => unreachable!("expected rule"), // No literal found
-	};
-
-	if let Some(unit_pair) = pairs.next() {
-		let unit_pairs = unit_pair.into_inner(); // Get the inner pairs for the unit
-		let (unit, scale) = parse_unit(unit_pairs)?;
-
-		println!("found unit: {:?}", unit);
-
-		Ok((
-			match literal {
-				Literal::Float(num) => Literal::Float(num * scale),
-				Literal::Complex(num) => Literal::Complex(num * scale),
-			},
-			unit,
-		))
-	} else {
-		Ok((literal, Unit::BASE_UNIT))
-	}
-}
-
-fn parse_expr(pairs: Pairs<Rule>) -> Result<(Node, NodeMetadata), ParseError> {
-	PRATT_PARSER
-		.map_primary(|primary| {
-			Ok(match primary.as_rule() {
-				Rule::lit => {
-					let (lit, unit) = parse_lit(primary.into_inner())?;
-
-					(Node::Lit(lit), NodeMetadata { unit })
-				}
-				Rule::fn_call => {
-					let mut pairs = primary.into_inner();
-					let name = pairs.next().expect("fn_call always has 2 children").as_str().to_string();
-
-					(
-						Node::FnCall {
-							name,
-							expr: pairs.map(|p| parse_expr(p.into_inner()).map(|expr| expr.0)).collect::<Result<Vec<Node>, ParseError>>()?,
-						},
-						NodeMetadata::new(Unit::BASE_UNIT),
-					)
-				}
-				Rule::constant => {
-					let lit = parse_const(primary.into_inner().next().expect("constant should have atleast 1 child"));
-
-					(Node::Lit(lit), NodeMetadata::new(Unit::BASE_UNIT))
-				}
-				Rule::ident => {
-					let name = primary.as_str().to_string();
-
-					(Node::Var(name), NodeMetadata::new(Unit::BASE_UNIT))
-				}
-				Rule::expr => parse_expr(primary.into_inner())?,
-				Rule::float => {
-					let value = primary.as_str().parse::<f64>()?;
-					(Node::Lit(Literal::Float(value)), NodeMetadata::new(Unit::BASE_UNIT))
-				}
-				Rule::conditional => {
-					let mut inner = primary.into_inner();
-
-					let condition = parse_expr(inner.next().expect("expected conditional to have condition").into_inner())?;
-					let if_block = parse_expr(inner.next().expect("expected conditional to have if block").into_inner())?;
-					let else_block = parse_expr(inner.next().expect("expected conditional to have else block").into_inner())?;
-
-					(
-						Node::Conditional {
-							condition: Box::new(condition.0),
-							if_block: Box::new(if_block.0),
-							else_block: Box::new(else_block.0),
-						},
-						if_block.1,
-					)
-				}
-				rule => unreachable!("unexpected rule: {:?}", rule),
-			})
-		})
-		.map_prefix(|op, rhs| {
-			let (rhs, rhs_metadata) = rhs?;
-			let op = match op.as_rule() {
-				Rule::neg => UnaryOp::Neg,
-				Rule::sqrt => UnaryOp::Sqrt,
-
-				rule => unreachable!("unexpected rule: {:?}", rule),
-			};
-
-			let node = Node::UnaryOp { expr: Box::new(rhs), op };
-			let unit = rhs_metadata.unit;
-
-			let unit = if !unit.is_base() {
-				match op {
-					UnaryOp::Sqrt if unit.length % 2 == 0 && unit.mass % 2 == 0 && unit.time % 2 == 0 => Unit {
-						length: unit.length / 2,
-						mass: unit.mass / 2,
-						time: unit.time / 2,
-					},
-					UnaryOp::Neg => unit,
-					op => return Err(ParseError::Type(TypeError::InvalidUnaryOp(unit, op))),
-				}
-			} else {
-				Unit::BASE_UNIT
-			};
-
-			Ok((node, NodeMetadata::new(unit)))
-		})
-		.map_postfix(|lhs, op| {
-			let op = match op.as_rule() {
-				Rule::EOI => return lhs,
-				rule => unreachable!("unexpected rule: {:?}", rule),
-			};
-		})
-		.map_infix(|lhs, op, rhs| {
-			let (lhs, lhs_metadata) = lhs?;
-			let (rhs, rhs_metadata) = rhs?;
-
-			let op = match op.as_rule() {
-				Rule::add => BinaryOp::Add,
-				Rule::sub => BinaryOp::Sub,
-				Rule::mul => BinaryOp::Mul,
-				Rule::div => BinaryOp::Div,
-				Rule::pow => BinaryOp::Pow,
-				Rule::paren => BinaryOp::Mul,
-				Rule::leq => BinaryOp::Leq,
-				Rule::geq => BinaryOp::Geq,
-				Rule::eq => BinaryOp::Eq,
-				rule => unreachable!("unexpected rule: {:?}", rule),
-			};
-
-			let (lhs_unit, rhs_unit) = (lhs_metadata.unit, rhs_metadata.unit);
-
-			let unit = match (!lhs_unit.is_base(), !rhs_unit.is_base()) {
-				(true, true) => match op {
-					BinaryOp::Mul => Unit {
-						length: lhs_unit.length + rhs_unit.length,
-						mass: lhs_unit.mass + rhs_unit.mass,
-						time: lhs_unit.time + rhs_unit.time,
-					},
-					BinaryOp::Div => Unit {
-						length: lhs_unit.length - rhs_unit.length,
-						mass: lhs_unit.mass - rhs_unit.mass,
-						time: lhs_unit.time - rhs_unit.time,
-					},
-					BinaryOp::Add | BinaryOp::Sub => {
-						if lhs_unit == rhs_unit {
-							lhs_unit
-						} else {
-							return Err(ParseError::Type(TypeError::InvalidBinaryOp(lhs_unit, op, rhs_unit)));
-						}
-					}
-					BinaryOp::Pow => {
-						return Err(ParseError::Type(TypeError::InvalidBinaryOp(lhs_unit, op, rhs_unit)));
-					}
-					BinaryOp::Eq | BinaryOp::Leq | BinaryOp::Geq => {
-						if lhs_unit == rhs_unit {
-							Unit::base_unit()
-						} else {
-							return Err(ParseError::Type(TypeError::InvalidBinaryOp(lhs_unit, op, rhs_unit)));
-						}
-					}
-				},
-
-				(true, false) => match op {
-					BinaryOp::Add | BinaryOp::Sub => return Err(ParseError::Type(TypeError::InvalidBinaryOp(lhs_unit, op, Unit::BASE_UNIT))),
-					BinaryOp::Pow => {
-						//TODO: improve error type
-						//TODO: support fractions
-						if let Ok(Value::Number(Number::Real(val))) = rhs.eval(&EvalContext::default()) {
-							if (val - val as i32 as f64).abs() <= f64::EPSILON {
-								Unit {
-									length: lhs_unit.length * val.round() as i32,
-									mass: lhs_unit.mass * val.round() as i32,
-									time: lhs_unit.time * val as i32,
-								}
-							} else {
-								return Err(ParseError::Type(TypeError::InvalidBinaryOp(lhs_unit, op, Unit::BASE_UNIT)));
-							}
-						} else {
-							return Err(ParseError::Type(TypeError::InvalidBinaryOp(lhs_unit, op, Unit::BASE_UNIT)));
-						}
-					}
-					_ => lhs_unit,
-				},
-				(false, true) => match op {
-					BinaryOp::Add | BinaryOp::Sub | BinaryOp::Pow => return Err(ParseError::Type(TypeError::InvalidBinaryOp(Unit::BASE_UNIT, op, rhs_unit))),
-					_ => rhs_unit,
-				},
-				(false, false) => Unit::BASE_UNIT,
-			};
-
-			let node = Node::BinOp {
-				lhs: Box::new(lhs),
-				op,
-				rhs: Box::new(rhs),
-			};
-
-			Ok((node, NodeMetadata::new(unit)))
-		})
-		.parse(pairs)
-}*/
-
-//TODO: set up Unit test for Units
 #[cfg(test)]
 mod tests {
 	use super::*;