refactor: use lib.rs in main.rs

this avoids duplicating unit tests, for instance

https://stackoverflow.com/a/77038955

src/formatting.rs

@@ -49,20 +49,20 @@ pub fn pretty_eval(mut input: String, max_digits: usize) -> Result<String, Error
 }
 #[test]
 fn test_character_readdition() {
-    assert_eq!(pretty_eval(" = 11".into()).unwrap(), " = 11");
-    assert_eq!(pretty_eval(" &= 11".into()).unwrap(), " & = 11");
-    assert_eq!(pretty_eval(" & 11".into()).unwrap(), " & 11");
-    assert_eq!(pretty_eval(" & 11 \\".into()).unwrap(), " & 11 \\");
+    assert_eq!(pretty_eval(" = 11".into(), 10).unwrap(), " = 11");
+    assert_eq!(pretty_eval(" &= 11".into(), 10).unwrap(), " & = 11");
+    assert_eq!(pretty_eval(" & 11".into(), 10).unwrap(), " & 11");
+    assert_eq!(pretty_eval(" & 11 \\".into(), 10).unwrap(), " & 11 \\");
 }
 #[test]
 fn test_basic_up_to_999() {
-    assert_eq!(pretty_eval("1".into()).unwrap(), "1");
-    assert_eq!(pretty_eval("10".into()).unwrap(), "10");
-    assert_eq!(pretty_eval("100".into()).unwrap(), "100");
-    assert_eq!(pretty_eval("999".into()).unwrap(), "999");
-    assert_eq!(pretty_eval("1000".into()).unwrap(), "1 * 10^3");
+    assert_eq!(pretty_eval("1".into(), 10).unwrap(), "1");
+    assert_eq!(pretty_eval("10".into(), 10).unwrap(), "10");
+    assert_eq!(pretty_eval("100".into(), 10).unwrap(), "100");
+    assert_eq!(pretty_eval("999".into(), 10).unwrap(), "999");
+    assert_eq!(pretty_eval("1000".into(), 10).unwrap(), "1 * 10^3");
 
-    assert_eq!(pretty_eval("11.111111".into()).unwrap(), "11.111111");
+    assert_eq!(pretty_eval("11.111111".into(), 10).unwrap(), "11.111111");
 }
 
 pub fn get_significant_digits(n: &Float) -> usize {

src/main.rs

@@ -4,8 +4,7 @@ use std::{
     process::ExitCode,
 };
 
-mod formatting;
-mod nodes;
+use tylc as lib;
 
 fn main() -> ExitCode {
     let input = match env::args().skip(1).rev().reduce(|x, a| a + &x) {
@@ -17,7 +16,7 @@ fn main() -> ExitCode {
         }
     };
 
-    match formatting::pretty_eval(input, 10) {
+    match lib::formatting::pretty_eval(input, 10) {
         Ok(s) => println!("{s}"),
 
         Err(e) => {

src/nodes/parse.rs

@@ -1,9 +1,9 @@
 use core::f64;
 use std::str::FromStr;
 
-use rug::{Float, float::ParseFloatError, ops::CompleteRound};
+use rug::{Float, float::ParseFloatError};
 
-use crate::nodes::{Function, Node, Nodes, Operator, PREC};
+use crate::nodes::{Function, Node, Nodes, Operator};
 
 impl Node {
     fn from_name(s: &str) -> Result<Self, String> {
@@ -124,15 +124,10 @@ impl FromStr for Nodes {
                         && !(c == 'e' && filtered_string.chars().nth(i + 1).is_some_and(|c| c == '-'))
                         && !(c == '-' && filtered_string.chars().nth(i - 1).is_some_and(|c| c == 'e'))
                     {
-                        nodes.push(Node::Number(
-                            Float::parse(&filtered_string[start_index..i])
-                                .map_err(|e| {
-                                    Error::NumberParsing(
-                                        filtered_string[start_index..i].to_owned(),
-                                        e,
-                                    )
-                                })?
-                                .complete(PREC),
+                        nodes.push(Node::from(
+                            Float::parse(&filtered_string[start_index..i]).map_err(|e| {
+                                Error::NumberParsing(filtered_string[start_index..i].to_owned(), e)
+                            })?,
                         ));
 
                         state = ParsingState::Start;
@@ -182,12 +177,10 @@ impl FromStr for Nodes {
                 if matches!(nodes.last(), Some(Node::ParenthesisEnd)) {
                     nodes.push(Node::Operator(Default::default()));
                 }
-                nodes.push(Node::Number(
-                    Float::parse(&filtered_string[start_index..i])
-                        .map_err(|e| {
-                            Error::NumberParsing(filtered_string[start_index..i].to_owned(), e)
-                        })?
-                        .complete(PREC),
+                nodes.push(Node::from(
+                    Float::parse(&filtered_string[start_index..i]).map_err(|e| {
+                        Error::NumberParsing(filtered_string[start_index..i].to_owned(), e)
+                    })?,
                 ));
             }
         }