refactored

src/main.rs

@@ -1,21 +1,42 @@
 use rand::Rng;
 use std::cmp::Ordering;
 
+fn parse_input() -> Option<u32> {
+
+    loop {
+
+        let mut input = String::new();
+        std::io::stdin()
+        .read_line(&mut input)
+        .unwrap();
+
+        match input.trim().parse::<u32>() {
+
+            Ok(output) => return Some(output),
+
+            Err(why) => {
+
+                match input.trim() {
+
+                    "quit" | ":q" | "q" | "stop" | "exit" => { println!("Stopping..."); return None; }
+                    _ => { println!("{} is not a number!", input); }
+
+                }
+            }
+        };
+    }
+}
+
 fn main() {
 
     println!("Welcome to bingame! Type \"quit\" anytime to stop playing.");
-
-    let mut liminput = String::new();
-
     println!("Provide an upward limit for generated numbers: ");
-    std::io::stdin()
-    .read_line(&mut liminput)
-    .unwrap();
+    let limit = parse_input().unwrap();
+    game(limit)
 
-    let limit = liminput
-        .trim()
-        .parse::<u32>()
-        .unwrap();
+}
+
+fn numgen(limit: u32) -> Result<(u32, u32), bool> {
 
     // generate random number
 
@@ -42,28 +63,35 @@ fn main() {
 
     }
 
-    let binary = binnery
-    .parse::<u32>()
-    .unwrap();
+    let binnery = binnery.parse::<u32>();
 
-    println!("Type {} in binary", nombre);
-    let mut input = String::new();
+    let binary = match binnery {
 
-    std::io::stdin()
-    .read_line(&mut input)
-    .unwrap();
+        Ok(binary) => { binary },
+        Err(why) => { std::process::abort(); }
+    };
 
-    let guess = input
-    .trim()
-    .parse::<u32>()
-    .unwrap();
+    return Ok((nombre, binary));
+}
 
-    match guess.cmp(&binary) {
-        Ordering::Equal => {
-            println!("That's correct! {} in binary is {}!", nombre, binnery);
-        }
-        Ordering::Greater | Ordering::Less => {
-            println!("Nope! {} in binary is {}!", nombre, binnery);
+fn game(limit: u32) {
+
+    loop {
+
+        let ans = numgen(limit).unwrap();
+        let nombre = ans.0;
+        let binary = ans.1;
+
+        println!("Type {} in binary", nombre);
+        let guess = parse_input().unwrap();
+
+        match guess.cmp(&binary) {
+            Ordering::Equal => {
+                println!("That's correct! {} in binary is {}!", nombre, binary);
+            }
+            Ordering::Greater | Ordering::Less => {
+                println!("Nope! {} in binary is {}!", nombre, binary);
+            }
         }
     }
 }