[翻訳]Rustを学ぼう - 数字当てゲーム

**Rustドキュメントの日本語訳は [Rustドキュメント翻訳プロジェクト](https://github.com/rust-lang-ja/the-rust-programming-language-ja) に移行しました。**

http://rust-lang-ja.github.io/the-rust-programming-language-ja/1.6/book/guessing-game.html にてRust 1.6原文に追従した版があります。

----

Rust 1.0時点の [Learn Rust - Guessing Game](https://doc.rust-lang.org/book/guessing-game.html) より訳出。

- 元ソース：https://github.com/rust-lang/rust/blob/1.0.0/src/doc/trpl/guessing-game.md
- ライセンス：MIT licenseまたはApache License 2.0, https://github.com/rust-lang/rust/blob/1.0.0/COPYRIGHT

訳者注：Qiita Markdownソースには原文をコメント形式`<!--`/`-->`で残してあります。誤訳修正や訳出改善の編集リクエストを歓迎します。

---
# 数字当てゲーム(Guessing Game)

<!-- For our first project, we’ll implement a classic beginner programming problem: the guessing game. Here’s how it works: Our program will generate a random integer between one and a hundred. It will then prompt us to enter a guess. Upon entering our guess, it will tell us if we’re too low or too high. Once we guess correctly, it will congratulate us. Sounds good? -->
私たちの最初のプロジェクトとして、プログラミング入門の古典問題：数当てゲームを実装していきます。動作はこんな感じです：プログラムは1から100までの間でランダムな整数を一つ生成し、ユーザが推測した値を入力させます。推測値が入力されると、プログラムが選んだ数字よりも高いか低いかを教えます。正しい値に到達したら、そこでゲームクリアです。いい感じでしょ？

# セットアップ(Set up)

<!-- Let’s set up a new project. Go to your projects directory. Remember how we had to create our directory structure and a `Cargo.toml` for `hello_world`? Cargo has a command that does that for us. Let’s give it a shot: -->
では新しいプロジェクトを準備しましょう。プロジェクト用のディレクトリに行ってください。ディレクトリ構造や`hello_world`での`Cargo.toml`の作り方を覚えていますか？Cargoはそのためのコマンドを持っています。次の通りにやってみて:

```bash
$ cd ~/projects
$ cargo new guessing_game --bin
$ cd guessing_game
```

<!-- We pass the name of our project to `cargo new`, and then the `--bin` flag, since we’re making a binary, rather than a library. -->
ここでは`cargo new`にプロジェクトの名前を渡し、ライブラリではなくバイナリを作るために`--bin`フラグを指定しました。

<!-- Check out the generated `Cargo.toml`: -->
生成された`Cargo.toml`を確認してみましょう:

```toml
[package]

name = "guessing_game"
version = "0.0.1"
authors = ["Your Name <you@example.com>"]
```

<!-- Cargo gets this information from your environment. If it’s not correct, go ahead and fix that. -->
Cargoはこの情報をあなたの環境から取得しています。間違っていたら直しておいてください。

<!-- Finally, Cargo generated a ‘Hello, world!’ for us. Check out `src/main.rs`: -->
最後に、Cargoは‘Hello, world!’を生成してくれます。`src/main.rs`を確認してみます:

```rust
fn main() {
    println!("Hello, world!")
}
```

<!-- Let’s try compiling what Cargo gave us:-->
さっそくCargoが用意したものをコンパイルしましょう:

```bash
$ cargo build
   Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
```

<!-- Excellent! Open up your `src/main.rs` again. We’ll be writing all of our code in this file. -->
よろしい！ではもう一度`src/main.rs`を開いてください。私たちのコードは全部このファイルに書いていきます。

<!-- Before we move on, let me show you one more Cargo command: `run`. `cargo run` is kind of like `cargo build`, but it also then runs the produced executable. Try it out: -->
先に進む前に、もう一つCargoのコマンド`run`を説明しておきましょうか。`cargo run`は`cargo build`と似ていますが、出来上がったファイルの実行まで行います。では試してみます:

```bash
$ cargo run
   Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
     Running `target/debug/guessing_game`
Hello, world!
```

<!-- Great! The `run` command comes in handy when you need to rapidly iterate on a project. Our game is just such a project, we need to quickly test each iteration before moving on to the next one. -->
素晴らしい！プロジェクトをすばやくイテレーションする場合は、`run`コマンドが便利です。私たちのゲームは、次ステップへ進む前にはイテレーション毎で確認する必要があるため、まさにその手のプロジェクトといえます。

# 推測値を処理する(Processing a Guess)

<!-- Let’s get to it! The first thing we need to do for our guessing game is allow our player to input a guess. Put this in your `src/main.rs`: -->
では始めましょう！数当てゲームで最初にすべきことは、プレイヤーに推測値を入力させることです。`src/main.rs`に次のとおり書いてください:

```rust
use std::io;

fn main() {
    println!("Guess the number!");

    println!("Please input your guess.");

    let mut guess = String::new();

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

    println!("You guessed: {}", guess);
}
```

<!-- There’s a lot here! Let’s go over it, bit by bit.-->
盛りだくさんですね！少しづつ見ていきましょうか。

```rust
use std::io;
```

<!-- We’ll need to take user input, and then print the result as output. As such, we need the `io` library from the standard library. Rust only imports a few things into every program, [the ‘prelude’][prelude]. If it’s not in the prelude, you’ll have to `use` it directly. -->
私たちはユーザ入力を受け付けて、さらに出力として結果を表示しなければなりません。ということで、標準ライブラリにある`io`ライブラリが必要になります。Rustでは、すべてのプログラムに「[プレリュード(prelude)][prelude]」に含まれるものしかインポートしません。あるライブラリ機能がプレリュードに含まれないときは、直接`use`する必要があります。

[prelude]: https://doc.rust-lang.org/std/prelude/

```rust
fn main() {
```

<!-- As you’ve seen before, the `main()` function is the entry point into your program. The `fn` syntax declares a new function, the `()`s indicate that there are no arguments, and `{` starts the body of the function. Because we didn’t include a return type, it’s assumed to be `()`, an empty [tuple][tuples]. -->
すでに見たとおり、`main()`関数がプログラムのエントリポイントになります。`fn`構文は新しい関数を宣言し、`()`は引数が無いことを表します。そして`{`で関数の本体が開始します。戻り値型を明記しなかったため、ここでは空の[タプル(tuple)][tuples]`()`とみなされます。

[tuples]: https://doc.rust-lang.org/book/primitive-types.html#tuples

```rust
    println!("Guess the number!");

    println!("Please input your guess.");
```

<!-- We previously learned that `println!()` is a [macro][macros] that prints a [string][strings] to the screen.-->
`println!()`が画面に[文字列(string)][strings]を表示する[マクロ(macro)][macros]であることは前に学びました。

[macros]: https://doc.rust-lang.org/book/macros.html
[strings]: https://doc.rust-lang.org/book/strings.html

```rust
    let mut guess = String::new();
```

<!-- Now we’re getting interesting! There’s a lot going on in this little line. The first thing to notice is that this is a [let statement][let], which is used to create ‘variable bindings’. They take this form: -->
さあ面白いところにきました！この1行には様々な要素がふくまれています。最初に気づくのは、これが「変数束縛(variable bindings)」に用いられる[let文(let statement)][let]であることです。次の形式をとります:

```rust
let foo = bar;
```

[let]: https://doc.rust-lang.org/book/variable-bindings.html

<!-- This will create a new binding named `foo`, and bind it to the value `bar`. In many languages, this is called a ‘variable’, but Rust’s variable bindings have a few tricks up their sleeves. -->
これは`foo`という名前で新しい束縛を作り、そこに`bar`の値を結びつけます(bind)。多くのプログラミング言語では「変数(variable)」と呼ばれますが、Rustの変数束縛にはいくつかの秘策が隠されているのです。

<!-- For example, they’re [immutable][immutable] by default. That’s why our example uses `mut`: it makes a binding mutable, rather than immutable. `let` doesn’t take a name on the left hand side, it actually accepts a ‘[pattern][patterns]’. We’ll use patterns more later. It’s easy enough to use for now: -->
例えば、変数束縛はデフォルトで[immutable][immutable]です。私たちの例で`mut`を使うのはこのため: immutableではなく、mutableな束縛とするためです。`let`はその左側に名前をとるのではなく、実は「[パターン(pattern)][patterns]」を書くことができます。パターンは後ほど使いましょう。今は簡単な使い方で十分です:

```rust
let foo = 5; // immutable.
let mut bar = 5; // mutable
```

[immutable]: https://doc.rust-lang.org/book/mutability.html
[patterns]: https://doc.rust-lang.org/book/patterns.html

<!-- Oh, and `//` will start a comment, until the end of the line. Rust ignores everything in [comments][comments]. -->
あと、`//`から行末まではコメントになります。Rustは[コメント(comments)][comments]部分を全部無視します。

[comments]: https://doc.rust-lang.org/book/comments.html

<!-- So now we know that `let mut guess` will introduce a mutable binding named `guess`, but we have to look at the other side of the `=` for what it’s bound to: `String::new()`. -->
`let mut guess`が名前`guess`のmutable束縛を導入すると理解したところで、`=`の逆側にある`String::new()`が意味するところを見ていく必要があります。

<!-- `String` is a string type, provided by the standard library. A [`String`][string] is a growable, UTF-8 encoded bit of text. -->
`String`は文字列型であり、標準ライブラリで提供されます。[`String`][string]は可変長であり、テキストをUTF-8エンコーディングしたものです。

[string]: https://doc.rust-lang.org/std/string/struct.String.html

<!-- The `::new()` syntax uses `::` because this is an ‘associated function’ of a particular type. That is to say, it’s associated with `String` itself, rather than a particular instance of a `String`. Some languages call this a ‘static method’. -->
`::new()`構文は`::`を使いますが、これはある型に「関連する関数(associated function)」となっているためです[^note_assocfunc]。つまり、`String`型の特定のインスタンスではなく、`String`型自身に関連付けられています。プログラミング言語によってはこれを「静的メソッド(static method)」と呼ぶものもあります。

[^note_assocfunc]: 訳注：日本語圏では用語が安定していない（と思う）ので、あえて"associated function"を直訳調の「関連する関数」とした。もうちょいマシな対訳語が欲しいところ。

<!-- This function is named `new()`, because it creates a new, empty `String`. You’ll find a `new()` function on many types, as it’s a common name for making a new value of some kind. -->
この関数は新しい空の`String`を生成するため、`new()`という名前を持ちます。その型の新しい値を作る一般的な名前のため、多くの型で`new()`関数を見つけられるでしょう。

<!-- Let’s move forward: -->
では次に行きましょう:

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

<!-- That’s a lot more! Let’s go bit-by-bit. The first line has two parts. Here’s the first: -->
これまた沢山！ちょっとづつ見ていきましょう。最初の行は2つのパートから成ります。まずはこちら:

```rust
io::stdin()
```

<!-- Remember how we `use`d `std::io` on the first line of the program? We’re now calling an associated function on it. If we didn’t `use std::io`, we could have written this line as `std::io::stdin()`. -->
プログラムの冒頭行で`std::io`を`use`したのを覚えていますか？ここでは関連する関数(associated function)を呼び出しているのです。もし`use std::io`がなかったら、この行は`std::io::stdin()`と書かなければなりませんでした。

<!-- This particular function returns a handle to the standard input for your terminal. More specifically, a [std::io::Stdin][iostdin]. -->
この関数は端末の標準入力へのハンドルを返します。具体的には[std::io::Stdin][iostdin]を返します。

[iostdin]: https://doc.rust-lang.org/std/io/struct.Stdin.html

<!-- The next part will use this handle to get input from the user: -->
続くパートでは、ユーザ入力の取得にこのハンドルを使います:

```rust
.read_line(&mut guess)
```

<!-- Here, we call the [`read_line()`][read_line] method on our handle. [Method][method]s are like associated functions, but are only available on a particular instance of a type, rather than the type itself. We’re also passing one argument to `read_line()`: `&mut guess`. -->
ここでは、ハンドルに対して[`read_line()`][read_line]メソッドを呼び出します。[メソッド(method)][method]は関連する関数(associated function)と似ていますが、その型自身ではなく、型の特定インスタンスに対してのみ有効です。また`read_line()`には引数も1つ: `&mut guess`を渡しています。

[read_line]: https://doc.rust-lang.org/std/io/struct.Stdin.html#method.read_line
[method]: https://doc.rust-lang.org/book/methods.html

<!-- Remember how we bound `guess` above? We said it was mutable. However, `read_line` doesn’t take a `String` as an argument: it takes a `&mut String`. Rust has a feature called ‘[references][references]’, which allows you to have multiple references to one piece of data, which can reduce copying. References are a complex feature, as one of Rust’s major selling points is how safe and easy it is to use references. We don’t need to know a lot of those details to finish our program right now, though. For now, all we need to know is that like `let` bindings, references are immutable by default. Hence, we need to write `&mut guess`, rather than `&guess`. -->
上で`guess`に束縛したやり方を覚えていますか？mutableな束縛としましたね。しかし、`read_line`は引数として`String`を取りません: `&mut String`を取ります。Rustには、あるデータへの複数個の参照ができて、コピー回数を減らせる、「[参照(references)][references]」という機能があります。参照を安全かつ簡単に扱えることはRustの主要なセールスポイントの1つですが、参照は複雑な機能です。もっとも、今回のプログラムを完成させるにはその詳細まで理解する必要はありません。今知っておくべきは、`let`束縛と同じく参照もデフォルトでimmutableとなる点です。なので、`&guess`ではなく`&mut guess`と書く必要があります。

<!-- Why does `read_line()` take a mutable reference to a string? Its job is to take what the user types into standard input, and place that into a string. So it takes that string as an argument, and in order to add the input, it needs to be mutable. -->
どうして`read_line()`が文字列へのmutable参照をとるのでしょう？この関数の仕事はユーザが標準入力にタイプしたものを取得し、文字列へと変換することです。なので関数は文字列を引数として取り、入力を追加するためにはmutableとする必要があるのです。

[references]: https://doc.rust-lang.org/book/references-and-borrowing.html

<!-- But we’re not quite done with this line of code, though. While it’s a single line of text, it’s only the first part of the single logical line of code: -->
ただし、コードのこの行はまだ終わっていません。テキストの1行ではありますが、コードの1論理行の最初のパートにすぎません:

```rust
        .ok()
        .expect("Failed to read line");
```

<!-- When you call a method with the `.foo()` syntax, you may introduce a newline and other whitespace. This helps you split up long lines. We _could_ have done: -->
`.foo()`構文でメソッドを呼び出すとき、新しい行や空白から始めることがあります。これは長い行を分割するのに役立ちます。次のようにも書くことも_できます_:

```rust
    io::stdin().read_line(&mut guess).ok().expect("failed to read line");
```

<!-- But that gets hard to read. So we’ve split it up, three lines for three method calls. We already talked about `read_line()`, but what about `ok()` and `expect()`? Well, we already mentioned that `read_line()` puts what the user types into the `&mut String` we pass it. But it also returns a value: in this case, an [`io::Result`][ioresult]. Rust has a number of types named `Result` in its standard library: a generic [`Result`][result], and then specific versions for sub-libraries, like `io::Result`. -->
これでは読むのが大変です。それで3つのメソッド呼び出しを3行に分けたのです。すでに`read_line()`には言及しましたが、`ok()`と`expect()`はどうでしょう？ええと、`read_line()`はユーザ入力を渡した`&mut String`へ代入することは説明した通りです。しかしその戻り値: この場合は[`io::Result`][ioresult]も返しているのです。Rust標準ライブラリには`Result`という名前の型がいくつかあります: ジェネリックな[`Result`][result]と、`io::Result`のようなサブラリブラリ用の具体的な型です。

[ioresult]: https://doc.rust-lang.org/std/io/type.Result.html
[result]: https://doc.rust-lang.org/std/result/enum.Result.html

<!-- The purpose of these `Result` types is to encode error handling information. Values of the `Result` type, like any type, have methods defined on them. In this case, `io::Result` has an `ok()` method, which says ‘we want to assume this value is a successful one. If not, just throw away the error information’. Why throw it away? Well, for a basic program, we just want to print a generic error, as basically any issue means we can’t continue. The [`ok()` method][ok] returns a value which has another method defined on it: `expect()`. The [`expect()` method][expect] takes a value it’s called on, and if it isn’t a successful one, [`panic!`][panic]s with a message you passed it. A `panic!` like this will cause our program to crash, displaying the message. -->
これら`Result`型の目的は、エラーハンドリング情報をエンコードすることです。`Result`型の値は、任意の型と同様に、メソッドを定義しています。この場合は`io::Result`が`ok()`メソッドを持ち、その意味は「我々はこの値が成功を意味すると仮定する。そうでなければエラー情報を捨てればよい。」となります。なぜ捨ててしまうのでしょう？基本的なプログラムでは、なんらかの問題が生じたときは処理続行不可能を意味するため、一般エラーを表示できれば十分でしょう。[`ok()`メソッド][ok]は、もう一つのメソッド`expect()`を定義する値を返します。[`expect()`メソッド][expect]呼び出しには値を取り、もし成功を意味していなければ、その値は[`panic!`][panic]メッセージとして渡されます。この`panic!`はプログラムをクラッシュさせ、メッセージを表示します。

[ok]: https://doc.rust-lang.org/std/result/enum.Result.html#method.ok
[expect]: https://doc.rust-lang.org/std/option/enum.Option.html#method.expect
[panic]: https://doc.rust-lang.org/book/error-handling.html

<!-- If we leave off calling these two methods, our program will compile, but we’ll get a warning: -->
これら2つのメソッド呼び出しをやめても、プログラムはコンパイルできますが、警告がなされるでしょう:

```bash
$ cargo build
   Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
src/main.rs:10:5: 10:39 warning: unused result which must be used,
#[warn(unused_must_use)] on by default
src/main.rs:10     io::stdin().read_line(&mut guess);
                   ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
```

<!-- Rust warns us that we haven’t used the `Result` value. This warning comes from a special annotation that `io::Result` has. Rust is trying to tell you that you haven’t handled a possible error. The right way to suppress the error is to actually write error handling. Luckily, if we just want to crash if there’s a problem, we can use these two little methods. If we can recover from the error somehow, we’d do something else, but we’ll save that for a future project. -->
Rustは私たちが`Result`値を使っていないと警告しています。この警告は`io::Result`への特殊なアノテーションによるものです。Rustは、エラー発生の可能性を扱っていないケースを教えてくれるのです。エラーを抑制する正しい方法は、エラーハンドリング処理を実際に書くことです。幸運にも、問題が起きた場合はクラッシュさせたいだけですから、今回は2つの小さなメソッド利用で十分です。エラーからどうにかして回復できるのならば、何かしらの対処が必要ですが、それは将来のプロジェクトのためにとっておきましょう。

<!-- There’s just one line of this first example left: -->
この最初の例では、あと1行を残すのみとなりました:

```rust
    println!("You guessed: {}", guess);
}
```

<!-- This prints out the string we saved our input in. The `{}`s are a placeholder, and so we pass it `guess` as an argument. If we had multiple `{}`s, we would pass multiple arguments: -->
ここでは入力を保存しておいた文字列を表示します。`{}`はプレースホルダーであり、対応させる`guess`を引数として渡します。複数の`{}`がある場合は、複数個の引数を渡すことになります:

```rust
let x = 5;
let y = 10;

println!("x and y: {} and {}", x, y);
```

<!-- Easy. -->
簡単ですね。

<!-- Anyway, that’s the tour. We can run what we have with `cargo run`: -->
何にせよ、ツアーは以上です。ここまでで`cargo run`で実行できます:

```bash
$ cargo run
   Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
     Running `target/debug/guessing_game`
Guess the number!
Please input your guess.
6
You guessed: 6
```

<!-- All right! Our first part is done: we can get input from the keyboard, and then print it back out. -->
オーライ！最初のパートが完了です: キーボードからの入力を取得し、それを表示し返すことができました。

# 秘密の数字を生成する(Generating a secret number)

<!-- Next, we need to generate a secret number. Rust does not yet include random number functionality in its standard library. The Rust team does, however, provide a [`rand` crate][randcrate]. A ‘crate’ is a package of Rust code. We’ve been building a ‘binary crate’, which is an executable. `rand` is a ‘library crate’, which contains code that’s intended to be used with other programs. -->
次は、秘密の数字を生成する必要があります。Rust標準ライブラリはまだ乱数生成機能を含んでいません。ただし、Rustチームが[`rand`クレート][randcrate]を提供しています。「クレート(crate)」はRustコードのパッケージです。私たちは実行可能な「バイナリ・クレート(binary crate)」をビルドしてきました。`rand`は「ライブラリ・クレート(library crate)」であり、他プログラムから利用されることを目的としたコードを含みます。

[randcrate]: https://crates.io/crates/rand

<!-- Using external crates is where Cargo really shines. Before we can write the code using `rand`, we need to modify our `Cargo.toml`. Open it up, and add these few lines at the bottom: -->
外部クレートの利用ではCargoの真価が発揮されます。`rand`を利用したコードを書く前に、私たちの`Cargo.toml`を変更する必要があります。ファイルを開いて、次の数行を下部に追記してください:

```toml
[dependencies]

rand="0.3.0"
```

<!-- The `[dependencies]` section of `Cargo.toml` is like the `[package]` section: everything that follows it is part of it, until the next section starts. Cargo uses the dependencies section to know what dependencies on external crates you have, and what versions you require. In this case, we’ve used version `0.3.0`. Cargo understands [Semantic Versioning][semver], which is a standard for writing version numbers. If we wanted to use the latest version we could use `*` or we could use a range of versions. [Cargo’s documentation][cargodoc] contains more details. -->
`Cargo.toml`の`[dependencies]`セクションは`[package]`と似ています: 次のセクションが始まるまでの後続内容は該当セクションに属します。Cargoは依存(dependencies)セクションを、依存先の外部クレートと要求バージョンの指定に利用します。ここでは、私たちはバージョン`0.3.0`を利用します。Cargoはバージョン番号付与の標準[セマンティック・バージョニング][semver]を理解します。最新版を使いたいなら、`*`やバージョン範囲の指定が可能です。[Cargoのドキュメント][cargodoc]に詳細があります。

[semver]: http://semver.org/lang/ja/
[cargodoc]: http://doc.crates.io/crates-io.html

<!-- Now, without changing any of our code, let’s build our project: -->
では、コードを一切変更していませんが、プロジェクトをビルドしましょう:

```bash
$ cargo build
    Updating registry `https://github.com/rust-lang/crates.io-index`
 Downloading rand v0.3.8
 Downloading libc v0.1.6
   Compiling libc v0.1.6
   Compiling rand v0.3.8
   Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
```

<!-- (You may see different versions, of course.) -->
（当然ですが、違うバージョンになるかもしれません。）

<!-- Lots of new output! Now that we have an external dependency, Cargo fetches the latest versions of everything from the registry, which is a copy of data from [Crates.io][cratesio]. Crates.io is where people in the Rust ecosystem post their open source Rust projects for others to use. -->
新しい出力がいっぱい！今回は外部の依存を指定したため、[Crates.io][cratesio]よりコピーされるレジストリから、Cargoが全ての最新バージョンを取ってきます。

[cratesio]: https://crates.io

<!-- After updating the registry, Cargo checks our `[dependencies]` and downloads any we don’t have yet. In this case, while we only said we wanted to depend on `rand`, we’ve also grabbed a copy of `libc`. This is because `rand` depends on `libc` to work. After downloading them, it compiles them, and then compiles our project. -->
レジストリを更新したのち、Cargoは`[dependencies]`をチェックして足りないものをダウンロードします。ここでは`rand`への依存のみを記述しましたが、`libc`のコピーも取得しています。これは`rand`が`libc`に依存しているためです。ダウンロードが終わると、それらをコンパイルし、その後に私たちのプロジェクトをコンパイルします。

<!-- If we run `cargo build` again, we’ll get different output: -->
もう一度`cargo build`を実行すると、異なる出力が得られるでしょう:

```bash
$ cargo build
```

<!-- That’s right, no output! Cargo knows that our project has been built, and that all of its dependencies are built, and so there’s no reason to do all that stuff. With nothing to do, it simply exits. If we open up `src/main.rs` again, make a trivial change, and then save it again, we’ll just see one line: -->
そうです、出力なし！プロジェクトがビルド済みで、また全ての依存先もビルド済みであり、何もしなくて良いことをCargoは知っています。することがなければ、単に終了します。再び`src/main.rs`を開いて、つまらない変更を行って、もう一度保存すれば、次の1行が出力されるでしょう:

```bash
$ cargo build
   Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
```

<!-- So, we told Cargo we wanted any `0.3.x` version of `rand`, and so it fetched the latest version at the time this was written, `v0.3.8`. But what happens when next week, version `v0.3.9` comes out, with an important bugfix? While getting bugfixes is important, what if `0.3.9` contains a regression that breaks our code? -->
Cargoには`rand`の任意バージョン`0.3.x`が欲しいと伝えたので、執筆時点での最新バージョン`v0.3.8`が取得されました。しかし翌週に、重要なバグ修正が行われたバージョン`v0.3.9`がリリースされたらどうなるでしょう？確かにバグ修正は重要ですが、`0.3.9`が私たちのコードを壊すレグレッションを起こすとしたら？

<!-- The answer to this problem is the `Cargo.lock` file you’ll now find in your project directory. When you build your project for the first time, Cargo figures out all of the versions that fit your 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 then use that specific version rather than do all the work of figuring out versions again. This lets you have a repeatable build automatically. In other words, we’ll stay at `0.3.8` until we explicitly upgrade, and so will anyone who we share our code with, thanks to the lock file. -->
プロジェクトのディレクトリ以下で見つかる`Cargo.lock`ファイルが、この問題への答えです。初めてプロジェクトをビルドするとき、Cargoは基準に適合する全バージョンを解決し、それらを`Cargo.lock`ファイルに書き出します。以降プロジェクトをビルドする際には、Cargoは`Cargo.lock`ファイルがあれば読み取って、再びバージョン解決処理を行う代わりに、指定されたバージョンを使います。これにより反復可能なビルドが自動的に達成されます。言い換えると、明示的にアップグレードしない限りは`0.3.8`のままです。誰かとコードを共有する場合には、lockファイルの恩恵があるでしょう。

<!-- What about when we _do_ want to use `v0.3.9`? Cargo has another command, `update`, which says ‘ignore the lock, figure out all the latest versions that fit what we’ve specified. If that works, write those versions out to the lock file’. But, by default, Cargo will only look for versions larger than `0.3.0` and smaller than `0.4.0`. If we want to move to `0.4.x`, we’d have to update the `Cargo.toml` directly. When we do, the next time we `cargo build`, Cargo will update the index and re-evaluate our `rand` requirements. -->
`v0.3.9`を使い_たい_場合はどうすれば？Cargoにはもう一つのコマンド`update`があり、その意味は「lockファイルを無視して、基準に合う最新バージョンを解決せよ。上手くいったら、それらのバージョン情報をlockファイルに書き出せ。」となります。ただし、デフォルトでは、Cargoはバージョン`0.3.0`以上かつ`0.4.0`未満だけを検索します。`0.4.x`に移行したければ、直接`Cargo.toml`を更新しなければなりません。そうすれば、次回`cargo build`したときに、Cargoはインデックスを更新して`rand`の要件を再評価するでしょう。

<!-- There’s a lot more to say about [Cargo][doccargo] and [its ecosystem][doccratesio], but for now, that’s all we need to know. Cargo makes it really easy to re-use libraries, and so Rustaceans tend to write smaller projects which are assembled out of a number of sub-packages. -->
[Cargo][doccargo]と[そのエコシステム][doccratesio]については、もっと言うべきことがあります。とはいえ今は、ここまでが知っておくべき全てです。Cargoによってライブラリ再利用が本当に簡単になるため、Rust使い(Rustaceans)は多くのサブパッケージで組み上げられる小さなプロジェクトを書く傾向があります。

[doccargo]: http://doc.crates.io
[doccratesio]: http://doc.crates.io/crates-io.html

<!-- Let’s get on to actually _using_ `rand`. Here’s our next step: -->
それでは`rand`を実際に_使って_いきましょう。これが次のステップです:

```rust
extern crate rand;

use std::io;
use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1, 101);

    println!("The secret number is: {}", secret_number);

    println!("Please input your guess.");

    let mut guess = String::new();

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

    println!("You guessed: {}", guess);
}
```

<!-- The first thing we’ve done is change the first line. It now says `extern crate rand`. Because we declared `rand` in our `[dependencies]`, we can use `extern crate` to let Rust know we’ll be making use of it. This also does the equivalent of a `use rand;` as well, so we can make use of anything in the `rand` crate by prefixing it with `rand::`. -->
最初に行ったのは冒頭行の変更です。今は`extern crate rand`になっています。`[dependencies]`で`rand`を宣言しておいたので、Rustにその利用を教えるために`extern crate`とできます。これは`use rand;`とも同じ意味であり、`rand::`プレフィクスを付ければ`rand`クレートの要素を使えるようになります。

<!-- Next, we added another `use` line: `use rand::Rng`. We’re going to use a method in a moment, and it requires that `Rng` be in scope to work. The basic idea is this: methods are defined on something called ‘traits’, and for the method to work, it needs the trait to be in scope. For more about the details, read the [traits][traits] section. -->
続いて、もう一つの`use`行: `use rand::Rng`を追加しました。すぐにメソッドを使う予定なので、そのとき要求される`Rng`をスコープに入れておきましょう。基本的な考え方は次の通りです: 「トレイト(traits)」と呼ばれる何かに対してメソッドが定義され、そのメソッドを動かすには、トレイトがスコープ内に存在している必要があります。より詳細を知りたければ、[トレイト(traits)][traits]の節を読んでください。

[traits]: https://doc.rust-lang.org/book/traits.html

<!-- There are two other lines we added, in the middle: -->
間には、2つの行を追加しました:

```rust
    let secret_number = rand::thread_rng().gen_range(1, 101);

    println!("The secret number is: {}", secret_number);
