Removed the struct

src/lib.rs

@@ -1,155 +1,105 @@
-#[allow(dead_code)]
+mod test;
-pub struct NumText {
+/// Convert digit to text.
-    number: u32,
+pub fn digit_to_text(digit: u8) -> Option<String> {
-    text: String,
+    match digit {
+        0 => Some("".to_string()),
+        1 => Some("one".to_string()),
+        2 => Some("two".to_string()),
+        3 => Some("three".to_string()),
+        4 => Some("four".to_string()),
+        5 => Some("five".to_string()),
+        6 => Some("six".to_string()),
+        7 => Some("seven".to_string()),
+        8 => Some("eight".to_string()),
+        9 => Some("nine".to_string()),
+        _ => None,
+    }
 }
 
-#[allow(dead_code, unused_variables)]
+fn tens_place(tens: u8, ones: u8) -> Option<String> {
-impl NumText {
+    match tens {
-    fn new(number: u32) -> Self {
+        0 => digit_to_text(ones),
-        NumText {
+        1 => match ones {
-            number,
+            0 => Some("ten".to_string()),
-            text: NumText::to_text(number),
+            1 => Some("eleven".to_string()),
-        }
+            2 => Some("twelve".to_string()),
-    }
+            3 => Some("thirteen".to_string()),
-    fn digit_to_text(digit: u8) -> Option<String> {
+            4 => Some("fourteen".to_string()),
-        match digit {
+            5 => Some("fifteen".to_string()),
-            // 0 => Some("zero".to_string()),
+            6 => Some("sixteen".to_string()),
-            0 => Some("".to_string()),
+            7 => Some("seventeen".to_string()),
-            1 => Some("one".to_string()),
+            8 => Some("eighteen".to_string()),
-            2 => Some("two".to_string()),
+            9 => Some("nineteen".to_string()),
-            3 => Some("three".to_string()),
-            4 => Some("four".to_string()),
-            5 => Some("five".to_string()),
-            6 => Some("six".to_string()),
-            7 => Some("seven".to_string()),
-            8 => Some("eight".to_string()),
-            9 => Some("nine".to_string()),
             _ => None,
-        }
+        },
-    }
+        d @ 2..=5 | d @ 8 => Some({
-
+            let mut buffer = String::new();
-    fn tens_place(tens: u8, ones: u8) -> Option<String> {
+            match d {
-        match tens {
+                2 => buffer.push_str("twenty"),
-            0 => NumText::digit_to_text(ones),
+                3 => buffer.push_str("thirty"),
-            1 => match ones {
+                4 => buffer.push_str("forty"),
-                0 => Some("ten".to_string()),
+                5 => buffer.push_str("fifty"),
-                1 => Some("eleven".to_string()),
+                8 => buffer.push_str("eighty"),
-                2 => Some("twelve".to_string()),
+                _ => (),
-                3 => Some("thirteen".to_string()),
-                4 => Some("fourteen".to_string()),
-                5 => Some("fifteen".to_string()),
-                6 => Some("sixteen".to_string()),
-                7 => Some("seventeen".to_string()),
-                8 => Some("eighteen".to_string()),
-                9 => Some("nineteen".to_string()),
-                _ => None,
-            },
-            d @ 2..=5 | d @ 8 => Some({
-                let mut buffer = String::new();
-                match d {
-                    2 => buffer.push_str("twenty"),
-                    3 => buffer.push_str("thirty"),
-                    4 => buffer.push_str("forty"),
-                    5 => buffer.push_str("fifty"),
-                    8 => buffer.push_str("eighty"),
-                    _ => (),
-                }
-                buffer.push_str(NumText::digit_to_text(ones).unwrap().as_str());
-                buffer
-            }),
-            d @ 6..=9 => Some({
-                let mut string = NumText::digit_to_text(d).unwrap() + "ty";
-                string.push_str(NumText::digit_to_text(ones).unwrap().as_str());
-                string
-            }),
-            _ => None,
-        }
-    }
-    fn place_value(number: u8, place: u8) -> Option<String> {
-        match place {
-            p @ 3..=6 => Some({
-                let mut value = Self::digit_to_text(number).unwrap();
-                match p {
-                    3 => value.push_str("hundred"),
-                    4 => value.push_str("thousand"),
-                    // 5 => value.push_str("placeholder"),
-                    6 => value.push_str("million"),
-                    _ => (),
-                }
-                value
-            }),
-            _ => None,
-        }
-    }
-
-    fn to_text(number: u32) -> String {
-        let mut numtext: String = String::new();
-        let digits: Vec<u8> = number
-            .to_string()
-            .chars()
-            .map(|d| d.to_digit(10).unwrap() as u8)
-            .collect();
-        let second_digit_array: [usize; 2] = [0, 3];
-        let mut last: Option<u8> = None;
-        for (index, digit) in digits.iter().rev().enumerate() {
-            if second_digit_array.contains(&index) {
-                last = Some(digit.clone());
-                continue;
             }
-            if let Some(last_digit) = last {
+            buffer.push_str(digit_to_text(ones).unwrap().as_str());
-                let mut buffer = String::new();
+            buffer
-                buffer.push_str(
+        }),
-                    Self::tens_place(digit.clone(), last_digit)
+        d @ 6..=9 => Some({
-                        .unwrap()
+            let mut string = digit_to_text(d).unwrap() + "ty";
-                        .as_str(),
+            string.push_str(digit_to_text(ones).unwrap().as_str());
-                );
+            string
-                if index > 2 {
+        }),
-                    buffer.push_str(Self::place_value(0, index as u8).unwrap().as_str());
+        _ => None,
-                }
+    }
-                numtext.insert_str(0, buffer.as_str());
+}
-                last = None;
+fn place_value(number: u8, place: u8) -> Option<String> {
-            } else {
+    match place {
-                numtext.insert_str(
+        p @ 3..=6 => Some({
-                    0,
+            let mut value = digit_to_text(number).unwrap();
-                    Self::place_value(digit.clone(), index as u8 + 1)
+            match p {
-                        .unwrap()
+                3 => value.push_str("hundred"),
-                        .as_str(),
+                4 => value.push_str("thousand"),
-                )
+                // 5 => value.push_str("placeholder"),
+                6 => value.push_str("million"),
+                _ => (),
             }
+            value
+        }),
+        _ => None,
+    }
+}
+/// Convert u32 to words in a string.
+pub fn to_text(number: u32) -> String {
+    let mut numtext: String = String::new();
+    let digits: Vec<u8> = number
+        .to_string()
+        .chars()
+        .map(|d| d.to_digit(10).unwrap() as u8)
+        .collect();
+    let second_digit_array: [usize; 2] = [0, 3];
+    let mut last: Option<u8> = None;
+    for (index, digit) in digits.iter().rev().enumerate() {
+        if second_digit_array.contains(&index) {
+            last = Some(digit.clone());
+            continue;
+        }
+        if let Some(last_digit) = last {
+            let mut buffer = String::new();
+            buffer.push_str(tens_place(digit.clone(), last_digit).unwrap().as_str());
+            if index > 2 {
+                buffer.push_str(place_value(0, index as u8).unwrap().as_str());
+            }
+            numtext.insert_str(0, buffer.as_str());
+            last = None;
+        } else {
+            numtext.insert_str(
+                0,
+                place_value(digit.clone(), index as u8 + 1)
+                    .unwrap()
+                    .as_str(),
+            )
         }
-        numtext
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn digits() {
-        use crate::NumText;
-        assert_eq!(NumText::digit_to_text(9).unwrap(), "nine");
-    }
-    #[test]
-    fn numbers() {
-        use crate::NumText;
-        assert_eq!(
-            NumText::to_text(12345),
-            "twelvethousandthreehundredfortyfive"
-        );
-        assert_eq!(
-            NumText::to_text(81123),
-            "eightyonethousandonehundredtwentythree"
-        );
-        assert_eq!(NumText::to_text(12), "twelve");
-    }
-    #[test]
-    fn tens() {
-        use crate::NumText;
-        assert_eq!(NumText::tens_place(1, 2).unwrap(), "twelve");
-        assert_eq!(NumText::tens_place(7, 6).unwrap(), "seventysix");
-        assert_eq!(NumText::tens_place(5, 7).unwrap(), "fiftyseven");
-        assert_eq!(NumText::tens_place(2, 3).unwrap(), "twentythree");
-        assert_eq!(NumText::tens_place(6, 9).unwrap(), "sixtynine");
-        assert_eq!(NumText::tens_place(0, 9).unwrap(), "nine");
     }
+    numtext
 }

src/test.rs

@@ -0,0 +1,25 @@
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn digits() {
+        use crate::digit_to_text;
+        assert_eq!(digit_to_text(9).unwrap(), "nine");
+    }
+    #[test]
+    fn numbers() {
+        use crate::to_text;
+        assert_eq!(to_text(12345), "twelvethousandthreehundredfortyfive");
+        assert_eq!(to_text(81123), "eightyonethousandonehundredtwentythree");
+        assert_eq!(to_text(12), "twelve");
+    }
+    #[test]
+    fn tens() {
+        use crate::tens_place;
+        assert_eq!(tens_place(1, 2).unwrap(), "twelve");
+        assert_eq!(tens_place(7, 6).unwrap(), "seventysix");
+        assert_eq!(tens_place(5, 7).unwrap(), "fiftyseven");
+        assert_eq!(tens_place(2, 3).unwrap(), "twentythree");
+        assert_eq!(tens_place(6, 9).unwrap(), "sixtynine");
+        assert_eq!(tens_place(0, 9).unwrap(), "nine");
+    }
+}