Programming a Guessing Game

    We’ll implement a classic beginner programming problem: a guessing game. Here’s how it works: the program will generate a random integer between 1 and 100. It will then prompt the player to enter a guess. After a guess is entered, the program will indicate whether the guess is too low or too high. If the guess is correct, the game will print a congratulatory message and exit.

    To set up a new project, go to the projects directory that you created in Chapter 1 and make a new project using Cargo, like so:

    The first command, cargo new, takes the name of the project (guessing_game) as the first argument. The second command changes to the new project’s directory.

    Look at the generated Cargo.toml file: Filename: Cargo.toml

    1. [package]
    2. name = "guessing_game"
    3. version = "0.1.0"
    4. edition = "2021"
    6. # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
    8. [dependencies]

    As you saw in Chapter 1, cargo new generates a “Hello, world!” program for you. Check out the src/main.rs file:

    Filename: src/main.rs

    1. fn main() {
    2.     println!("Hello, world!");
    3. }

    Now let’s compile this “Hello, world!” program and run it in the same step using the cargo run command:

    1. $ cargo run
    2.    Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    3.     Finished dev [unoptimized + debuginfo] target(s) in 1.50s
    4.      Running `target/debug/guessing_game`
    5. Hello, world!

    The run command comes in handy when you need to rapidly iterate on a project, as we’ll do in this game, quickly testing each iteration before moving on to the next one.

    Reopen the src/main.rs file. You’ll be writing all the code in this file.

    The first part of the guessing game program will ask for user input, process that input, and check that the input is in the expected form. To start, we’ll allow the player to input a guess. Enter the code in Listing 2-1 into src/main.rs.

    Filename: src/main.rs

    1. use std::io;
    3. fn main() {
    4.     println!("Guess the number!");
    6.     println!("Please input your guess.");
    8.     let mut guess = String::new();
    10.     io::stdin()
    11.         .read_line(&mut guess)
    12.         .expect("Failed to read line");
    14.     println!("You guessed: {guess}");
    15. }

    Listing 2-1: Code that gets a guess from the user and prints it

    This code contains a lot of information, so let’s go over it line by line. To obtain user input and then print the result as output, we need to bring the io input/output library into scope. The io library comes from the standard library, known as std:

    1. use std::io;
    3. fn main() {
    4.     println!("Guess the number!");
    6.     println!("Please input your guess.");
    8.     let mut guess = String::new();
    10.     io::stdin()
    11.         .read_line(&mut guess)
    12.         .expect("Failed to read line");
    14.     println!("You guessed: {guess}");
    15. }

    By default, Rust has a set of items defined in the standard library that it brings into the scope of every program. This set is called the prelude, and you can see everything in it in the standard library documentation.

    If a type you want to use isn’t in the prelude, you have to bring that type into scope explicitly with a use statement. Using the std::io library provides you with a number of useful features, including the ability to accept user input.

    As you saw in Chapter 1, the main function is the entry point into the program:

    1. use std::io;
    3. fn main() {
    4.     println!("Guess the number!");
    6.     println!("Please input your guess.");
    8.     let mut guess = String::new();
    10.     io::stdin()
    11.         .read_line(&mut guess)
    12.         .expect("Failed to read line");
    14.     println!("You guessed: {guess}");
    15. }

    The fn syntax declares a new function, the parentheses, (), indicate there are no parameters, and the curly bracket, {, starts the body of the function.

    As you also learned in Chapter 1, println! is a macro that prints a string to the screen:

    1. use std::io;
    3. fn main() {
    4.     println!("Guess the number!");
    6.     println!("Please input your guess.");
    8.     let mut guess = String::new();
    10.     io::stdin()
    11.         .read_line(&mut guess)
    12.         .expect("Failed to read line");
    14.     println!("You guessed: {guess}");
    15. }

    This code is printing a prompt stating what the game is and requesting input from the user.

    Next, we’ll create a variable to store the user input, like this:

    1. use std::io;
    3. fn main() {
    4.     println!("Guess the number!");
    6.     println!("Please input your guess.");
    8.     let mut guess = String::new();
    10.     io::stdin()
    11.         .read_line(&mut guess)
    12.         .expect("Failed to read line");
    14.     println!("You guessed: {guess}");
    15. }

    Now the program is getting interesting! There’s a lot going on in this little line. We use the let statement to create the variable. Here’s another example:

    1. let apples = 5;

    This line creates a new variable named apples and binds it to the value 5. In Rust, variables are immutable by default, meaning once we give the variable a value, the value won't change. We’ll be discussing this concept in detail in the “Variables and Mutability” section in Chapter 3. To make a variable mutable, we add mut before the variable name:

    1. let apples = 5; // immutable
    2. let mut bananas = 5; // mutable

    Returning to the guessing game program, you now know that let mut guess will introduce a mutable variable named guess. The equal sign (=) tells Rust we want to bind something to the variable now. On the right of the equals sign is the value that guess is bound to, which is the result of calling String::new, a function that returns a new instance of a String. is a string type provided by the standard library that is a growable, UTF-8 encoded bit of text.

    The :: syntax in the ::new line indicates that new is an associated function of the String type. An associated function is a function that’s implemented on a type, in this case String. This new function creates a new, empty string. You’ll find a new function on many types, because it’s a common name for a function that makes a new value of some kind.

    In full, the let mut guess = String::new(); line has created a mutable variable that is currently bound to a new, empty instance of a String. Whew!

    Recall that we included the input/output functionality from the standard library with use std::io; on the first line of the program. Now we’ll call the stdin function from the io module, which will allow us to handle user input:

    1. use std::io;
    3. fn main() {
    4.     println!("Guess the number!");
    6.     println!("Please input your guess.");
    8.     let mut guess = String::new();
    10.     io::stdin()
    11.         .read_line(&mut guess)
    12.         .expect("Failed to read line");
    14.     println!("You guessed: {guess}");
    15. }

    If we hadn’t imported the io library with use std::io at the beginning of the program, we could still use the function by writing this function call as std::io::stdin. The stdin function returns an instance of std::io::Stdin, which is a type that represents a handle to the standard input for your terminal.

    Next, the line .read_line(&mut guess) calls the method on the standard input handle to get input from the user. We’re also passing &mut guess as the argument to read_line to tell it what string to store the user input in. The full job of read_line is to take whatever the user types into standard input and append that into a string (without overwriting its contents), so we therefore pass that string as an argument. The string argument needs to be mutable so the method can change the string’s content.

    The & indicates that this argument is a reference, which gives you a way to let multiple parts of your code access one piece of data without needing to copy that data into memory multiple times. References are a complex feature, and one of Rust’s major advantages is how safe and easy it is to use references. You don’t need to know a lot of those details to finish this program. For now, all you need to know is that like variables, references are immutable by default. Hence, you need to write &mut guess rather than &guess to make it mutable. (Chapter 4 will explain references more thoroughly.)

    We’re still working on this line of code. We’re now discussing a third line of text, but note that it’s still part of a single logical line of code. The next part is this method:

    We could have written this code as:

    1. io::stdin().read_line(&mut guess).expect("Failed to read line");

    However, one long line is difficult to read, so it’s best to divide it. It’s often wise to introduce a newline and other whitespace to help break up long lines when you call a method with the .method_name() syntax. Now let’s discuss what this line does.

    As mentioned earlier, read_line puts whatever the user enters into the string we pass to it, but it also returns a Result value. Result is an , often called an enum, which is a type that can be in one of multiple possible states. We call each possible state a variant.

    Chapter 6 will cover enums in more detail. The purpose of these Result types is to encode error-handling information.

    Result's variants are Ok and Err. The Ok variant indicates the operation was successful, and inside Ok is the successfully generated value. The Err variant means the operation failed, and Err contains information about how or why the operation failed.

    If you don’t call expect, the program will compile, but you’ll get a warning:

    1. $ cargo build
    2.    Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    3. warning: unused `Result` that must be used
    4.   --> src/main.rs:10:5
    5.    |
    6. 10 |     io::stdin().read_line(&mut guess);
    7.    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    8.    |
    9.    = note: `#[warn(unused_must_use)]` on by default
    10.    = note: this `Result` may be an `Err` variant, which should be handled
    12. warning: `guessing_game` (bin "guessing_game") generated 1 warning
    13.     Finished dev [unoptimized + debuginfo] target(s) in 0.59s

    Rust warns that you haven’t used the Result value returned from read_line, indicating that the program hasn’t handled a possible error.

    The right way to suppress the warning is to actually write error handling, but in our case we just want to crash this program when a problem occurs, so we can use expect. You’ll learn about recovering from errors in Chapter 9.

    Aside from the closing curly bracket, there’s only one more line to discuss in the code so far:

    1. use std::io;
    3. fn main() {
    4.     println!("Guess the number!");
    6.     println!("Please input your guess.");
    8.     let mut guess = String::new();
    10.     io::stdin()
    11.         .read_line(&mut guess)
    12.         .expect("Failed to read line");
    14.     println!("You guessed: {guess}");
    15. }

    This line prints the string that now contains the user’s input. The {} set of curly brackets is a placeholder: think of {} as little crab pincers that hold a value in place. You can print more than one value using curly brackets: the first set of curly brackets holds the first value listed after the format string, the second set holds the second value, and so on. Printing multiple values in one call to println! would look like this:

    1. #![allow(unused)]
    2. fn main() {
    3. let x = 5;
    4. let y = 10;
    6. println!("x = {} and y = {}", x, y);
    7. }

    This code would print x = 5 and y = 10.

    Let’s test the first part of the guessing game. Run it using cargo run: 

    1. $ cargo run
    2.    Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    3.      Running `target/debug/guessing_game`
    4. Guess the number!
    5. Please input your guess.
    6. 6
    7. You guessed: 6

    At this point, the first part of the game is done: we’re getting input from the keyboard and then printing it.

    Next, we need to generate a secret number that the user will try to guess. The secret number should be different every time so the game is fun to play more than once. We’ll use a random number between 1 and 100 so the game isn’t too difficult. Rust doesn’t yet include random number functionality in its standard library. However, the Rust team does provide a with said functionality.

    Remember that a crate is a collection of Rust source code files. The project we’ve been building is a binary crate, which is an executable. The rand crate is a library crate, which contains code intended to be used in other programs and can't be executed on its own.

    Cargo’s coordination of external crates is where Cargo really shines. Before we can write code that uses rand, we need to modify the Cargo.toml file to include the rand crate as a dependency. Open that file now and add the following line to the bottom beneath the [dependencies] section header that Cargo created for you. Be sure to specify rand exactly as we have here, with this version number, or the code examples in this tutorial may not work. Filename: Cargo.toml

    1. rand = "0.8.3"

    In the Cargo.toml file, everything that follows a header is part of that section that continues until another section starts. In [dependencies] you tell Cargo which external crates your project depends on and which versions of those crates you require. In this case, we specify the crate with the semantic version specifier 0.8.3. Cargo understands Semantic Versioning (sometimes called SemVer), which is a standard for writing version numbers. The number 0.8.3 is actually shorthand for ^0.8.3, which means any version that is at least 0.8.3 but below 0.9.0.

    Cargo considers these versions to have public APIs compatible with version 0.8.3, and this specification ensures you’ll get the latest patch release that will still compile with the code in this chapter. Any version 0.9.0 or greater is not guaranteed to have the same API as what the following examples use.

    Now, without changing any of the code, let’s build the project, as shown in Listing 2-2. 

    1. $ cargo build
    2.     Updating crates.io index
    3.   Downloaded rand v0.8.3
    4.   Downloaded libc v0.2.86
    5.   Downloaded getrandom v0.2.2
    6.   Downloaded cfg-if v1.0.0
    7.   Downloaded ppv-lite86 v0.2.10
    8.   Downloaded rand_chacha v0.3.0
    9.   Downloaded rand_core v0.6.2
    10.    Compiling rand_core v0.6.2
    11.    Compiling libc v0.2.86
    12.    Compiling getrandom v0.2.2
    13.    Compiling cfg-if v1.0.0
    14.    Compiling ppv-lite86 v0.2.10
    15.    Compiling rand_chacha v0.3.0
    16.    Compiling rand v0.8.3
    17.    Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    18.     Finished dev [unoptimized + debuginfo] target(s) in 2.53s

    Listing 2-2: The output from running cargo build after adding the rand crate as a dependency

    You may see different version numbers (but they will all be compatible with the code, thanks to SemVer!), different lines (depending on the operating system), and the lines may be in a different order.

    When we include an external dependency, Cargo fetches the latest versions of everything that dependency needs from the registry, which is a copy of data from . Crates.io is where people in the Rust ecosystem post their open source Rust projects for others to use.

    After updating the registry, Cargo checks the [dependencies] section and downloads any crates listed that aren’t already downloaded. In this case, although we only listed rand as a dependency, Cargo also grabbed other crates that rand depends on to work. After downloading the crates, Rust compiles them and then compiles the project with the dependencies available.

    If you immediately run cargo build again without making any changes, you won’t get any output aside from the Finished line. Cargo knows it has already downloaded and compiled the dependencies, and you haven’t changed anything about them in your Cargo.toml file. Cargo also knows that you haven’t changed anything about your code, so it doesn’t recompile that either. With nothing to do, it simply exits.

    If you open up the src/main.rs file, make a trivial change, and then save it and build again, you’ll only see two lines of output: 

    1. $ cargo build
    2.    Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    3.     Finished dev [unoptimized + debuginfo] target(s) in 2.53 secs

    These lines show Cargo only updates the build with your tiny change to the src/main.rs file. Your dependencies haven’t changed, so Cargo knows it can reuse what it has already downloaded and compiled for those.

    Cargo has a mechanism that ensures you can rebuild the same artifact every time you or anyone else builds your code: Cargo will use only the versions of the dependencies you specified until you indicate otherwise. For example, say that next week version 0.8.4 of the rand crate comes out, and that version contains an important bug fix, but it also contains a regression that will break your code. To handle this, Rust creates the Cargo.lock file the first time you run cargo build, so we now have this in the guessing_game directory.

    When you build a project for the first time, Cargo figures out all the versions of the dependencies that fit the criteria and then writes them to the Cargo.lock file. When you build your project in the future, Cargo will see that the Cargo.lock file exists and use the versions specified there rather than doing all the work of figuring out versions again. This lets you have a reproducible build automatically. In other words, your project will remain at 0.8.3 until you explicitly upgrade, thanks to the Cargo.lock file. Because the Cargo.lock file is important for reproducible builds, it's often checked into source control with the rest of the code in your project.

    When you do want to update a crate, Cargo provides the command update, which will ignore the Cargo.lock file and figure out all the latest versions that fit your specifications in Cargo.toml. Cargo will then write those versions to the Cargo.lock file. Otherwise, by default, Cargo will only look for versions greater than 0.8.3 and less than 0.9.0. If the rand crate has released the two new versions 0.8.4 and 0.9.0 you would see the following if you ran cargo update: 

    1. $ cargo update
    2.     Updating crates.io index
    3.     Updating rand v0.8.3 -> v0.8.4

    Cargo ignores the 0.9.0 release. At this point, you would also notice a change in your Cargo.lock file noting that the version of the rand crate you are now using is 0.8.4. To use rand version 0.9.0 or any version in the 0.9.x series, you’d have to update the Cargo.toml file to look like this instead:

    1. [dependencies]
    2. rand = "0.9.0"

    The next time you run cargo build, Cargo will update the registry of crates available and reevaluate your rand requirements according to the new version you have specified.

    There’s a lot more to say about Cargo and which we’ll discuss in Chapter 14, but for now, that’s all you need to know. Cargo makes it very easy to reuse libraries, so Rustaceans are able to write smaller projects that are assembled from a number of packages.

    Let’s start using rand to generate a number to guess. The next step is to update src/main.rs, as shown in Listing 2-3.

    Filename: src/main.rs

    1. use std::io;
    2. use rand::Rng;
    4. fn main() {
    5.     println!("Guess the number!");
    7.     let secret_number = rand::thread_rng().gen_range(1..=100);
    9.     println!("The secret number is: {secret_number}");
    11.     println!("Please input your guess.");
    13.     let mut guess = String::new();
    15.     io::stdin()
    16.         .read_line(&mut guess)
    17.         .expect("Failed to read line");
    19.     println!("You guessed: {guess}");
    20. }

    Listing 2-3: Adding code to generate a random number

    First, we add the line use rand::Rng. The Rng trait defines methods that random number generators implement, and this trait must be in scope for us to use those methods. Chapter 10 will cover traits in detail.

    Next, we’re adding two lines in the middle. In the first line, we call the rand::thread_rng function that gives us the particular random number generator that we’re going to use: one that is local to the current thread of execution and seeded by the operating system. Then we call the gen_range method on the random number generator. This method is defined by the Rng trait that we brought into scope with the use rand::Rng statement. The gen_range method takes a range expression as an argument and generates a random number in the range. The kind of range expression we’re using here takes the form start..=end and is inclusive on the lower and upper bounds, so we need to specify 1..=100 to request a number between 1 and 100.

    Note: You won’t just know which traits to use and which methods and functions to call from a crate, so each crate has documentation with instructions for using it. Another neat feature of Cargo is that running the cargo doc --open command will build documentation provided by all of your dependencies locally and open it in your browser. If you’re interested in other functionality in the rand crate, for example, run cargo doc --open and click rand in the sidebar on the left.

    The second new line prints the secret number. This is useful while we’re developing the program to be able to test it, but we’ll delete it from the final version. It’s not much of a game if the program prints the answer as soon as it starts!

    Try running the program a few times:

    You should get different random numbers, and they should all be numbers between 1 and 100. Great job!

    Comparing the Guess to the Secret Number

    Filename: src/main.rs

    1. use rand::Rng;
    2. use std::cmp::Ordering;
    3. use std::io;
    5. fn main() {
    6.     // --snip--
    7.     println!("Guess the number!");
    9.     let secret_number = rand::thread_rng().gen_range(1..=100);
    11.     println!("The secret number is: {secret_number}");
    13.     println!("Please input your guess.");
    15.     let mut guess = String::new();
    17.     io::stdin()
    18.         .read_line(&mut guess)
    19.         .expect("Failed to read line");
    21.     println!("You guessed: {guess}");
    23.     match guess.cmp(&secret_number) {
    24.         Ordering::Less => println!("Too small!"),
    25.         Ordering::Greater => println!("Too big!"),
    26.         Ordering::Equal => println!("You win!"),
    27.     }
    28. }

    Listing 2-4: Handling the possible return values of comparing two numbers

    First we add another use statement, bringing a type called std::cmp::Ordering into scope from the standard library. The Ordering type is another enum and has the variants Less, Greater, and Equal. These are the three outcomes that are possible when you compare two values.

    Then we add five new lines at the bottom that use the Ordering type. The cmp method compares two values and can be called on anything that can be compared. It takes a reference to whatever you want to compare with: here it’s comparing the guess to the secret_number. Then it returns a variant of the Ordering enum we brought into scope with the use statement. We use a expression to decide what to do next based on which variant of Ordering was returned from the call to cmp with the values in guess and secret_number.

    A match expression is made up of arms. An arm consists of a pattern to match against, and the code that should be run if the value given to match fits that arm’s pattern. Rust takes the value given to match and looks through each arm’s pattern in turn. Patterns and the match construct are powerful Rust features that let you express a variety of situations your code might encounter and make sure that you handle them all. These features will be covered in detail in Chapter 6 and Chapter 18, respectively.

    Let’s walk through an example with the match expression we use here. Say that the user has guessed 50 and the randomly generated secret number this time is 38. When the code compares 50 to 38, the cmp method will return Ordering::Greater, because 50 is greater than 38. The match expression gets the Ordering::Greater value and starts checking each arm’s pattern. It looks at the first arm’s pattern, Ordering::Less, and sees that the value Ordering::Greater does not match Ordering::Less, so it ignores the code in that arm and moves to the next arm. The next arm’s pattern is Ordering::Greater, which does match Ordering::Greater! The associated code in that arm will execute and print Too big! to the screen. The match expression ends after the first successful match, so it won’t look at the last arm in this scenario.

    However, the code in Listing 2-4 won’t compile yet. Let’s try it:

    1. $ cargo build
    2.    Compiling libc v0.2.86
    3.    Compiling getrandom v0.2.2
    4.    Compiling cfg-if v1.0.0
    5.    Compiling ppv-lite86 v0.2.10
    6.    Compiling rand_core v0.6.2
    7.    Compiling rand_chacha v0.3.0
    8.    Compiling rand v0.8.3
    9.    Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    10. error[E0308]: mismatched types
    11.   --> src/main.rs:22:21
    12.    |
    13. 22 |     match guess.cmp(&secret_number) {
    14.    |                     ^^^^^^^^^^^^^^ expected struct `String`, found integer
    15.    |
    16.    = note: expected reference `&String`
    17.               found reference `&{integer}`
    19. For more information about this error, try `rustc --explain E0308`.
    20. error: could not compile `guessing_game` due to previous error

    The core of the error states that there are mismatched types. Rust has a strong, static type system. However, it also has type inference. When we wrote let mut guess = String::new(), Rust was able to infer that guess should be a String and didn’t make us write the type. The secret_number, on the other hand, is a number type. A few of Rust’s number types can have a value between 1 and 100: i32, a 32-bit number; u32, an unsigned 32-bit number; i64, a 64-bit number; as well as others. Unless otherwise specified, Rust defaults to an i32, which is the type of secret_number unless you add type information elsewhere that would cause Rust to infer a different numerical type. The reason for the error is that Rust cannot compare a string and a number type.

    Ultimately, we want to convert the String the program reads as input into a real number type so we can compare it numerically to the secret number. We do so by adding this line to the main function body:

    Filename: src/main.rs

    1. use rand::Rng;
    2. use std::cmp::Ordering;
    3. use std::io;
    5. fn main() {
    6.     println!("Guess the number!");
    8.     let secret_number = rand::thread_rng().gen_range(1..=100);
    10.     println!("The secret number is: {secret_number}");
    12.     println!("Please input your guess.");
    14.     // --snip--
    16.     let mut guess = String::new();
    18.     io::stdin()
    19.         .read_line(&mut guess)
    20.         .expect("Failed to read line");
    22.     let guess: u32 = guess.trim().parse().expect("Please type a number!");
    24.     println!("You guessed: {guess}");
    26.     match guess.cmp(&secret_number) {
    27.         Ordering::Less => println!("Too small!"),
    28.         Ordering::Greater => println!("Too big!"),
    29.         Ordering::Equal => println!("You win!"),
    30.     }
    31. }

    The line is:

    1. let guess: u32 = guess.trim().parse().expect("Please type a number!");

    We create a variable named guess. But wait, doesn’t the program already have a variable named guess? It does, but helpfully Rust allows us to shadow the previous value of guess with a new one. Shadowing lets us reuse the guess variable name rather than forcing us to create two unique variables, such as guess_str and guess for example. We’ll cover this in more detail in Chapter 3, but for now know that this feature is often used when you want to convert a value from one type to another type.

    We bind this new variable to the expression guess.trim().parse(). The guess in the expression refers to the original guess variable that contained the input as a string. The trim method on a String instance will eliminate any whitespace at the beginning and end, which we must do to be able to compare the string to the u32, which can only contain numerical data. The user must press enter to satisfy read_line and input their guess, which adds a newline character to the string. For example, if the user types 5 and presses enter, guess looks like this: 5\n. The \n represents “newline”. (On Windows, pressing enter results in a carriage return and a newline, \r\n). The trim method eliminates \n or \r\n, resulting in just 5.

    The parse method on strings converts a string to another type. Here, we use it to convert from a string to a number. We need to tell Rust the exact number type we want by using let guess: u32. The colon (:) after guess tells Rust we’ll annotate the variable’s type. Rust has a few built-in number types; the u32 seen here is an unsigned, 32-bit integer. It’s a good default choice for a small positive number. You’ll learn about other number types in Chapter 3. Additionally, the u32 annotation in this example program and the comparison with secret_number means that Rust will infer that secret_number should be a u32 as well. So now the comparison will be between two values of the same type!

    The parse method will only work on characters that can logically be converted into numbers and so can easily cause errors. If, for example, the string contained A👍%, there would be no way to convert that to a number. Because it might fail, the parse method returns a Result type, much as the read_line method does (discussed earlier in ). We’ll treat this the same way by using the expect method again. If parse returns an Err Result variant because it couldn’t create a number from the string, the expect call will crash the game and print the message we give it. If parse can successfully convert the string to a number, it will return the Ok variant of Result, and expect will return the number that we want from the Ok value.

    Let’s run the program now! 

    1. $ cargo run
    2.    Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    3.     Finished dev [unoptimized + debuginfo] target(s) in 0.43s
    4.      Running `target/debug/guessing_game`
    5. Guess the number!
    6. The secret number is: 58
    7. Please input your guess.
    8.   76
    9. You guessed: 76
    10. Too big!

    Nice! Even though spaces were added before the guess, the program still figured out that the user guessed 76. Run the program a few times to verify the different behavior with different kinds of input: guess the number correctly, guess a number that is too high, and guess a number that is too low.

    We have most of the game working now, but the user can make only one guess. Let’s change that by adding a loop!

    The loop keyword creates an infinite loop. We’ll add a loop to give users more chances at guessing the number:

    Filename: src/main.rs

    1. use rand::Rng;
    2. use std::cmp::Ordering;
    3. use std::io;
    5. fn main() {
    6.     println!("Guess the number!");
    8.     let secret_number = rand::thread_rng().gen_range(1..=100);
    10.     // --snip--
    12.     println!("The secret number is: {secret_number}");
    14.     loop {
    15.         println!("Please input your guess.");
    17.         // --snip--
    19.         let mut guess = String::new();
    21.         io::stdin()
    22.             .read_line(&mut guess)
    24.         let guess: u32 = guess.trim().parse().expect("Please type a number!");
    26.         println!("You guessed: {guess}");
    28.         match guess.cmp(&secret_number) {
    29.             Ordering::Less => println!("Too small!"),
    30.             Ordering::Greater => println!("Too big!"),
    31.             Ordering::Equal => println!("You win!"),
    32.         }
    33.     }
    34. }

    As you can see, we’ve moved everything from the guess input prompt onward into a loop. Be sure to indent the lines inside the loop another four spaces each and run the program again. The program will now ask for another guess forever, which actually introduces a new problem. It doesn’t seem like the user can quit!

    The user could always interrupt the program by using the keyboard shortcut ctrl-c. But there’s another way to escape this insatiable monster, as mentioned in the parse discussion in : if the user enters a non-number answer, the program will crash. We can take advantage of that to allow the user to quit, as shown here: 

    1. $ cargo run
    2.    Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    3.     Finished dev [unoptimized + debuginfo] target(s) in 1.50s
    4.      Running `target/debug/guessing_game`
    5. Guess the number!
    6. The secret number is: 59
    7. Please input your guess.
    8. 45
    9. You guessed: 45
    10. Too small!
    11. Please input your guess.
    12. 60
    13. You guessed: 60
    14. Too big!
    15. Please input your guess.
    16. 59
    17. You guessed: 59
    18. You win!
    19. Please input your guess.
    20. quit
    21. thread 'main' panicked at 'Please type a number!: ParseIntError { kind: InvalidDigit }', src/main.rs:28:47
    22. note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

    Typing quit will quit the game, but as you’ll notice so will entering any other non-number input. This is suboptimal to say the least; we want the game to also stop when the correct number is guessed.

    Let’s program the game to quit when the user wins by adding a break statement:

    Filename: src/main.rs

    1. use rand::Rng;
    2. use std::cmp::Ordering;
    3. use std::io;
    5. fn main() {
    6.     println!("Guess the number!");
    8.     let secret_number = rand::thread_rng().gen_range(1..=100);
    10.     println!("The secret number is: {secret_number}");
    12.     loop {
    13.         println!("Please input your guess.");
    15.         let mut guess = String::new();
    17.         io::stdin()
    18.             .read_line(&mut guess)
    19.             .expect("Failed to read line");
    21.         let guess: u32 = guess.trim().parse().expect("Please type a number!");
    23.         println!("You guessed: {guess}");
    25.         // --snip--
    27.         match guess.cmp(&secret_number) {
    28.             Ordering::Less => println!("Too small!"),
    29.             Ordering::Greater => println!("Too big!"),
    30.             Ordering::Equal => {
    31.                 println!("You win!");
    32.                 break;
    33.             }
    34.         }
    35.     }
    36. }

    Adding the break line after You win! makes the program exit the loop when the user guesses the secret number correctly. Exiting the loop also means exiting the program, because the loop is the last part of main.

    To further refine the game’s behavior, rather than crashing the program when the user inputs a non-number, let’s make the game ignore a non-number so the user can continue guessing. We can do that by altering the line where guess is converted from a String to a u32, as shown in Listing 2-5.

    Filename: src/main.rs

    1. use rand::Rng;
    2. use std::cmp::Ordering;
    3. use std::io;
    5. fn main() {
    6.     println!("Guess the number!");
    8.     let secret_number = rand::thread_rng().gen_range(1..=100);
    10.     println!("The secret number is: {secret_number}");
    12.     loop {
    13.         println!("Please input your guess.");
    15.         let mut guess = String::new();
    17.         // --snip--
    19.         io::stdin()
    20.             .read_line(&mut guess)
    21.             .expect("Failed to read line");
    23.         let guess: u32 = match guess.trim().parse() {
    24.             Ok(num) => num,
    25.             Err(_) => continue,
    26.         };
    28.         println!("You guessed: {guess}");
    30.         // --snip--
    32.         match guess.cmp(&secret_number) {
    33.             Ordering::Less => println!("Too small!"),
    34.             Ordering::Greater => println!("Too big!"),
    35.             Ordering::Equal => {
    36.                 println!("You win!");
    37.                 break;
    38.             }
    39.         }
    40.     }
    41. }

    Listing 2-5: Ignoring a non-number guess and asking for another guess instead of crashing the program

    We switch from an expect call to a match expression to move from crashing on an error to handling the error. Remember that parse returns a Result type and Result is an enum that has the variants Ok and Err. We’re using a match expression here, as we did with the Ordering result of the cmp method.

    If parse is able to successfully turn the string into a number, it will return an Ok value that contains the resulting number. That Ok value will match the first arm’s pattern, and the match expression will just return the num value that parse produced and put inside the Ok value. That number will end up right where we want it in the new guess variable we’re creating.

    If parse is not able to turn the string into a number, it will return an Err value that contains more information about the error. The Err value does not match the Ok(num) pattern in the first match arm, but it does match the Err(_) pattern in the second arm. The underscore, _, is a catchall value; in this example, we’re saying we want to match all Err values, no matter what information they have inside them. So the program will execute the second arm’s code, continue, which tells the program to go to the next iteration of the loop and ask for another guess. So, effectively, the program ignores all errors that parse might encounter!

    Now everything in the program should work as expected. Let’s try it: 

    1. $ cargo run
    2.    Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
    3.     Finished dev [unoptimized + debuginfo] target(s) in 4.45s
    4.      Running `target/debug/guessing_game`
    5. Guess the number!
    6. The secret number is: 61
    7. Please input your guess.
    8. 10
    9. You guessed: 10
    10. Too small!
    11. Please input your guess.
    12. 99
    13. You guessed: 99
    14. Too big!
    15. Please input your guess.
    16. foo
    17. Please input your guess.
    18. 61
    19. You guessed: 61
    20. You win!

    Awesome! With one tiny final tweak, we will finish the guessing game. Recall that the program is still printing the secret number. That worked well for testing, but it ruins the game. Let’s delete the println! that outputs the secret number. Listing 2-6 shows the final code.

    Filename: src/main.rs

    1. use rand::Rng;
    2. use std::cmp::Ordering;
    3. use std::io;
    5. fn main() {
    6.     println!("Guess the number!");
    8.     let secret_number = rand::thread_rng().gen_range(1..=100);
    10.     loop {
    11.         println!("Please input your guess.");
    13.         let mut guess = String::new();
    15.         io::stdin()
    16.             .read_line(&mut guess)
    17.             .expect("Failed to read line");
    19.         let guess: u32 = match guess.trim().parse() {
    20.             Ok(num) => num,
    21.             Err(_) => continue,
    22.         };
    24.         println!("You guessed: {guess}");
    26.         match guess.cmp(&secret_number) {
    27.             Ordering::Less => println!("Too small!"),
    28.             Ordering::Greater => println!("Too big!"),
    29.             Ordering::Equal => {
    30.                 println!("You win!");
    31.                 break;
    32.             }
    33.         }
    34. }

    Listing 2-6: Complete guessing game code

    This project was a hands-on way to introduce you to many new Rust concepts: let, match, functions, the use of external crates, and more. In the next few chapters, you’ll learn about these concepts in more detail. Chapter 3 covers concepts that most programming languages have, such as variables, data types, and functions, and shows how to use them in Rust. Chapter 4 explores ownership, a feature that makes Rust different from other languages. Chapter 5 discusses structs and method syntax, and Chapter 6 explains how enums work.