```

<!-- We use the `rand::thread_rng()` function to get a copy of the random number generator, which is local to the particular [thread][concurrency] of execution we’re in. Because we `use rand::Rng`’d above, it has a `gen_range()` method available. This method takes two arguments, and generates a number between them. It’s inclusive on the lower bound, but exclusive on the upper bound, so we need `1` and `101` to get a number between one and a hundred. -->
実行中の[スレッド(thread)][concurrency]に対してローカルな、乱数生成器のコピーを得るために`rand::thread_rng()`関数を使います。上で`use rand::Rng`としたため、`gen_range()`メソッドが有効になっています。このメソッドは2つの引数をとり、それらの間の数字を生成します。下限値は含みます(inclusive)が、上限値は範囲に含まれない(exclusive)ため、1から100までの間の数字を得るには`1`と`101`が必要になります。

[concurrency]: https://doc.rust-lang.org/book/concurrency.html

<!-- The second line just prints out the secret number. This is useful while we’re developing our program, so we can easily test it out. But we’ll be deleting it for the final version. It’s not much of a game if it prints out the answer when you start it up! -->
2行目では単に秘密の数字を表示します。確認が簡単になりますから、プログラム開発のあいだは便利です。ただし最終バージョンでは削除する予定です。最初から答えを表示してしまってはゲームになりませんからね！

<!-- Try running our new program a few times: -->
新しいプログラムを何回か実行してみます:

```bash
$ cargo run
   Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
     Running `target/debug/guessing_game`
