Implement Arbitrary int and floats as strings for full roundtrip pars…

…e/emit. No implementation/checks are done.

README.md

@@ -368,6 +368,7 @@ fn complex_ok() -> Result<(), EdnError> {
     - [x] nil `""`
     - [x] String `"\"string\""`
     - [x] Numbers `"324352"`, `"3442.234"`, `"3/4"`
+    - [x] Arbitrary Numbers `"4650481213195981094N"`, `"-6.731982E-96M"`. These are stored as strings and not checked for correctness
     - [x] Keywords `:a`
     - [x] Symbol `sym-bol-s` with a maximum of 200 chars
     - [x] Vector `"[1 :2 \"d\"]"`

src/deserialize/parse.rs

@@ -286,6 +286,8 @@ fn read_number(
             let mut n = n.chars();
             read_symbol(n.next().unwrap_or(' '), &mut n.enumerate())
         }
+        n if n.to_uppercase().ends_with('N') => Ok(Edn::ArbitraryInt(n)),
+        n if n.to_uppercase().ends_with('M') => Ok(Edn::ArbitraryFloat(n)),
         _ => Err(Error::ParseEdn(format!(
             "{number} could not be parsed with radix {radix}"
         ))),

src/edn/mod.rs

@@ -31,6 +31,8 @@ pub enum Edn {
     Str(String),
     Int(i64),
     UInt(u64),
+    ArbitraryInt(String),
+    ArbitraryFloat(String),
     Double(Double),
     Rational(String),
     Char(char),
@@ -249,6 +251,8 @@ impl core::fmt::Display for Edn {
             Self::Str(s) => format!("{s:?}"),
             Self::Int(i) => format!("{i}"),
             Self::UInt(u) => format!("{u}"),
+            Self::ArbitraryInt(i) => i.to_string(),
+            Self::ArbitraryFloat(f) => f.to_string(),
             Self::Double(d) => format!("{d}"),
             Self::Rational(r) => r.to_string(),
             Self::Bool(b) => format!("{b}"),

src/edn/utils/index.rs

@@ -138,6 +138,8 @@ impl<'a> fmt::Display for Type<'a> {
             Edn::Nil => formatter.write_str("null"),
             Edn::Bool(_) => formatter.write_str("boolean"),
             Edn::Int(_) | Edn::UInt(_) => formatter.write_str("integer"),
+            Edn::ArbitraryInt(_) => formatter.write_str("arbitraryint"),
+            Edn::ArbitraryFloat(_) => formatter.write_str("arbitraryfloat"),
             Edn::Str(_) => formatter.write_str("string"),
             Edn::Vector(_) => formatter.write_str("vector"),
             #[cfg(feature = "sets")]

src/json/mod.rs

@@ -11,6 +11,8 @@ pub fn display_as_json(edn: &Edn) -> String {
         Edn::Symbol(s) | Edn::Str(s) => format!("{s:?}"),
         Edn::Int(n) => format!("{n}"),
         Edn::UInt(n) => format!("{n}"),
+        Edn::ArbitraryInt(i) => format!("{i:?}"),
+        Edn::ArbitraryFloat(f) => format!("{f:?}"),
         Edn::Double(n) => {
             // Rust formats an f64 with a value of 2^5 as "32".
             // We do this to ensure all precision is printed if available, but still adds a decimal point for json.

tests/deserialize.rs

@@ -982,4 +982,12 @@ mod test {
             ]))
         );
     }
+
+    #[test]
+    fn arbitrary_numbers() {
+        assert_eq!(
+            Edn::from_str("[-6.731982E-96M 4650481213195981094106568258513747645404361846863540722905990782512657236531968143067223662542170794755N]").unwrap(),
+            Edn::Vector(Vector::new(vec![Edn::ArbitraryFloat("-6.731982E-96M".to_string()), Edn::ArbitraryInt("4650481213195981094106568258513747645404361846863540722905990782512657236531968143067223662542170794755N".to_string())]))
+        )
+    }
 }