From 5904eec65961a3fb07bc18dcb07838516cf6cbc2 Mon Sep 17 00:00:00 2001
From: Philippe Assis <codephilippe@gmail.com>
Date: Mon, 30 Dec 2024 18:06:49 -0300
Subject: [PATCH 1/2] Refactor TryFrom implementation for Number struct to
 simplify parsing logic

---
 valu3/src/types/number.rs | 72 +++++++++++++++++++--------------------
 1 file changed, 36 insertions(+), 36 deletions(-)

diff --git a/valu3/src/types/number.rs b/valu3/src/types/number.rs
index 45e58f8..cb9dc7b 100644
--- a/valu3/src/types/number.rs
+++ b/valu3/src/types/number.rs
@@ -906,43 +906,43 @@ impl TryFrom<&str> for Number {
     type Error = Error;
 
     fn try_from(value: &str) -> Result<Self, Self::Error> {
-        match value.parse::<i32>() {
-            Ok(value) => Ok(Self::from(value)),
-            Err(_) => match value.parse::<f64>() {
-                Ok(value) => Ok(Self::from(value)),
-                Err(_) => match value.parse::<i8>() {
-                    Ok(value) => Ok(Self::from(value)),
-                    Err(_) => match value.parse::<i16>() {
-                        Ok(value) => Ok(Self::from(value)),
-                        Err(_) => match value.parse::<i64>() {
-                            Ok(value) => Ok(Self::from(value)),
-                            Err(_) => match value.parse::<i128>() {
-                                Ok(value) => Ok(Self::from(value)),
-                                Err(_) => match value.parse::<u8>() {
-                                    Ok(value) => Ok(Self::from(value)),
-                                    Err(_) => match value.parse::<u16>() {
-                                        Ok(value) => Ok(Self::from(value)),
-                                        Err(_) => match value.parse::<u32>() {
-                                            Ok(value) => Ok(Self::from(value)),
-                                            Err(_) => match value.parse::<u64>() {
-                                                Ok(value) => Ok(Self::from(value)),
-                                                Err(_) => match value.parse::<u128>() {
-                                                    Ok(value) => Ok(Self::from(value)),
-                                                    Err(_) => match value.parse::<f32>() {
-                                                        Ok(value) => Ok(Self::from(value)),
-                                                        Err(_) => Err(Error::NotNumber),
-                                                    },
-                                                },
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
+        if let Ok(parsed) = value.parse::<i32>() {
+            return Ok(Self::from(parsed));
         }
+        if let Ok(parsed) = value.parse::<f64>() {
+            return Ok(Self::from(parsed));
+        }
+        if let Ok(parsed) = value.parse::<i8>() {
+            return Ok(Self::from(parsed));
+        }
+        if let Ok(parsed) = value.parse::<i16>() {
+            return Ok(Self::from(parsed));
+        }
+        if let Ok(parsed) = value.parse::<i64>() {
+            return Ok(Self::from(parsed));
+        }
+        if let Ok(parsed) = value.parse::<i128>() {
+            return Ok(Self::from(parsed));
+        }
+        if let Ok(parsed) = value.parse::<u8>() {
+            return Ok(Self::from(parsed));
+        }
+        if let Ok(parsed) = value.parse::<u16>() {
+            return Ok(Self::from(parsed));
+        }
+        if let Ok(parsed) = value.parse::<u32>() {
+            return Ok(Self::from(parsed));
+        }
+        if let Ok(parsed) = value.parse::<u64>() {
+            return Ok(Self::from(parsed));
+        }
+        if let Ok(parsed) = value.parse::<u128>() {
+            return Ok(Self::from(parsed));
+        }
+        if let Ok(parsed) = value.parse::<f32>() {
+            return Ok(Self::from(parsed));
+        }
+        Err(Error::NotNumber)
     }
 }
 

From 06fc56d5b8dc21580e176e188f6a23b9abbc1ebd Mon Sep 17 00:00:00 2001
From: Philippe Assis <codephilippe@gmail.com>
Date: Mon, 30 Dec 2024 18:10:01 -0300
Subject: [PATCH 2/2] Add test for Value struct conversion from u32 to u64

---
 valu3/src/impls.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/valu3/src/impls.rs b/valu3/src/impls.rs
index 91b7038..a2f5480 100644
--- a/valu3/src/impls.rs
+++ b/valu3/src/impls.rs
@@ -960,6 +960,9 @@ mod tests {
     fn test_value_number_behavior() {
         let value = Value::from(3.14);
         assert_eq!(value.get_f64_unsafe(), 3.14);
+
+        let value2 = Value::from(42u32);
+        assert_eq!(value2.to_u64(), Some(42));
     }
 
     #[test]