Guess the number!
The secret number is: 7
Please input your guess.
4
You guessed: 4
$ cargo run
     Running `target/debug/guessing_game`
Guess the number!
The secret number is: 83
Please input your guess.
5
You guessed: 5
```

<!-- Great! Next up: let’s compare our guess to the secret guess. -->
素晴らしい！次は: 推測値と秘密の数字を比較しましょう。

# 推測値を比較する(Comparing guesses)

<!-- Now that we’ve got user input, let’s compare our guess to the random guess. Here’s our next step, though it doesn’t quite work yet: -->
ここではユーザの入力を取得して、ランダムな数字と推測値を比較しましょう。まだ上手く動きませんが、下記が次ステップです:

```rust
extern crate rand;

use std::io;
use std::cmp::Ordering;
use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1, 101);

    println!("The secret number is: {}", secret_number);

    println!("Please input your guess.");

    let mut guess = String::new();

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

    println!("You guessed: {}", guess);

    match guess.cmp(&secret_number) {
        Ordering::Less    => println!("Too small!"),
        Ordering::Greater => println!("Too big!"),
        Ordering::Equal   => println!("You win!"),
    }
}
```

<!-- A few new bits here. The first is another `use`. We bring a type called `std::cmp::Ordering` into scope. Then, five new lines at the bottom that use it: -->
ここで新しい箇所は少しだけです。まずは`use`の追加です。`std::cmp::Ordering`という型をスコープにいれます。それから、後半部にはその型を使った5行を追加します:

```rust
match guess.cmp(&secret_number) {
    Ordering::Less    => println!("Too small!"),
    Ordering::Greater => println!("Too big!"),
    Ordering::Equal   => println!("You win!"),
}
```

<!-- The `cmp()` method can be called on anything that can be compared, and it takes a reference to the thing you want to compare it to. It returns the `Ordering` type we `use`d earlier. We use a [`match`][match] statement to determine exactly what kind of `Ordering` it is. `Ordering` is an [`enum`][enum], short for ‘enumeration’, which looks like this: -->
`cmp()`メソッドは比較可能な型に対して呼ぶことができ、引数には比較対象オブジェクトの参照をとります。そして前で`use`済みの`Ordering`型を返します。ここでは`Ordering`の種類を判定するのに[`match`][match]文を使います。`Ordering` は[`enum`型][enum]です。これは'enumeration(列挙)'の短縮表記で、次のようなものです:

```rust
enum Foo {
    Bar,
    Baz,
}
```

[match]: https://doc.rust-lang.org/book/match.html
[enum]: https://doc.rust-lang.org/book/enums.html

<!-- With this definition, anything of type `Foo` can be either a `Foo::Bar` or a `Foo::Baz`. We use the `::` to indicate the namespace for a particular `enum` variant. -->
この定義では、`Foo`型は`Foo::Bar`または`Foo::Baz`のみを値として持ちます。`::`は、固有の`enum`変数の名前空間を指定するのに使います。

<!-- The [`Ordering`][ordering] enum has three possible variants: `Less`, `Equal`, and `Greater`. The `match` statement takes a value of a type, and lets you create an ‘arm’ for each possible value. Since we have three types of `Ordering`, we have three arms: -->
[`Ordering`][ordering]列挙型(enum)では3つの値: `Less`, `Equal`, `Greater`を取りえます。`match`文は型の値をとり、それぞれの候補値から'arm(アーム; 腕)'を伸ばしていきます。`Ordering`は3種類の値をもつため、3つのarmを書きます[^note_arm]:

```rust
match guess.cmp(&secret_number) {
    Ordering::Less    => println!("Too small!"),
    Ordering::Greater => println!("Too big!"),
    Ordering::Equal   => println!("You win!"),
}
```

[ordering]: https://doc.rust-lang.org/std/cmp/enum.Ordering.html
[^note_arm]: 訳注：'arm'とはmatch式中の `=>` を指している。日本語訳だと意味が取りにくいように思えたので、そのまま'arm'表記とした。

<!-- If it’s `Less`, we print `Too small!`, if it’s `Greater`, `Too big!`, and if `Equal`, `You win!`. `match` is really useful, and is used often in Rust. -->
`Less`なら`Too small!`を、`Greater`なら`Too big!`を、`Equal`なら`You win!`を表示します。`match`はとても便利で、Rustではよく用いられます。

<!-- I did mention that this won’t quite work yet, though. Let’s try it: -->
ところで、このコードはまだ上手く動かないと言いました。試してみましょうか:

```bash
$ cargo build
   Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
