feat: ignore underscores in input

this isn't useful for typst usually,
since underscores are subscript and don't appear in expressions much.

however, when using tylc as a standalone calculator,
this is useful eg to seperate sets of three digits.

idea totally stolen from rust literals

flake.lock

@@ -20,15 +20,18 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1791260994,
+        "lastModified": 1780749050,
-        "narHash": "sha256-MFBjw66d4h06MvpW6lIl7RwarLteD0sk859CncGwb1Q=",
+        "narHash": "sha256-3av0pIjlOWQ6rDbNOmpUSvbNnJkGORQKKjb4LtCZsIY=",
-        "rev": "151fa4e8ddfdd8dd25d945ad94ed54a13de9f6e4",
+        "owner": "NixOS",
-        "type": "tarball",
+        "repo": "nixpkgs",
-        "url": "https://releases.nixos.org/nixos/unstable/nixos-26.11pre1086391.151fa4e8ddfd/nixexprs.tar.zst?lastModified=1791260994&rev=151fa4e8ddfdd8dd25d945ad94ed54a13de9f6e4"
+        "rev": "a799d3e3886da994fa307f817a6bc705ae538eeb",
+        "type": "github"
       },
       "original": {
-        "type": "tarball",
+        "owner": "NixOS",
-        "url": "https://channels.nixos.org/nixos-unstable/nixexprs.tar.zst"
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
       }
     },
     "root": {

flake.nix

@@ -1,6 +1,6 @@
 {
   inputs = {
-    nixpkgs.url = "https://channels.nixos.org/nixos-unstable/nixexprs.tar.zst";
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
 
     flake-utils.url = "github:numtide/flake-utils";
   };

src/formatting.rs

@@ -3,19 +3,20 @@ use rug::Float;
 use crate::nodes::{self, Error};
 
 pub fn pretty_eval(input: &str, max_digits: usize) -> Result<String, Error> {
-    let (prefix, deliminator, input) = input
+    let mut input = input.replace('_', "");
-        .rsplit_once('=')
-        .map(|(p, i)| (p, "= ", i))
-        .unwrap_or_else(|| {
-            input
-                .rsplit_once('&')
-                .map(|(p, i)| (p, "& ", i))
-                .unwrap_or(("", "", input))
-        });
 
-    // no need to remove the character here,
+    // no need to remove the characters here,
-    // as we ignore it in all other logic already
+    // as we ignore the them in all other logic already
+    let should_add_back_alignment = input.contains('&');
     let should_add_back_backslash = input.contains('\\');
+    let leading_spaces = input.chars().take_while(|c| *c == ' ').count();
+
+    let should_add_back_equals = input
+        .find('=')
+        .inspect(|i| {
+            input.remove(*i);
+        })
+        .is_some();
 
     let result = nodes::eval(&input)?;
     let display_digits =
@@ -33,11 +34,38 @@ pub fn pretty_eval(input: &str, max_digits: usize) -> Result<String, Error> {
             });
 
     Ok(format!(
-        "{prefix}{deliminator}{result:.display_digits$}{}",
+        "{}{}{result:.display_digits$}{}",
+        " ".repeat(leading_spaces),
+        if should_add_back_equals && should_add_back_alignment {
+            "& = "
+        } else if should_add_back_equals {
+            "= "
+        } else if should_add_back_alignment {
+            "& "
+        } else {
+            ""
+        },
         if should_add_back_backslash { " \\" } else { "" }
     )
     .replace('e', " * 10^"))
 }
+#[test]
+fn test_character_readdition() {
+    assert_eq!(pretty_eval(" = 11", 10).unwrap(), " = 11");
+    assert_eq!(pretty_eval(" &= 11", 10).unwrap(), " & = 11");
+    assert_eq!(pretty_eval(" & 11", 10).unwrap(), " & 11");
+    assert_eq!(pretty_eval(" & 11 \\", 10).unwrap(), " & 11 \\");
+}
+#[test]
+fn test_basic_up_to_999() {
+    assert_eq!(pretty_eval("1", 10).unwrap(), "1");
+    assert_eq!(pretty_eval("10", 10).unwrap(), "10");
+    assert_eq!(pretty_eval("100", 10).unwrap(), "100");
+    assert_eq!(pretty_eval("999", 10).unwrap(), "999");
+    assert_eq!(pretty_eval("1000", 10).unwrap(), "1 * 10^3");
+
+    assert_eq!(pretty_eval("11.111111", 10).unwrap(), "11.111111");
+}
 
 pub fn get_significant_digits(n: &Float) -> usize {
     let raw_string = n.to_string().replace('.', "");
@@ -73,33 +101,12 @@ pub fn get_significant_digits(n: &Float) -> usize {
 }
 
 #[cfg(test)]
-mod tests {
+fn eval(s: &str) -> Float {
-    use super::*;
-    fn eval(s: &str) -> Float {
     crate::nodes::eval(s).unwrap()
-    }
+}
 
-    #[test]
+#[test]
-    fn character_readdition() {
+fn test_get_significant_digits() {
-        assert_eq!(pretty_eval(" = 11", 10).unwrap(), " = 11");
-        assert_eq!(pretty_eval(" &= 11", 10).unwrap(), " &= 11");
-        assert_eq!(pretty_eval(" & 11", 10).unwrap(), " & 11");
-        assert_eq!(pretty_eval(" & 11 \\", 10).unwrap(), " & 11 \\");
-    }
-
-    #[test]
-    fn basic_output_up_to_999() {
-        assert_eq!(pretty_eval("1", 10).unwrap(), "1");
-        assert_eq!(pretty_eval("10", 10).unwrap(), "10");
-        assert_eq!(pretty_eval("100", 10).unwrap(), "100");
-        assert_eq!(pretty_eval("999", 10).unwrap(), "999");
-        assert_eq!(pretty_eval("1000", 10).unwrap(), "1 * 10^3");
-
-        assert_eq!(pretty_eval("11.111111", 10).unwrap(), "11.111111");
-    }
-
-    #[test]
-    fn basic_get_significant_digits() {
     let many_zeros = eval("14.00643 + 1.00784 * 4 + 35.446 + 15.9994 * 4");
     assert_eq!(many_zeros.to_f64(), 117.48139);
     let many_nines = eval("12.0096 + 15.9994 * 2");
@@ -113,5 +120,4 @@ mod tests {
     assert_eq!(get_significant_digits(&many_nines), 6);
     assert_eq!(get_significant_digits(&zero_nine_zero), 6);
     assert_eq!(get_significant_digits(&test_4), 7);
-    }
 }