3 Let’s learn some Rust! For our first project, we’ll implement a classic
4 beginner programming problem: the guessing game. Here’s how it works: Our
5 program will generate a random integer between one and a hundred. It will then
6 prompt us to enter a guess. Upon entering our guess, it will tell us if we’re
7 too low or too high. Once we guess correctly, it will congratulate us. Sounds
10 Along the way, we’ll learn a little bit about Rust. The next chapter, ‘Syntax
11 and Semantics’, will dive deeper into each part.
15 Let’s set up a new project. Go to your projects directory. Remember how we had
16 to create our directory structure and a `Cargo.toml` for `hello_world`? Cargo
17 has a command that does that for us. Let’s give it a shot:
21 $ cargo new guessing_game --bin
25 We pass the name of our project to `cargo new`, and then the `--bin` flag,
26 since we’re making a binary, rather than a library.
28 Check out the generated `Cargo.toml`:
33 name = "guessing_game"
35 authors = ["Your Name <you@example.com>"]
38 Cargo gets this information from your environment. If it’s not correct, go ahead
41 Finally, Cargo generated a ‘Hello, world!’ for us. Check out `src/main.rs`:
45 println!("Hello, world!");
49 Let’s try compiling what Cargo gave us:
53 Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
56 Excellent! Open up your `src/main.rs` again. We’ll be writing all of
57 our code in this file.
59 Before we move on, let me show you one more Cargo command: `run`. `cargo run`
60 is kind of like `cargo build`, but it also then runs the produced executable.
65 Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
66 Running `target/debug/guessing_game`
70 Great! The `run` command comes in handy when you need to rapidly iterate on a
71 project. Our game is such a project, we need to quickly test each
72 iteration before moving on to the next one.
76 Let’s get to it! The first thing we need to do for our guessing game is
77 allow our player to input a guess. Put this in your `src/main.rs`:
83 println!("Guess the number!");
85 println!("Please input your guess.");
87 let mut guess = String::new();
89 io::stdin().read_line(&mut guess)
90 .expect("Failed to read line");
92 println!("You guessed: {}", guess);
96 There’s a lot here! Let’s go over it, bit by bit.
102 We’ll need to take user input, and then print the result as output. As such, we
103 need the `io` library from the standard library. Rust only imports a few things
104 by default into every program, [the ‘prelude’][prelude]. If it’s not in the
105 prelude, you’ll have to `use` it directly. There is also a second ‘prelude’, the
106 [`io` prelude][ioprelude], which serves a similar function: you import it, and it
107 imports a number of useful, `io`-related things.
109 [prelude]: ../std/prelude/index.html
110 [ioprelude]: ../std/io/prelude/index.html
116 As you’ve seen before, the `main()` function is the entry point into your
117 program. The `fn` syntax declares a new function, the `()`s indicate that
118 there are no arguments, and `{` starts the body of the function. Because
119 we didn’t include a return type, it’s assumed to be `()`, an empty
122 [tuples]: primitive-types.html#tuples
125 println!("Guess the number!");
127 println!("Please input your guess.");
130 We previously learned that `println!()` is a [macro][macros] that
131 prints a [string][strings] to the screen.
133 [macros]: macros.html
134 [strings]: strings.html
137 let mut guess = String::new();
140 Now we’re getting interesting! There’s a lot going on in this little line.
141 The first thing to notice is that this is a [let statement][let], which is
142 used to create ‘variable bindings’. They take this form:
148 [let]: variable-bindings.html
150 This will create a new binding named `foo`, and bind it to the value `bar`. In
151 many languages, this is called a ‘variable’, but Rust’s variable bindings have
152 a few tricks up their sleeves.
154 For example, they’re [immutable][immutable] by default. That’s why our example
155 uses `mut`: it makes a binding mutable, rather than immutable. `let` doesn’t
156 take a name on the left hand side of the assignment, it actually accepts a
157 ‘[pattern][patterns]’. We’ll use patterns later. It’s easy enough
161 let foo = 5; // immutable.
162 let mut bar = 5; // mutable
165 [immutable]: mutability.html
166 [patterns]: patterns.html
168 Oh, and `//` will start a comment, until the end of the line. Rust ignores
169 everything in [comments][comments].
171 [comments]: comments.html
173 So now we know that `let mut guess` will introduce a mutable binding named
174 `guess`, but we have to look at the other side of the `=` for what it’s
175 bound to: `String::new()`.
177 `String` is a string type, provided by the standard library. A
178 [`String`][string] is a growable, UTF-8 encoded bit of text.
180 [string]: ../std/string/struct.String.html
182 The `::new()` syntax uses `::` because this is an ‘associated function’ of
183 a particular type. That is to say, it’s associated with `String` itself,
184 rather than a particular instance of a `String`. Some languages call this a
187 This function is named `new()`, because it creates a new, empty `String`.
188 You’ll find a `new()` function on many types, as it’s a common name for making
189 a new value of some kind.
194 io::stdin().read_line(&mut guess)
195 .expect("Failed to read line");
198 That’s a lot more! Let’s go bit-by-bit. The first line has two parts. Here’s
205 Remember how we `use`d `std::io` on the first line of the program? We’re now
206 calling an associated function on it. If we didn’t `use std::io`, we could
207 have written this line as `std::io::stdin()`.
209 This particular function returns a handle to the standard input for your
210 terminal. More specifically, a [std::io::Stdin][iostdin].
212 [iostdin]: ../std/io/struct.Stdin.html
214 The next part will use this handle to get input from the user:
217 .read_line(&mut guess)
220 Here, we call the [`read_line()`][read_line] method on our handle.
221 [Methods][method] are like associated functions, but are only available on a
222 particular instance of a type, rather than the type itself. We’re also passing
223 one argument to `read_line()`: `&mut guess`.
225 [read_line]: ../std/io/struct.Stdin.html#method.read_line
226 [method]: method-syntax.html
228 Remember how we bound `guess` above? We said it was mutable. However,
229 `read_line` doesn’t take a `String` as an argument: it takes a `&mut String`.
230 Rust has a feature called ‘[references][references]’, which allows you to have
231 multiple references to one piece of data, which can reduce copying. References
232 are a complex feature, as one of Rust’s major selling points is how safe and
233 easy it is to use references. We don’t need to know a lot of those details to
234 finish our program right now, though. For now, all we need to know is that
235 like `let` bindings, references are immutable by default. Hence, we need to
236 write `&mut guess`, rather than `&guess`.
238 Why does `read_line()` take a mutable reference to a string? Its job is
239 to take what the user types into standard input, and place that into a
240 string. So it takes that string as an argument, and in order to add
241 the input, it needs to be mutable.
243 [references]: references-and-borrowing.html
245 But we’re not quite done with this line of code, though. While it’s
246 a single line of text, it’s only the first part of the single logical line of
250 .expect("Failed to read line");
253 When you call a method with the `.foo()` syntax, you may introduce a newline
254 and other whitespace. This helps you split up long lines. We _could_ have
258 io::stdin().read_line(&mut guess).expect("failed to read line");
261 But that gets hard to read. So we’ve split it up, three lines for three method
262 calls. We already talked about `read_line()`, but what about `expect()`? Well,
263 we already mentioned that `read_line()` puts what the user types into the `&mut
264 String` we pass it. But it also returns a value: in this case, an
265 [`io::Result`][ioresult]. Rust has a number of types named `Result` in its
266 standard library: a generic [`Result`][result], and then specific versions for
267 sub-libraries, like `io::Result`.
269 [ioresult]: ../std/io/type.Result.html
270 [result]: ../std/result/enum.Result.html
272 The purpose of these `Result` types is to encode error handling information.
273 Values of the `Result` type, like any type, have methods defined on them. In
274 this case, `io::Result` has an [`expect()` method][expect] that takes a value
275 it’s called on, and if it isn’t a successful one, [`panic!`][panic]s with a
276 message you passed it. A `panic!` like this will cause our program to crash,
277 displaying the message.
279 [expect]: ../std/option/enum.Option.html#method.expect
280 [panic]: error-handling.html
282 If we leave off calling these two methods, our program will compile, but
287 Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
288 src/main.rs:10:5: 10:39 warning: unused result which must be used,
289 #[warn(unused_must_use)] on by default
290 src/main.rs:10 io::stdin().read_line(&mut guess);
291 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
294 Rust warns us that we haven’t used the `Result` value. This warning comes from
295 a special annotation that `io::Result` has. Rust is trying to tell you that
296 you haven’t handled a possible error. The right way to suppress the error is
297 to actually write error handling. Luckily, if we want to crash if there’s
298 a problem, we can use these two little methods. If we can recover from the
299 error somehow, we’d do something else, but we’ll save that for a future
302 There’s only one line of this first example left:
305 println!("You guessed: {}", guess);
309 This prints out the string we saved our input in. The `{}`s are a placeholder,
310 and so we pass it `guess` as an argument. If we had multiple `{}`s, we would
311 pass multiple arguments:
317 println!("x and y: {} and {}", x, y);
322 Anyway, that’s the tour. We can run what we have with `cargo run`:
326 Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
327 Running `target/debug/guessing_game`
329 Please input your guess.
334 All right! Our first part is done: we can get input from the keyboard,
335 and then print it back out.
337 # Generating a secret number
339 Next, we need to generate a secret number. Rust does not yet include random
340 number functionality in its standard library. The Rust team does, however,
341 provide a [`rand` crate][randcrate]. A ‘crate’ is a package of Rust code.
342 We’ve been building a ‘binary crate’, which is an executable. `rand` is a
343 ‘library crate’, which contains code that’s intended to be used with other
346 [randcrate]: https://crates.io/crates/rand
348 Using external crates is where Cargo really shines. Before we can write
349 the code using `rand`, we need to modify our `Cargo.toml`. Open it up, and
350 add these few lines at the bottom:
358 The `[dependencies]` section of `Cargo.toml` is like the `[package]` section:
359 everything that follows it is part of it, until the next section starts.
360 Cargo uses the dependencies section to know what dependencies on external
361 crates you have, and what versions you require. In this case, we’ve specified version `0.3.0`,
362 which Cargo understands to be any release that’s compatible with this specific version.
363 Cargo understands [Semantic Versioning][semver], which is a standard for writing version
364 numbers. A bare number like above is actually shorthand for `^0.3.0`,
365 meaning "anything compatible with 0.3.0".
366 If we wanted to use only `0.3.0` exactly, we could say `rand="=0.3.0"`
367 (note the two equal signs).
368 And if we wanted to use the latest version we could use `*`.
369 We could also use a range of versions.
370 [Cargo’s documentation][cargodoc] contains more details.
372 [semver]: http://semver.org
373 [cargodoc]: http://doc.crates.io/crates-io.html
375 Now, without changing any of our code, let’s build our project:
379 Updating registry `https://github.com/rust-lang/crates.io-index`
380 Downloading rand v0.3.8
381 Downloading libc v0.1.6
382 Compiling libc v0.1.6
383 Compiling rand v0.3.8
384 Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
387 (You may see different versions, of course.)
389 Lots of new output! Now that we have an external dependency, Cargo fetches the
390 latest versions of everything from the registry, which is a copy of data from
391 [Crates.io][cratesio]. Crates.io is where people in the Rust ecosystem
392 post their open source Rust projects for others to use.
394 [cratesio]: https://crates.io
396 After updating the registry, Cargo checks our `[dependencies]` and downloads
397 any we don’t have yet. In this case, while we only said we wanted to depend on
398 `rand`, we’ve also grabbed a copy of `libc`. This is because `rand` depends on
399 `libc` to work. After downloading them, it compiles them, and then compiles
402 If we run `cargo build` again, we’ll get different output:
408 That’s right, no output! Cargo knows that our project has been built, and that
409 all of its dependencies are built, and so there’s no reason to do all that
410 stuff. With nothing to do, it simply exits. If we open up `src/main.rs` again,
411 make a trivial change, and then save it again, we’ll only see one line:
415 Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
418 So, we told Cargo we wanted any `0.3.x` version of `rand`, and so it fetched the latest
419 version at the time this was written, `v0.3.8`. But what happens when next
420 week, version `v0.3.9` comes out, with an important bugfix? While getting
421 bugfixes is important, what if `0.3.9` contains a regression that breaks our
424 The answer to this problem is the `Cargo.lock` file you’ll now find in your
425 project directory. When you build your project for the first time, Cargo
426 figures out all of the versions that fit your criteria, and then writes them
427 to the `Cargo.lock` file. When you build your project in the future, Cargo
428 will see that the `Cargo.lock` file exists, and then use that specific version
429 rather than do all the work of figuring out versions again. This lets you
430 have a repeatable build automatically. In other words, we’ll stay at `0.3.8`
431 until we explicitly upgrade, and so will anyone who we share our code with,
432 thanks to the lock file.
434 What about when we _do_ want to use `v0.3.9`? Cargo has another command,
435 `update`, which says ‘ignore the lock, figure out all the latest versions that
436 fit what we’ve specified. If that works, write those versions out to the lock
437 file’. But, by default, Cargo will only look for versions larger than `0.3.0`
438 and smaller than `0.4.0`. If we want to move to `0.4.x`, we’d have to update
439 the `Cargo.toml` directly. When we do, the next time we `cargo build`, Cargo
440 will update the index and re-evaluate our `rand` requirements.
442 There’s a lot more to say about [Cargo][doccargo] and [its
443 ecosystem][doccratesio], but for now, that’s all we need to know. Cargo makes
444 it really easy to re-use libraries, and so Rustaceans tend to write smaller
445 projects which are assembled out of a number of sub-packages.
447 [doccargo]: http://doc.crates.io
448 [doccratesio]: http://doc.crates.io/crates-io.html
450 Let’s get on to actually _using_ `rand`. Here’s our next step:
459 println!("Guess the number!");
461 let secret_number = rand::thread_rng().gen_range(1, 101);
463 println!("The secret number is: {}", secret_number);
465 println!("Please input your guess.");
467 let mut guess = String::new();
469 io::stdin().read_line(&mut guess)
470 .expect("failed to read line");
472 println!("You guessed: {}", guess);
476 The first thing we’ve done is change the first line. It now says
477 `extern crate rand`. Because we declared `rand` in our `[dependencies]`, we
478 can use `extern crate` to let Rust know we’ll be making use of it. This also
479 does the equivalent of a `use rand;` as well, so we can make use of anything
480 in the `rand` crate by prefixing it with `rand::`.
482 Next, we added another `use` line: `use rand::Rng`. We’re going to use a
483 method in a moment, and it requires that `Rng` be in scope to work. The basic
484 idea is this: methods are defined on something called ‘traits’, and for the
485 method to work, it needs the trait to be in scope. For more about the
486 details, read the [traits][traits] section.
488 [traits]: traits.html
490 There are two other lines we added, in the middle:
493 let secret_number = rand::thread_rng().gen_range(1, 101);
495 println!("The secret number is: {}", secret_number);
498 We use the `rand::thread_rng()` function to get a copy of the random number
499 generator, which is local to the particular [thread][concurrency] of execution
500 we’re in. Because we `use rand::Rng`’d above, it has a `gen_range()` method
501 available. This method takes two arguments, and generates a number between
502 them. It’s inclusive on the lower bound, but exclusive on the upper bound,
503 so we need `1` and `101` to get a number ranging from one to a hundred.
505 [concurrency]: concurrency.html
507 The second line prints out the secret number. This is useful while
508 we’re developing our program, so we can easily test it out. But we’ll be
509 deleting it for the final version. It’s not much of a game if it prints out
510 the answer when you start it up!
512 Try running our new program a few times:
516 Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
517 Running `target/debug/guessing_game`
519 The secret number is: 7
520 Please input your guess.
524 Running `target/debug/guessing_game`
526 The secret number is: 83
527 Please input your guess.
532 Great! Next up: comparing our guess to the secret number.
536 Now that we’ve got user input, let’s compare our guess to the secret number.
537 Here’s our next step, though it doesn’t quite compile yet:
543 use std::cmp::Ordering;
547 println!("Guess the number!");
549 let secret_number = rand::thread_rng().gen_range(1, 101);
551 println!("The secret number is: {}", secret_number);
553 println!("Please input your guess.");
555 let mut guess = String::new();
557 io::stdin().read_line(&mut guess)
558 .expect("failed to read line");
560 println!("You guessed: {}", guess);
562 match guess.cmp(&secret_number) {
563 Ordering::Less => println!("Too small!"),
564 Ordering::Greater => println!("Too big!"),
565 Ordering::Equal => println!("You win!"),
570 A few new bits here. The first is another `use`. We bring a type called
571 `std::cmp::Ordering` into scope. Then, five new lines at the bottom that use
575 match guess.cmp(&secret_number) {
576 Ordering::Less => println!("Too small!"),
577 Ordering::Greater => println!("Too big!"),
578 Ordering::Equal => println!("You win!"),
582 The `cmp()` method can be called on anything that can be compared, and it
583 takes a reference to the thing you want to compare it to. It returns the
584 `Ordering` type we `use`d earlier. We use a [`match`][match] statement to
585 determine exactly what kind of `Ordering` it is. `Ordering` is an
586 [`enum`][enum], short for ‘enumeration’, which looks like this:
598 With this definition, anything of type `Foo` can be either a
599 `Foo::Bar` or a `Foo::Baz`. We use the `::` to indicate the
600 namespace for a particular `enum` variant.
602 The [`Ordering`][ordering] `enum` has three possible variants: `Less`, `Equal`,
603 and `Greater`. The `match` statement takes a value of a type, and lets you
604 create an ‘arm’ for each possible value. Since we have three types of
605 `Ordering`, we have three arms:
608 match guess.cmp(&secret_number) {
609 Ordering::Less => println!("Too small!"),
610 Ordering::Greater => println!("Too big!"),
611 Ordering::Equal => println!("You win!"),
615 [ordering]: ../std/cmp/enum.Ordering.html
617 If it’s `Less`, we print `Too small!`, if it’s `Greater`, `Too big!`, and if
618 `Equal`, `You win!`. `match` is really useful, and is used often in Rust.
620 I did mention that this won’t quite compile yet, though. Let’s try it:
624 Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
625 src/main.rs:28:21: 28:35 error: mismatched types:
626 expected `&collections::string::String`,
628 (expected struct `collections::string::String`,
629 found integral variable) [E0308]
630 src/main.rs:28 match guess.cmp(&secret_number) {
632 error: aborting due to previous error
633 Could not compile `guessing_game`.
636 Whew! This is a big error. The core of it is that we have ‘mismatched types’.
637 Rust has a strong, static type system. However, it also has type inference.
638 When we wrote `let guess = String::new()`, Rust was able to infer that `guess`
639 should be a `String`, and so it doesn’t make us write out the type. And with
640 our `secret_number`, there are a number of types which can have a value
641 between one and a hundred: `i32`, a thirty-two-bit number, or `u32`, an
642 unsigned thirty-two-bit number, or `i64`, a sixty-four-bit number or others.
643 So far, that hasn’t mattered, and so Rust defaults to an `i32`. However, here,
644 Rust doesn’t know how to compare the `guess` and the `secret_number`. They
645 need to be the same type. Ultimately, we want to convert the `String` we
646 read as input into a real number type, for comparison. We can do that
647 with three more lines. Here’s our new program:
653 use std::cmp::Ordering;
657 println!("Guess the number!");
659 let secret_number = rand::thread_rng().gen_range(1, 101);
661 println!("The secret number is: {}", secret_number);
663 println!("Please input your guess.");
665 let mut guess = String::new();
667 io::stdin().read_line(&mut guess)
668 .expect("failed to read line");
670 let guess: u32 = guess.trim().parse()
671 .expect("Please type a number!");
673 println!("You guessed: {}", guess);
675 match guess.cmp(&secret_number) {
676 Ordering::Less => println!("Too small!"),
677 Ordering::Greater => println!("Too big!"),
678 Ordering::Equal => println!("You win!"),
686 let guess: u32 = guess.trim().parse()
687 .expect("Please type a number!");
690 Wait a minute, I thought we already had a `guess`? We do, but Rust allows us
691 to ‘shadow’ the previous `guess` with a new one. This is often used in this
692 exact situation, where `guess` starts as a `String`, but we want to convert it
693 to an `u32`. Shadowing lets us re-use the `guess` name, rather than forcing us
694 to come up with two unique names like `guess_str` and `guess`, or something
697 We bind `guess` to an expression that looks like something we wrote earlier:
703 Here, `guess` refers to the old `guess`, the one that was a `String` with our
704 input in it. The `trim()` method on `String`s will eliminate any white space at
705 the beginning and end of our string. This is important, as we had to press the
706 ‘return’ key to satisfy `read_line()`. This means that if we type `5` and hit
707 return, `guess` looks like this: `5\n`. The `\n` represents ‘newline’, the
708 enter key. `trim()` gets rid of this, leaving our string with only the `5`. The
709 [`parse()` method on strings][parse] parses a string into some kind of number.
710 Since it can parse a variety of numbers, we need to give Rust a hint as to the
711 exact type of number we want. Hence, `let guess: u32`. The colon (`:`) after
712 `guess` tells Rust we’re going to annotate its type. `u32` is an unsigned,
713 thirty-two bit integer. Rust has [a number of built-in number types][number],
714 but we’ve chosen `u32`. It’s a good default choice for a small positive number.
716 [parse]: ../std/primitive.str.html#method.parse
717 [number]: primitive-types.html#numeric-types
719 Just like `read_line()`, our call to `parse()` could cause an error. What if
720 our string contained `A👍%`? There’d be no way to convert that to a number. As
721 such, we’ll do the same thing we did with `read_line()`: use the `expect()`
722 method to crash if there’s an error.
724 Let’s try our program out!
728 Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
729 Running `target/guessing_game`
731 The secret number is: 58
732 Please input your guess.
738 Nice! You can see I even added spaces before my guess, and it still figured
739 out that I guessed 76. Run the program a few times, and verify that guessing
740 the number works, as well as guessing a number too small.
742 Now we’ve got most of the game working, but we can only make one guess. Let’s
743 change that by adding loops!
747 The `loop` keyword gives us an infinite loop. Let’s add that in:
753 use std::cmp::Ordering;
757 println!("Guess the number!");
759 let secret_number = rand::thread_rng().gen_range(1, 101);
761 println!("The secret number is: {}", secret_number);
764 println!("Please input your guess.");
766 let mut guess = String::new();
768 io::stdin().read_line(&mut guess)
769 .expect("failed to read line");
771 let guess: u32 = guess.trim().parse()
772 .expect("Please type a number!");
774 println!("You guessed: {}", guess);
776 match guess.cmp(&secret_number) {
777 Ordering::Less => println!("Too small!"),
778 Ordering::Greater => println!("Too big!"),
779 Ordering::Equal => println!("You win!"),
785 And try it out. But wait, didn’t we just add an infinite loop? Yup. Remember
786 our discussion about `parse()`? If we give a non-number answer, we’ll `panic!`
791 Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
792 Running `target/guessing_game`
794 The secret number is: 59
795 Please input your guess.
799 Please input your guess.
803 Please input your guess.
807 Please input your guess.
809 thread '<main>' panicked at 'Please type a number!'
812 Ha! `quit` actually quits. As does any other non-number input. Well, this is
813 suboptimal to say the least. First, let’s actually quit when you win the game:
819 use std::cmp::Ordering;
823 println!("Guess the number!");
825 let secret_number = rand::thread_rng().gen_range(1, 101);
827 println!("The secret number is: {}", secret_number);
830 println!("Please input your guess.");
832 let mut guess = String::new();
834 io::stdin().read_line(&mut guess)
835 .expect("failed to read line");
837 let guess: u32 = guess.trim().parse()
838 .expect("Please type a number!");
840 println!("You guessed: {}", guess);
842 match guess.cmp(&secret_number) {
843 Ordering::Less => println!("Too small!"),
844 Ordering::Greater => println!("Too big!"),
846 println!("You win!");
854 By adding the `break` line after the `You win!`, we’ll exit the loop when we
855 win. Exiting the loop also means exiting the program, since it’s the last
856 thing in `main()`. We have only one more tweak to make: when someone inputs a
857 non-number, we don’t want to quit, we want to ignore it. We can do that
864 use std::cmp::Ordering;
868 println!("Guess the number!");
870 let secret_number = rand::thread_rng().gen_range(1, 101);
872 println!("The secret number is: {}", secret_number);
875 println!("Please input your guess.");
877 let mut guess = String::new();
879 io::stdin().read_line(&mut guess)
880 .expect("failed to read line");
882 let guess: u32 = match guess.trim().parse() {
887 println!("You guessed: {}", guess);
889 match guess.cmp(&secret_number) {
890 Ordering::Less => println!("Too small!"),
891 Ordering::Greater => println!("Too big!"),
893 println!("You win!");
901 These are the lines that changed:
904 let guess: u32 = match guess.trim().parse() {
910 This is how you generally move from ‘crash on error’ to ‘actually handle the
911 returned by `parse()` is an `enum` like `Ordering`, but in this case, each
912 variant has some data associated with it: `Ok` is a success, and `Err` is a
913 failure. Each contains more information: the successfully parsed integer, or an
914 error type. In this case, we `match` on `Ok(num)`, which sets the inner value
915 of the `Ok` to the name `num`, and then we return it on the right-hand
916 side. In the `Err` case, we don’t care what kind of error it is, so we
917 use `_` instead of a name. This ignores the error, and `continue` causes us
918 to go to the next iteration of the `loop`.
920 Now we should be good! Let’s try:
924 Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
925 Running `target/guessing_game`
927 The secret number is: 61
928 Please input your guess.
932 Please input your guess.
936 Please input your guess.
938 Please input your guess.
944 Awesome! With one tiny last tweak, we have finished the guessing game. Can you
945 think of what it is? That’s right, we don’t want to print out the secret
946 number. It was good for testing, but it kind of ruins the game. Here’s our
953 use std::cmp::Ordering;
957 println!("Guess the number!");
959 let secret_number = rand::thread_rng().gen_range(1, 101);
962 println!("Please input your guess.");
964 let mut guess = String::new();
966 io::stdin().read_line(&mut guess)
967 .expect("failed to read line");
969 let guess: u32 = match guess.trim().parse() {
974 println!("You guessed: {}", guess);
976 match guess.cmp(&secret_number) {
977 Ordering::Less => println!("Too small!"),
978 Ordering::Greater => println!("Too big!"),
980 println!("You win!");
990 At this point, you have successfully built the Guessing Game! Congratulations!
992 This first project showed you a lot: `let`, `match`, methods, associated
993 functions, using external crates, and more. Our next project will show off