src/main.rs:28:21: 28:35 error: mismatched types:
 expected `&collections::string::String`,
    found `&_`
(expected struct `collections::string::String`,
    found integral variable) [E0308]
src/main.rs:28     match guess.cmp(&secret_number) {
                                   ^~~~~~~~~~~~~~
error: aborting due to previous error
Could not compile `guessing_game`.
```

<!-- Whew! This is a big error. The core of it is that we have ‘mismatched types’. Rust has a strong, static type system. However, it also has type inference. When we wrote `let guess = String::new()`, Rust was able to infer that `guess` should be a `String`, and so it doesn’t make us write out the type. And with our `secret_number`, there are a number of types which can have a value between one and a hundred: `i32`, a thirty-two-bit number, or `u32`, an unsigned thirty-two-bit number, or `i64`, a sixty-four-bit number. Or others. So far, that hasn’t mattered, and so Rust defaults to an `i32`. However, here, Rust doesn’t know how to compare the `guess` and the `secret_number`. They need to be the same type. Ultimately, we want to convert the `String` we read as input into a real number type, for comparison. We can do that with three more lines. Here’s our new program: -->
ヒェー！大きな間違いがあったようです。このでの問題は‘mismatched types(型の不整合)’です。Rustは強い静的な型システムを持ちます。一方で型推論も持っています。`let guess = String::new()`と書いたとき、Rustは`guess`が`String`型であると推論できるため、私たちは型を明示せずに済みました。そして`secret_number`の候補には、1から100の間の整数値を保持できる型: 32ビットの数値型`i32`、符号無し32ビット数値型`u32`、64ビットの数値型`i64`などがあります。これまでは気にしていませんでしたが、Rustは`i32`をデフォルトとします。しかし、ここでは、Rustは`guess`と`secret_number`を比較する方法が分かりません。同じ型同士で比べる必要があります。つまり、比較のためには入力から読み取った`String`を本当の数値型に変換したいのです。これは3行の追加で可能です。新しいプログラムは次の通り:

```rust
extern crate rand;

use std::io;
use std::cmp::Ordering;
use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1, 101);

    println!("The secret number is: {}", secret_number);

    println!("Please input your guess.");

    let mut guess = String::new();

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

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

    println!("You guessed: {}", guess);

    match guess.cmp(&secret_number) {
        Ordering::Less    => println!("Too small!"),
        Ordering::Greater => println!("Too big!"),
        Ordering::Equal   => println!("You win!"),
    }
}
```

<!-- The new three lines: -->
新しいのは次の3行:

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

<!-- Wait a minute, I thought we already had a `guess`? We do, but Rust allows us to ‘shadow’ the previous `guess` with a new one. This is often used in this exact situation, where `guess` starts as a `String`, but we want to convert it to an `u32`. Shadowing lets us re-use the `guess` name, rather than forcing us to come up with two unique names like `guess_str` and `guess`, or something else. -->
ちょっと待って、もう`guess`変数は使っていましたよね？その通り、ただRustでは前の`guess`を新しい変数で'shadow(覆い隠す)'ことができます。最初`guess`が`String`だったものを、`u32`に変換したいというような、まさにこの手の状況で良く用いられます。Shadowing(覆い隠し)によって名前`guess`が再利用でき、`guess_str`と`guess`といった2つの名前をいちいち付けなくて済みます。

<!-- We bind `guess` to an expression that looks like something we wrote earlier: -->
`guess`を以前も書いたような式に束縛します:

```rust
guess.trim().parse()
```

<!-- Followed by an `ok().expect()` invocation. Here, `guess` refers to the old `guess`, the one that was a `String` with our input in it. The `trim()` method on `String`s will eliminate any white space at the beginning and end of our string. This is important, as we had to press the ‘return’ key to satisfy `read_line()`. This means that if we type `5` and hit return, `guess` looks like this: `5\n`. The `\n` represents ‘newline’, the enter key. `trim()` gets rid of this, leaving our string with just the `5`. The [`parse()` method on strings][parse] parses a string into some kind of number. Since it can parse a variety of numbers, we need to give Rust a hint as to the exact type of number we want. Hence, `let guess: u32`. The colon (`:`) after `guess` tells Rust we’re going to annotate its type. `u32` is an unsigned, thirty-two bit integer. Rust has [a number of built-in number types][number], but we’ve chosen `u32`. It’s a good default choice for a small positive number. -->
さらに`ok().expect()`の呼び出しが続きます。ここで、`guess`は`String`型で入力を保持している古い方の`guess`を指しています。`String`の`trim()`メソッドは、文字列前／後にある空白文字を全て取り除きます。`read_line()`では必ず`return`キーを入力させるため、この処理は重要です。つまり`5`とタイプしてからreturnを入力すると、`guess`は`5\n`のようになっているのです。ここで`\n`はエンターキーによる'newline'を表します。`trim()`でこれを取り除き、文字列を`5`だけにするのです。[文字列型の`parse()`メソッド][parse]は、文字列を数値へと解析(parse)します。解析される数値型は複数候補があるため、Rustには欲しい正確な数値型を教える必要があります。よって`let guess: u32`とします。`guess`直後のコロン(`:`)はRustに型の注釈を与えています。`u32`は符号なし(unsigned)の32bit整数型です。Rustは[数種類の組込み値型][number]を提供しますが、ここでは`u32`を選びました。小さな正数に対しては、良いデフォルトの選択です。

[parse]: https://doc.rust-lang.org/std/primitive.str.html#method.parse
[number]: https://doc.rust-lang.org/book/primitive-types.html#numeric-types

<!-- Just like `read_line()`, our call to `parse()` could cause an error. What if our string contained `A👍%`? There’d be no way to convert that to a number. As such, we’ll do the same thing we did with `read_line()`: use the `ok()` and `expect()` methods to crash if there’s an error. -->
`read_line()`と同様に、`parse()`呼び出しもエラーの可能性があります。文字列が`A👍%`を含んだらどうなるでしょう？これらは数値へと変換できません。そこで、`read_line()`のときと同じ方法をとります: `ok()`と`expect()`メソッドを使って、エラー時はクラッシュさせます。

<!-- Let’s try our program out!-->
ではプログラムを動かしてみましょう！

```bash
$ cargo run
   Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
     Running `target/guessing_game`
