Rust guessing game test

code review
1

Guessing game using @Pjdur's input function from here.

use rand::Rng;
use std::io::{self, Write};
fn main() {
    let player_input: String = input("Guess my number!: ");
    let random_number: i32 = rand::rng().random_range(1..=10);
    let player_input_new: i32 = player_input.parse().unwrap_or(-1);
    let is_it_the_same: bool = player_input_new == random_number;
    let the_string: &'static str;
    if is_it_the_same {
        the_string = "You"
    } else {
        the_string = "I"
    }
    if player_input_new == -1 || player_input_new > 10 || player_input_new < 0 {
        println!("Pick a actual number between 0 and 10");
    } else {
        print!(
            "Your guess was {}. My guess was {}. {} win!",
            player_input_new, random_number, the_string
        );
    }
}
pub fn input<T: std::fmt::Display>(prompt: T) -> String {
    print!("{}", prompt);
    io::stdout().flush().unwrap();
    let mut line: String = String::new();
    io::stdin().read_line(&mut line).unwrap();
    line.trim().to_string()
}
2 
use rand::Rng;
use std::io::{self, Write};

pub fn input<T: std::fmt::Display>(prompt: T) -> io::Result<String> {
    print!("{prompt}");
    io::stdout().flush()?;
    let mut line = String::new();
    io::stdin().read_line(&mut line)?;
    Ok(line.trim().to_string())
}

fn main() -> io::Result<()> {
    const MIN: i32 = 1;
    const MAX: i32 = 10;
    let player_input = input("Guess my number!: ")?;
    let random_number: i32 = rand::rng().random_range(MIN..=MAX);
    let player_guess = player_input.parse::<i32>().unwrap_or(-1);
    if !(MIN..=MAX).contains(&player_guess) {
        println!("Pick an actual number between 1 and 10");
    } else {
        let winner = if player_guess == random_number {
            "You"
        } else {
            "I"
        };
        println!("Your guess was {player_guess}. My guess was {random_number}. {winner} win!");
    }
    Ok(())
}
3

Great job! Just a couple of pointers:

I would include std::fmt::Display here just as well. You're already importing quite a few things: might throw in the formatting as well. Unless you want to do without it at all, more on that later.

The compiler is smart enough to infer the types it's working on, making most of the type annotations in let <var>: <type> somewhat redundant. Except for the one in the .parse(). That one is much preferred to an otherwise quite verbose "turbofish" syntax: .parse::<i32>().

.unwrap_or(-1) there, on the other hand, is a bit of a tricky choice. Its main purpose is to fall back on a reasonable "default" value in case None or an Err in question isn't a deal-breaker. Which isn't quite the case for you here: if the player types in "five" or "a watermelon" they would likely appreciate at least some hint that their input doesn't match the expected constraints. I would:

Summary 
fn prompt_number(message: &str) -> i32 {
  loop {
    let input_str = input(message);
    if let Ok(number) = player_input.parse() {
      return number;
    }
    eprintln!("Not a [whole] number! Let's try again.");
    // continue looping until you get a valid number as an input
  }
}

Generating a random number after requesting the input from the user seems like a bit of an odd choice as well here. I'd expect a basic algorithm of this sort to follow the logic of:

  1. Generate a number
  2. Get a number from the user
  3. Check the generated number against the input
    a. if true: congratulate and exit
    b. if false: repeat from 2

Anyone (including you) who might stumble upon your code in the future would be very likely to ask themselves why would a user be prompted for input before any random number is even generated. Try to avoid confusing anyone (including yourself) with less-than-intuitive logic. The simpler and the easier it is to reason about, the better. Same goes for any clever "tricks" you ever come up with.

A bit of a confusing flow again here. If you're only using the_string in the winning else branch: why compute it outside of that particular branch? Keep an uninitialized variable (the_string) outside of the block (if { ... } and else { ... } here) is best for very few occasions. This one seems just a bit unnecessary. Many conditions (||) aren't very readable, either. Instead:

Summary 
let guess = prompt_number("Take a guess: ");
let is_valid = guess >= 0 && guess <= 10;
if !is_valid {
  eprintln!("Sorry, I can only count from 0 to 10!");
  return;
}
// for readability purposes
let is_correct = guess == random;
let winner = if is_correct { "You" } else { "I" };
print!("Your guess was {guess}. My guess was {random}. {winner} win!");

Generics a bit more advanced of a topic, yet generally - if you can do without them, you probably should. It'll speed up your compilation time and make the whole thing a bit easier to reason about.

Over here, it'd be trivial to keep the whole function a simple fn input(prompt: &str). Any valid container for a piece of text / UTF-8: including String among other types, could easily be coerced into the &str slice by a simple & reference. Check the chapter on slices in the book for details.

@Jesper's reply has some more ideas with regards to the extensibility and variation with regards to the range of accepted numbers. Note that the !(MIN..=MAX).contains(x) is somewhat sub-optimal there, since it requires iterating through the whole range just to confirm whether the x lies within its bounds or not: a simple x >= MIN && X <= MAX check would suffice, instead.

Great job, otherwise. Keep it up!

1 Like