add lexing stage, make variables and functions prefixed to prepare for

urisinger · urisinger · commit 50be35283af1 · 2025-06-09T15:43:21.000+03:00
implicit multiplication
diff --git a/libraries/math-parser/src/ast.rs b/libraries/math-parser/src/ast.rs
@@ -37,7 +37,7 @@ impl Unit {
 	}
 }
 
-#[derive(Debug, PartialEq)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum Literal {
 	Float(f64),
 	Complex(Complex),
diff --git a/libraries/math-parser/src/constants.rs b/libraries/math-parser/src/constants.rs
@@ -9,6 +9,14 @@ lazy_static! {
 	pub static ref DEFAULT_FUNCTIONS: HashMap<&'static str, FunctionImplementation> = {
 		let mut map: HashMap<&'static str, FunctionImplementation> = HashMap::new();
 
+		map.insert(
+			"sqrt",
+			Box::new(|values| match values{
+				[Value::Number(Number::Real(real))] => Some(Value::Number(Number::Real(real.sqrt()))),
+				[Value::Number(Number::Complex(complex))] => Some(Value::Number(Number::Complex(complex.sqrt()))),
+				_ => None,
+			})
+		);
 		map.insert(
 			"sin",
 			Box::new(|values| match values {
diff --git a/libraries/math-parser/src/lexer.rs b/libraries/math-parser/src/lexer.rs
@@ -0,0 +1,159 @@
+// ── lexer.rs ───────────────────────────────────────────────────────────
+use crate::ast::Literal;
+use chumsky::input::{Input, ValueInput};
+use chumsky::prelude::*;
+use chumsky::span::SimpleSpan;
+use chumsky::text::{ident, int};
+use num_complex::Complex64;
+use std::ops::Range;
+
+pub type Span = SimpleSpan;
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum Token<'src> {
+	// literals ----------------------------------------------------------------
+	Const(Literal), // numeric or complex constants recognised at lex‑time
+	Var(&'src str), //  #identifier  (variables)
+	Call(&'src str),
+	// punctuation -------------------------------------------------------------
+	LParen,
+	RParen,
+	Comma,
+	Plus,
+	Minus,
+	Star,
+	Slash,
+	Caret,
+	// comparison --------------------------------------------------------------
+	Lt,
+	Le,
+	Gt,
+	Ge,
+	EqEq,
+	// keywords ----------------------------------------------------------------
+	If,
+}
+
+pub fn lexer<'src>() -> impl Parser<'src, &'src str, Vec<(Token<'src>, Span)>, extra::Err<Rich<'src, char>>> {
+	// ── numbers ────────────────────────────────────────────────────────────
+	let num = int(10)
+		.then(just('.').then(int(10)).or_not())
+		.then(just('e').or(just('E')).then(one_of("+-").or_not()).then(int(10)).or_not())
+		.map(|((int_part, frac), exp): ((&str, _), _)| {
+			let mut s = int_part.to_string();
+			if let Some((_, frac)) = frac {
+				s.push('.');
+				s.push_str(frac);
+			}
+			if let Some(((e, sign), exp)) = exp {
+				s.push(e);
+				if let Some(sign) = sign {
+					s.push(sign);
+				}
+				s.push_str(exp);
+			}
+			Token::Const(Literal::Float(s.parse::<f64>().unwrap()))
+		});
+
+	// ── single‑char symbols ────────────────────────────────────────────────
+	let sym = choice((
+		just('(').to(Token::LParen),
+		just(')').to(Token::RParen),
+		just(',').to(Token::Comma),
+		just('+').to(Token::Plus),
+		just('-').to(Token::Minus),
+		just('*').to(Token::Star),
+		just('/').to(Token::Slash),
+		just('^').to(Token::Caret),
+	));
+
+	// ── comparison operators ───────────────────────────────────────────────
+	let cmp = choice((
+		just("<=").to(Token::Le),
+		just(">=").to(Token::Ge),
+		just("==").to(Token::EqEq),
+		just('<').to(Token::Lt),
+		just('>').to(Token::Gt),
+	));
+
+	let kw_token = |w, t| just(w).padded().to(t);
+
+	let kw_lit = |w, lit: Literal| just(w).padded().to(lit);
+
+	let const_token = choice((
+		kw_lit("pi", Literal::Float(std::f64::consts::PI)),
+		kw_lit("π", Literal::Float(std::f64::consts::PI)),
+		kw_lit("tau", Literal::Float(std::f64::consts::TAU)),
+		kw_lit("τ", Literal::Float(std::f64::consts::TAU)),
+		kw_lit("e", Literal::Float(std::f64::consts::E)),
+		kw_lit("phi", Literal::Float(1.618_033_988_75)),
+		kw_lit("φ", Literal::Float(1.618_033_988_75)),
+		kw_lit("inf", Literal::Float(f64::INFINITY)),
+		kw_lit("∞", Literal::Float(f64::INFINITY)),
+		kw_lit("i", Literal::Complex(Complex64::new(0.0, 1.0))),
+		kw_lit("G", Literal::Float(9.80665)),
+	))
+	.map(Token::Const);
+
+	let var_token = just('#').ignore_then(ident()).map(Token::Var);
+	let call_token = just('@').ignore_then(ident()).map(Token::Call);
+
+	choice((num, kw_token("if", Token::If), const_token, cmp, sym, var_token, call_token))
+		.map_with(|t, e| (t, e.span()))
+		.padded()
+		.repeated()
+		.collect()
+}
+
+#[derive(Debug)]
+pub struct TokenStream<'src> {
+	tokens: Vec<(Token<'src>, Span)>,
+}
+
+impl<'src> TokenStream<'src> {
+	pub fn new(tokens: Vec<(Token<'src>, Span)>) -> Self {
+		TokenStream { tokens }
+	}
+}
+
+impl<'src> Input<'src> for TokenStream<'src> {
+	type Token = (Token<'src>, Span);
+	type Span = Span;
+	type Cursor = usize;
+	type MaybeToken = (Token<'src>, Span);
+	type Cache = Self;
+
+	fn begin(self) -> (Self::Cursor, Self::Cache) {
+		(0, self)
+	}
+
+	fn cursor_location(cursor: &Self::Cursor) -> usize {
+		*cursor
+	}
+
+	#[inline(always)]
+	unsafe fn next_maybe(this: &mut Self::Cache, cursor: &mut Self::Cursor) -> Option<Self::MaybeToken> {
+		if let Some(tok) = this.tokens.get(*cursor) {
+			*cursor += 1;
+			Some(tok.clone())
+		} else {
+			None
+		}
+	}
+
+	#[inline(always)]
+	unsafe fn span(_this: &mut Self::Cache, range: Range<&Self::Cursor>) -> Self::Span {
+		(*range.start..*range.end).into()
+	}
+}
+
+impl<'src> ValueInput<'src> for TokenStream<'src> {
+	unsafe fn next(this: &mut Self::Cache, cursor: &mut Self::Cursor) -> Option<Self::Token> {
+		if let Some(tok) = this.tokens.get(*cursor) {
+			*cursor += 1;
+			Some(tok.clone())
+		} else {
+			None
+		}
+	}
+}
diff --git a/libraries/math-parser/src/lib.rs b/libraries/math-parser/src/lib.rs
@@ -4,6 +4,7 @@ pub mod ast;
 mod constants;
 pub mod context;
 pub mod executer;
+pub mod lexer;
 pub mod parser;
 pub mod value;
 
@@ -95,22 +96,22 @@ mod tests {
 		order_of_operations_negative_prefix: "-10 + 5" => -5.,
 		order_of_operations_add_multiply: "5+1*1+5" => 11.,
 		order_of_operations_add_negative_multiply: "5+(-1)*1+5" => 9.,
-		order_of_operations_sqrt: "sqrt25 + 11" => 16.,
-		order_of_operations_sqrt_expression: "sqrt(25+11)" => 6.,
+		order_of_operations_sqrt: "@sqrt(25) + 11" => 16.,
+		order_of_operations_sqrt_expression: "@sqrt(25+11)" => 6.,
 
 		// Parentheses and nested expressions
 		parentheses_nested_multiply: "(5 + 3) * (2 + 6)" => 64.,
 		parentheses_mixed_operations: "2 * (3 + 5 * (2 + 1))" => 36.,
 		parentheses_divide_add_multiply: "10 / (2 + 3) + (7 * 2)" => 16.,
 
 		// Square root and nested square root
-		sqrt_chain_operations: "sqrt(16) + sqrt(9) * sqrt(4)" => 10.,
-		sqrt_nested: "sqrt(sqrt(81))" => 3.,
-		sqrt_divide_expression: "sqrt((25 + 11) / 9)" => 2.,
+		sqrt_chain_operations: "@sqrt(16) + @sqrt(9) * @sqrt(4)" => 10.,
+		sqrt_nested: "@sqrt(@sqrt(81))" => 3.,
+		sqrt_divide_expression: "@sqrt((25 + 11) / 9)" => 2.,
 
 		// Mixed square root and units
-		sqrt_add_multiply: "sqrt(49) - 1 + 2 * 3" => 12.,
-		sqrt_addition_multiply: "(sqrt(36) + 2) * 2" => 16.,
+		sqrt_add_multiply: "@sqrt(49) - 1 + 2 * 3" => 12.,
+		sqrt_addition_multiply: "(@sqrt(36) + 2) * 2" => 16.,
 
 		// Exponentiation
 		exponent_single: "2^3" => 8.,
@@ -119,10 +120,10 @@ mod tests {
 
 		// Operations with negative values
 		negative_nested_parentheses: "-(5 + 3 * (2 - 1))" => -8.,
-		negative_sqrt_addition: "-(sqrt(16) + sqrt(9))" => -7.,
-		multiply_sqrt_subtract: "5 * 2 + sqrt(16) / 2 - 3" => 9.,
-		add_multiply_subtract_sqrt: "4 + 3 * (2 + 1) - sqrt(25)" => 8.,
-		add_sqrt_subtract_nested_multiply: "10 + sqrt(64) - (5 * (2 + 1))" => 3.,
+		negative_sqrt_addition: "-(@sqrt(16) + @sqrt(9))" => -7.,
+		multiply_sqrt_subtract: "5 * 2 + @sqrt(16) / 2 - 3" => 9.,
+		add_multiply_subtract_sqrt: "4 + 3 * (2 + 1) - @sqrt(25)" => 8.,
+		add_sqrt_subtract_nested_multiply: "10 + @sqrt(64) - (5 * (2 + 1))" => 3.,
 
 		// Mathematical constants
 		constant_pi: "pi" => std::f64::consts::PI,
@@ -138,47 +139,44 @@ mod tests {
 		infinity_subtract_large_number: "inf - 1000" => f64::INFINITY,
 
 		// Trigonometric functions
-		trig_sin_pi: "sin(pi)" => 0.0,
-		trig_cos_zero: "cos(0)" => 1.0,
-		trig_tan_pi_div_four: "tan(pi/4)" => 1.0,
-		trig_sin_tau: "sin(tau)" => 0.0,
-		trig_cos_tau_div_two: "cos(tau/2)" => -1.0,
+		trig_sin_pi: "@sin(pi)" => 0.0,
+		trig_cos_zero: "@cos(0)" => 1.0,
+		trig_tan_pi_div_four: "@tan(pi/4)" => 1.0,
+		trig_sin_tau: "@sin(tau)" => 0.0,
+		trig_cos_tau_div_two: "@cos(tau/2)" => -1.0,
 
 		// Basic if statements
-		if_true_condition: "if(1){5} else {3}" => 5.,
-		if_false_condition: "if(0){5} else {3}" => 3.,
+		if_true_condition: "if(1,5,3)" => 5.,
+		if_false_condition: "if(0, 5, 3)" => 3.,
 
 		// Arithmetic conditions
-		if_arithmetic_true: "if(2+2-4){1} else {0}" => 0.,
-		if_arithmetic_false: "if(3*2-5){1} else {0}" => 1.,
+		if_arithmetic_true: "if(2+2-4, 1 , 0)" => 0.,
+		if_arithmetic_false: "if(3*2-5, 1, 0)" => 1.,
 
 		// Nested arithmetic
-		if_complex_arithmetic: "if((5+3)*(2-1)){10} else {20}" => 10.,
-		if_with_division: "if(8/4-2 == 0){15} else {25}" => 15.,
+		if_complex_arithmetic: "if((5+3)*(2-1), 10, 20)" => 10.,
+		if_with_division: "if(8/4-2 == 0,15, 25)" => 15.,
 
 		// Constants in conditions
-		if_with_pi: "if(pi > 3){1} else {0}" => 1.,
-		if_with_e: "if(e < 3){1} else {0}" => 1.,
+		if_with_pi: "if(pi > 3, 1, 0)" => 1.,
+		if_with_e: "if(e < 3, 1, 0)" => 1.,
 
 		// Functions in conditions
-		if_with_sqrt: "if(sqrt(16) == 4){1} else {0}" => 1.,
-		if_with_sin: "if(sin(pi) == 0.0){1} else {0}" => 0.,
+		if_with_sqrt: "if(@sqrt(16) == 4, 1, 0)" => 1.,
+		if_with_sin: "if(@sin(pi) == 0.0, 1, 0)" => 0.,
 
 		// Nested if statements
-		nested_if: "if(1){if(0){1} else {2}} else {3}" => 2.,
-		nested_if_complex: "if(2-2 == 0){if(1){5} else {6}} else {if(1){7} else {8}}" => 5.,
+		nested_if: "if(1, if(0, 1, 2), 3)" => 2.,
+		nested_if_complex: "if(2-2 == 0, if(1, 5, 6), if(1, 7, 8))" => 5.,
 
 		// Mixed operations in conditions and blocks
-		if_complex_condition: "if(sqrt(16) + sin(pi) < 5){2*pi} else {3*e}" => 2. * std::f64::consts::PI,
-		if_complex_blocks: "if(1){2*sqrt(16) + sin(pi/2)} else {3*cos(0) + 4}" => 9.,
+		if_complex_condition: "if(@sqrt(16) + @sin(pi) < 5, 2*pi, 3*e)" => 2. * std::f64::consts::PI,
+		if_complex_blocks: "if(1, 2*@sqrt(16) + @sin(pi/2), 3*@cos(0) + 4)" => 9.,
 
 		// Edge cases
-		if_zero: "if(0.0){1} else {2}" => 2.,
-		if_negative: "if(-1){1} else {2}" => 1.,
-		if_infinity: "if(inf){1} else {2}" => 1.,
-
+		if_zero: "if(0.0, 1, 2)" => 2.,
 
 		// Complex nested expressions
-		if_nested_expr: "if((sqrt(16) + 2) * (sin(pi) + 1)){3 + 4 * 2} else {5 - 2 / 1}" => 11.,
+		if_nested_expr: "if((@sqrt(16) + 2) * (@sin(pi) + 1), 3 + 4 * 2, 5 - 2 / 1)" => 11.,
 	}
 }
diff --git a/libraries/math-parser/src/parser.rs b/libraries/math-parser/src/parser.rs

Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ impl Unit {`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`
`40`		`-#[derive(Debug, PartialEq)]`
	`40`	`+#[derive(Debug, Clone, PartialEq)]`
`41`	`41`	`pub enum Literal {`
`42`	`42`	`Float(f64),`
`43`	`43`	`Complex(Complex),`