Guess the number!
The secret number is: 58
Please input your guess.
  76
You guessed: 76
Too big!
```

<!-- Nice! You can see I even added spaces before my guess, and it still figured out that I guessed 76. Run the program a few times, and verify that guessing the number works, as well as guessing a number too small. -->
イイネ！推測値の前に空白を含めてみましたが、ちゃんと推測値76として扱われています。プログラムを何度か実行して、小さな数を入れてみるなどして数当てが動いているか確認してください。

<!-- Now we’ve got most of the game working, but we can only make one guess. Let’s change that by adding loops! -->
これでゲーム処理の大部分が出来あがりましたが、まだ数当てを1回しか行えません。繰り返し処理を加えていきましょう！

# 繰り返し処理(Looping)

<!-- The `loop` keyword gives us an infinite loop. Let’s add that in: -->
`loop`キーワードで無限ループできます。さっそく追加しましょう:

```rust
extern crate rand;

use std::io;
use std::cmp::Ordering;
use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1, 101);

    println!("The secret number is: {}", secret_number);

    loop {
        println!("Please input your guess.");

        let mut guess = String::new();

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

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

        println!("You guessed: {}", guess);

        match guess.cmp(&secret_number) {
            Ordering::Less    => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal   => println!("You win!"),
        }
    }
}
```

<!-- And try it out. But wait, didn’t we just add an infinite loop? Yup. Remember our discussion about `parse()`? If we give a non-number answer, we’ll `return` and quit. Observe: -->
では試します。ちょっと待った、無限ループさせるだけ？`parse()`のときの議論を忘れた？数値以外の答えが入力されたら、`return`して終了しましょう。やってみます:

```bash
$ cargo run
   Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
     Running `target/guessing_game`
Guess the number!
The secret number is: 59
Please input your guess.
45
You guessed: 45
Too small!
Please input your guess.
60
You guessed: 60
Too big!
Please input your guess.
59
You guessed: 59
You win!
Please input your guess.
quit
thread '<main>' panicked at 'Please type a number!'
```

<!-- Ha! `quit` actually quits. As does any other non-number input. Well, this is suboptimal to say the least. First, let’s actually quit when you win the game: -->
おや！`quit`で本当に終了しました。他の数値でない入力も同様です。んー、これはあまりイケてないですね。まずは、ゲームに勝利したときだけ終了させましょう:

```rust
extern crate rand;

use std::io;
use std::cmp::Ordering;
use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1, 101);

    println!("The secret number is: {}", secret_number);

    loop {
        println!("Please input your guess.");

        let mut guess = String::new();

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

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

        println!("You guessed: {}", guess);

        match guess.cmp(&secret_number) {
            Ordering::Less    => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal   => {
                println!("You win!");
                break;
            }
        }
    }
}
```

<!-- By adding the `break` line after the `You win!`, we’ll exit the loop when we win. Exiting the loop also means exiting the program, since it’s the last thing in `main()`. We have just one more tweak to make: when someone inputs a non-number, we don’t want to quit, we just want to ignore it. We can do that like this: -->
`You win!`の次行に`break`を追加したので、勝利したときにループを抜けるようになります。ループを抜けると`main()`終端に到達するため、プログラムの終了となります。もう1箇所調整をしましょう: 数値以外でプログラム終了するのではなく、単に入力を無視したいです。次のようにして実現可能です:

```rust
extern crate rand;

use std::io;
use std::cmp::Ordering;
use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1, 101);

    println!("The secret number is: {}", secret_number);

    loop {
        println!("Please input your guess.");

        let mut guess = String::new();

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

        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("You guessed: {}", guess);

        match guess.cmp(&secret_number) {
            Ordering::Less    => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal   => {
                println!("You win!");
                break;
            }
        }
    }
}
```

<!-- These are the lines that changed: -->
下記が変更した行です:

```rust
let guess: u32 = match guess.trim().parse() {
    Ok(num) => num,
    Err(_) => continue,
};
```

<!-- This is how you generally move from ‘crash on error’ to ‘actually handle the error’, by switching from `ok().expect()` to a `match` statement. The `Result` returned by `parse()` is an enum just like `Ordering`, but in this case, each variant has some data associated with it: `Ok` is a success, and `Err` is a failure. Each contains more information: the successful parsed integer, or an error type. In this case, we `match` on `Ok(num)`, which sets the inner value of the `Ok` to the name `num`, and then we just return it on the right-hand side. In the `Err` case, we don’t care what kind of error it is, so we just use `_` instead of a name. This ignores the error, and `continue` causes us to go to the next iteration of the `loop`. -->
この`ok().expect()`から`match`文への切り替えは、「エラー発生でクラッシュ」から「実際のエラーハンドリング処理」に移行する一般的なやり方です。`parse()`により返された`Result`は`Ordering`同様に列挙型(enum)なのですが、こちらはそれぞれが状況に関連したデータを保持しています: `Ok`は成功に、`Err`は失敗を表します。それぞれ追加の情報: 成功時には解析された数値を、失敗時はエラー型を含んでいます。ここでは、`Ok(num)`に`match`したときは、`Ok`値が保持する値を`num`に取り出して、右辺にそれを置いて値を戻しています。`Err`の場合には、エラーの種類を気しないため、名前の代わりに`_`を使っています。これによりエラーを無視して、`continue`で`loop`の次イテレーションへと進ませます。

<!-- Now we should be good! Let’s try: -->
これで上手くいくはず！レッツ・トライ:

```bash
$ cargo run
   Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
     Running `target/guessing_game`
Guess the number!
The secret number is: 61
Please input your guess.
10
You guessed: 10
Too small!
Please input your guess.
99
You guessed: 99
Too big!
Please input your guess.
foo
Please input your guess.
61
You guessed: 61
You win!
```

<!-- Awesome! With one tiny last tweak, we have finished the guessing game. Can you think of what it is? That’s right, we don’t want to print out the secret number. It was good for testing, but it kind of ruins the game. Here’s our final source: -->
最高！数当てゲームを完成させるため、最後の微調整が残っています。何だかわかった？その通り、秘密の数字を出力したらダメですよね。確認中は便利でしたが、ゲームとしては台無しです。こちらが最終的なコードです:

```rust
extern crate rand;

use std::io;
use std::cmp::Ordering;
use rand::Rng;

fn main() {
    println!("Guess the number!");

    let secret_number = rand::thread_rng().gen_range(1, 101);

    loop {
        println!("Please input your guess.");

        let mut guess = String::new();

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

        let guess: u32 = match guess.trim().parse() {
            Ok(num) => num,
            Err(_) => continue,
        };

        println!("You guessed: {}", guess);

        match guess.cmp(&secret_number) {
            Ordering::Less    => println!("Too small!"),
            Ordering::Greater => println!("Too big!"),
            Ordering::Equal   => {
                println!("You win!");
                break;
            }
        }
    }
}
```

# 完成！(Complete!)

<!-- At this point, you have successfully built the Guessing Game! Congratulations! -->
ようやく、数当てゲームの作成に成功しました！おめでとう！

<!-- This first project showed you a lot: `let`, `match`, methods, associated functions, using external crates, and more. Our next project will show off even more. -->
このプロジェクトではたくさんの要素を説明しました： `let`、`match`、メソッド、関連する関数(associated functions)、外部クレート利用など。次のプロジェクトでも色々見ていきましょう。

---