Rust：推測の例に慣れる

小さなプロジェクトに取り組んでRustを知ろう！ Rustの基本概念を実際の例で示します。 let 、 match 、メソッド、関連関数、サードパーティライブラリの接続などについて学びます。 ゲームを推測するという古典的なタスクを実現しています。

1. プログラムは1から100までの乱数を生成します。
2. その後、彼はプレイヤーに推測を入力するように頼みます。
3. その後、プログラムはプレーヤーに通知します。
   
   • 彼が数字を推測したら、ゲームは終了します
   • そうでない場合：
     
     • 書き込み、推測された数よりも少ないか、推測された数より多い。
     • ステップ2に進みます。

新しいプロジェクトを作成する

新しいプロジェクトを作成するには：

 $ cargo new guessing_game --bin $ cd guessing_game 

最初のcargo newコマンドは、プログラムの名前（ guessing_game ）を最初の引数として受け取ります。 --binは、（ライブラリではなく）プログラムを作成するためのプロジェクトを準備するようCargoに指示します。 プロジェクト構成ファイル-Cargo.tomlにあるものを見てみましょう

 [package] name = "guessing_game" version = "0.1.0" authors = ["Your Name <you@example.com>"] [dependencies] 

Cargoがシステムから受け取った作成者情報が正しくない場合は、構成ファイルを修正して保存します。 デフォルトでは、新しいプロジェクトには「Hello、world」が含まれています。
src / main.rs

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

プログラムをビルドして実行しましょう：

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

runコマンドは、コンパイル、ビルド、起動の各フェーズを順番に繰り返すことが多い場合に非常に役立ちます。

推測処理

プログラムの最初の部分では、ユーザーに推測を入力し、入力を処理して、正しいことを確認します。 まず、ユーザーが推測を入力できるようにします。以降、すべての変更はsrc/main.rsに対して行われsrc/main.rs 。

 //        stdout 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) .expect("Failed to read line"); println!("You guessed: {}", guess); } 

コードには多くの情報が含まれているため、徐々に検討してください。 入力された推測をユーザーから受け取り、stdoutで推測するには、 ioライブラリをグローバルスコープに追加する必要があります 。 ioは、標準ライブラリ（以下stdます）の一部です。

 use std::io; 

デフォルトでは、Rustはプログラムスコープにいくつかのタイプのみをもたらします（ prelude ）。 prelude必要なタイプがない場合は、 useステートメントを記述してスコープに手動で追加する必要があります。 std::ioを使用すると、ユーザー入力を読み取る機能など、入出力（ IO ）を操作するための多くの機能が提供されます。 main関数（CおよびC ++など）は、プログラムへのエントリポイントです。

 fn main() { 

fn使用すると、新しい関数を宣言できます。 ()は、関数がパラメーターを受け入れないことを示し、 {は関数の本体の前にあります。 println! -コンソールに文字列を表示するマクロ（ macro ）：

 println!("Guess the number!"); //   . println!("Please input your guess."); 

変数に値を保存します

次に、ユーザー入力が保存される場所を作成します。

 let mut guess = String::new(); 

変数を作成するために必要なletステートメントに注意してください。 それは可能です。

 let foo = bar; 

コードはfooという変数を作成し、 barの値をバインドしbar 。 Rustでは、デフォルトで変数は不変です。 それらを可変にするには、 let隣の変数名にmutを追加します。

 let foo = 5; //  (immutable) let mut bar = 5; // mutable() 

let mut guessで可変のguess変数が作成let mut guessことがわかりました。 =記号の右側は、 guessバインドする値guessこれは、新しい文字列を返す関数であるString::newを呼び出した結果です。 Stringは、成長できる文字列型（C ++のstringおよびJavaのStringBuilderと同様）で、 UTF-8エンコードされたテキストを含みます。 :: in ::newは、 newがString型の関連関数であることを示します。 関連付けられた関数は、型、この場合はString、および型の特定のインスタンスに実装されます。 C ++などの一部の言語は、このような関数の静的メソッドを呼び出します。 new関数は、新しい空のStringインスタンスを作成します。 new 、あるタイプの新しい値を作成する関数を示すために使用されるため、多くのタイプで実装されていることがわかります。 まとめると： let mut guess = String::new(); 新しい空のStringインスタンス（空の文字列）にバインドされる新しい可変変数を作成しました。 use std::ioをuse std::ioしてIOを操作use std::io関数を含めました。 次に、関連する関数stdin呼び出します。

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

プログラムの最初にuse std::ioを記述しなかった場合、 std::io::stdin形式でこの関数の呼び出しを記述できます。 stdin関数は、 標準入力の ハンドルを表す型であるstd::io::Stdinインスタンスを返します 。 これはユーザーのキーボードです。 コードの次の部分である.read_line(&mut guess) 、受信したばかりのポインター（ handle ）でread_lineを呼び出して、ユーザー入力を読み取るためのstdinを呼び出します。 また、単一の引数&mut guessも送信します。 read_lineは、ユーザーからstdin入ってくるものを受け取り、この入力をストリングに入れます。したがって、ストリング変数へのリンクを受け入れます。 メソッドがユーザー入力を追加してこの文字列の値を変更できるように、この文字列引数は可変である必要があります。 &は、引数（ &mut guess ）がコードの異なる部分が同じデータ領域に値をそのデータ領域から何度もコピーすることなくアクセスできるようにする参照であることを示します。 Rustの強みの1つは、リンクが使いやすいことです（メモリを損傷することはありません）。 現時点では、変数などのリンクがデフォルトで不変であることを知るだけで十分です。 したがって、 &mut guess &guess （不変リンクを作成）を記述し、 &mut guess &guess （不変リンクを作成）を記述します。

 .expect("Failed to read line"); 

.foo()構文を使用してメソッドを呼び出すときは、コード行が長くなりすぎないように、新しい行にジャンプすることをお勧めします。 これにより、他のプログラマーがコードを読みやすくなります。

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

少し難しく読みます。

エラー完了処理（ Result使用）

read_line読み取るだけでなく、値も返します。ここでは、タイプio::Result値です。 Rustには、異なるライブラリモジュールにResultと呼ばれるいくつかのタイプがあります。

• 一般的なResult
• 特定の例： io::Result
Result型は列挙です - 代数的データ型の実装です。 C / C ++では、アナログにunionというタグが付けられます。 Result値は、オプションOkおよびErrで表すことができます。 Okは、操作が成功したことを示し、戻り値が含まれます。 Err操作がエラーで完了したことを示し、内部のエラーに関する情報が含まれています。 ResultなどのResult固有のメソッドは、 Result型の値に適用されます。 Result型のオブジェクトの値がErr場合、 expectは渡されたエラーメッセージを表示し、プログラムをクラッシュさせます。 値がOk場合、 expectはOk内の値を返します。 read_lineているread_line関数は（成功した場合） Ok 、ユーザーが入力したバイト数を返します。 expect呼び出さない場合、プログラムはコンパイル時に警告を生成します。

 $ cargo build Compiling guessing_game v0.1.0 (file:///projects/guessing_game) warning: unused `std::result::Result` which must be used --> src/main.rs:10:5 | 10 | io::stdin().read_line(&mut guess); | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | = note: #[warn(unused_must_use)] on by default 

コンパイラは、返されたResult値を使用しなかったことを通知し、プログラムがエラーの可能性を処理しなかったことを示します。 警告を抑制するには、エラー処理コードを記述する必要がありますが、プログラムがエラーで終了する方法を確認するため、 expectを使用expectます。

printlnを使用した値の印刷！

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

{}は「プレースホルダー」であり、受信した行にこの可変プレースホルダーに対応する値があることを示します。 複数の値を印刷するには、複数のプレースホルダーを使用します。最初のプレースホルダー（ {} ）は最初の出力値に一致し、2番目から2番目に出力されます。 たとえば、次のように：

 let x = 5; let y = 10; println!("x = {} and y = {}", x, y); // : // x = 5 and y = 10 

最初の部分の検証

 $ cargo run Compiling guessing_game v0.1.0 (file:///projects/guessing_game) Finished dev [unoptimized + debuginfo] target(s) in 2.53 secs Running `target/debug/guessing_game` Guess the number! Please input your guess. 6 You guessed: 6 

プログラムは番号を要求し、私たちが入力し、プログラムはこの番号を印刷しました。 どうぞ

秘密番号の生成

ユーザーが推測しようとする数字（1〜100）を考えてください。 これは、ゲームを複数回プレイできるように、乱数でなければなりません。 Rustにはstd （標準ライブラリ）の乱数を扱うためのモジュールがないため、サードパーティのライブラリ（Rustに関してはcrate） randます。

追加機能にはラックを使用しています。

クレートは、Rustコードの単なるパッケージです。 実行可能バイナリファイル形式の通常プログラムである実行可能クレートを作成しています。 rand -Cの.oおよび.soファイルに似たライブラリクレート -他のクレートに接続できる関数が含まれています。 貨物は、サードパーティ製のラックの設置に非常に便利です。 randクレートの使用を開始するには、 Cargo.tomlに適切な変更を加えて、 randを依存関係として含める必要があります。 [依存関係]セクションを変更します

 [dependencies] rand = "0.3.14" 

Cargo.tomlファイルでは、セクションヘッダーに続くすべてが、新しいセクションが始まるまで続きます。 [dependencies]セクションは、 貨物レートを指定する場所であり、プロジェクトのコードが依存する場所、および必要なバージョンを指定します。 この場合、プロジェクトをビルドするには、バージョン0.3.14指定子を持つrand 0.3.14が必要であることを示し0.3.14 。 Cargoは、異なるバージョンのプログラムに名前を付けるための標準の1つであるセマンティックバージョニングモデルを理解しています。 0.3.14という数値（実際、これは^0.3.14短縮形です）は、バージョン0.3.14と互換性のあるオープン（ パブリック ）APIを備えたバージョンが適していることを意味します。 収集しましょう、ただし新しい依存関係があります：

 $ cargo build Updating registry `https://github.com/rust-lang/crates.io-index` Downloading rand v0.3.14 Downloading libc v0.2.14 Compiling libc v0.2.14 Compiling rand v0.3.14 Compiling guessing_game v0.1.0 (file:///projects/guessing_game) Finished dev [unoptimized + debuginfo] target(s) in 2.53 secs 

Cargoはリポジトリ（ レジストリ ） -Crates.ioから依存関係をダウンロードします。 Crates.ioは、Rust開発者がオープンソースプロジェクトを投稿する場所です。 Cargo.tomlは、インデックスをダウンロードした後、まだダウンロードされていない依存関係があるかどうかを確認します。 ある場合は、それらをダウンロードします。 さらに、 randは彼に依存しているため、彼はまだlibcダウンロードしています。 これは、推移的な依存関係が自動的に解決されることを意味します。 依存関係をダウンロードした後、rustc（Rustコンパイラー）はそれらをコンパイルし、プリコンパイルされた依存関係を使用してプログラム自体をコンパイルします。 再びcargo buildを実行cargo buildと、メッセージは表示されません。 Cargoは、必要な依存関係が既にダウンロードおよびコンパイルされていることを知っており、 Cargo.tomlの [dependencies]セクションを変更していないことを知っています。 Cargoは、コードを変更していないことも知っているため、コードを再コンパイルすることはありません。 完了する必要のある作業がないため、貨物は終了します。 src / main.rsを開いて変更すると、 cargo buildはプロジェクトのコードを再度コンパイルしますが、依存関係は変更されていないため、コンパイルしません（ インクリメンタルコンパイル ）。

Cargo.lockは、 再現可能なビルドプログラムのビルドを支援します

Cargoには、更新可能なビルドを取得できるツールがあり、他のバージョンの依存関係を指定するまで、指定した依存関係のバージョンのみを使用します。 重要なバグ修正とコードを壊すリグレッションを含むrandクレートバージョンv0.3.15たらどうなりますか？ この問題を解決するために、 Cargo.lockファイルが使用されます。このファイルは、初めてcagoビルドが起動されたときに作成され、現在はプロジェクトのルートディレクトリにあります。 プロジェクトを初めてアセンブルするとき、Cargoは、指定された要件（ Cargo.toml内 ）に一致する依存関係番号を見つけ、それらに関する情報をCargo.lockに書き込みます。 2回目以降にプロジェクトをアセンブルすると、CargoはCargo.lockがすでに存在することを確認し、そこに示されているバージョンを使用し、それらを再度表示せず、依存関係の分析に時間を費やします。 これにより、再現可能なアセンブリを取得できます。 つまり、明示的にアップグレードするまで、プロジェクトはrand 0.3.14バージョン0.3.14を使用します。

ラックを最新バージョンに更新する

クレートを更新する場合、Cargoはupdateコマンドを提供します。

• Cargo.lockを無視し、 Cargo.tomlで指定した要件を満たす最新の依存関係を見つけます。
• 成功すると、Cargoはこれらの更新されたバージョン番号をCargo.lockに書き込みます
  デフォルトでは、Cargoはバージョン> 0.3.0および< 0.4.0を使用します。 randの作成者が2つの新しいバージョン、たとえば0.3.15と0.4.0 0.3.15と、依存関係を更新するときに次のように表示されます（ cargo update ）。

 $ cargo update Updating registry `https://github.com/rust-lang/crates.io-index` Updating rand v0.3.14 -> v0.3.15 

その後、 Cargo.lockのrandのバージョンが0.3.15に変更されたことに0.3.15 。 randバージョン0.4.0または他のバージョン0.4.xを使用する場合は、 Cargo.tomlを次のように更新する必要があります。

 [dependencies] rand = "0.4.0" 

次回、 cargo buildを実行すると、Cargoは使用可能なクレートのインデックスを更新し、依存関係を再確認します。 Cargoを使用すると、サードパーティのライブラリを簡単に接続でき、 コードの再利用に役立ちます。 かんたん
既存のものをビルディングブロックとして使用して、新しいクレートを作成します。

乱数生成

rand使用に移りましょう。このため、 src / main.rsを更新します

 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) .expect("Failed to read line"); println!("You guessed: {}", guess); } 

extern crate rand;を追加しましたextern crate rand; 、サードパーティのライブラリを接続する必要があることをrustcに示します。 rand::記述することでrand::から関数を呼び出す機会があるため、 use randをuse randことにも似ていuse rand 。 use rand::Rngも追加しました。 Rngは、乱数ジェネレーターによって実装されるメソッドを定義する特性です。 メソッドを使用できるように、この特性はスコープ内になければなりません。 また、中央に2行追加しました。 rand::thread_rng関数rand::thread_rng 、オペレーティングシステムによって事前に初期化（ シード ）されている、現在のスレッドに対してローカルな乱数ジェネレーターを返します。 次に、ジェネレーターでgen_rangeを呼び出します。 このメソッドは、以前にuse rand::Rng演算子をuse rand::Rngしてスコープに導入したRngで定義されています。 gen_rangeは2つの数値を取り、それらの間にある乱数を返します。 範囲には下限が含まれ、上限は含まれません。そのため、1〜100の数字を取得するには、数字1と101指定する必要があります。クレートのすべての機能を理解するには、そのドキュメントを読む必要があります。 Cargoのもう1つの可能性は、 cargo doc --open呼び出してドキュメントを「収集」できることです。その後、ブラウザでドキュメントを開きます（アセンブリ後）。 他のrandサブ機能に興味がある場合は、左ペインでrandアイテムを選択します。 追加した2行目は、秘密の番号を出力します。 今のところ、このままにしておきましょう。プログラムの動作を確認するのに便利です。プログラムの最終バージョンにはありません。 数回実行します。

 $ cargo run Compiling guessing_game v0.1.0 (file:///projects/guessing_game) Finished dev [unoptimized + debuginfo] target(s) in 2.53 secs 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 

プログラムは毎回1から100までの異なる乱数を出力する必要があります。

推測を暗証番号と比較する

乱数を生成し、ユーザーから推測を得た後、それらを比較できます。 src / main.rsを変更します

 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) .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!"), } } 

ここで最初のなじみのない要素は、useステートメントの別の使用法です。これは、 std::cmp::Orderingをstdから scopeに変換します。 Orderingは別の列挙であり、 Resultに似ていますが、他のオプションがあります。

• Less
• Greater
• Equal
  これらは、2つの数値を比較すると得られる3つの結果です。 また、 Orderingタイプを使用してコードを追加しました。

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

cmpメソッドは2つの数値を比較し、比較可能な2つのエンティティに関連して呼び出すことができます。 この要素と比較したいものへのリンクを取得します。この場合、 guessとsecret_numberます。 cmpはOrderingオプションを返します（ useステートメントを使用して以前にスコープに持ってきました）。 また、 match一致を使用して、比較の結果に応じて、次に何をするかを決定します。 マッチmatchはブランチ（ arm ）で構成されます。 ブランチは、一致した式がブランチのパターンと一致する場合に実行する必要があるパターンとコードで構成されます。 Rustは、 matchブランチ内のパターンを使用して式を順番に一致させ、 matchが見つかった後、 matchしたパターンの右側のコードが実行されます。 プログラムとの可能な相互作用の例を見てみましょう。 ユーザーが推測として数値50を提案し、秘密（想定）数値が38であるとしましょう。コードが50と38を比較すると、 cmpメソッドは50> 38であるためOrdering::Greater返します。 。 matchは最初のブランチOrdering::Lessのテンプレートを調べますが、 Ordering::Greater値はOrdering::Lessと比較できないため（この場合は等しくないため）、このブランチのコードを無視し、次のテンプレートとの比較を続行します。 次のブランチのテンプレートであるOrdering::Greater 、 Ordering::Greater （ matchを渡しmatch ） Ordering::Greater同等です。 Too big! 。 match , . , :

 $ cargo build Compiling guessing_game v0.1.0 (file:///projects/guessing_game) error[E0308]: mismatched types --> src/main.rs:23:21 | 23 | match guess.cmp(&secret_number) { | ^^^^^^^^^^^^^^ expected struct `std::string::String`, found integral variable | = note: expected type `&std::string::String` = note: found type `&{integer}` error: aborting due to previous error Could not compile `guessing_game`. 

, . Rust — , , , . let guess = String::new() , Rust , guess String , . , secret_number — . 1 100. :

• i32 — 32- ( )
• u32 — 32- ( )
• i64 — 64- ( )
  その他。 Rust i32 , secret_number ( , , , secret_number , ). , Rust . String , , , . main :

 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) .expect("Failed to read line"); let guess: u32 = guess.trim().parse() .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!"), } } 

:

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

guess . , ? , Rust ( shadow ), . , . ( shadowing ) ( identifier ), , guess_str guess . ( bind ) guess guess.trim().parse() . guess guess , . trim String . u32 , ENTER , ( read_line ). ENTER , . , 5 ENTER , guess 5\n . \n — , ENTER . trim \n , 5 . parse String , . , Rust , let guess: u32 . ( : ) guess , Rust , ( annotate ) . Rust , , u32 , 32- . . u32 guess guess secret_number , Rust secret_number u32 . ( u32 ). parse . , , A% , . - , , parse Result , , read_line . Result : expect . parse Err - , , expect , expect . parse , parse Ok , expect Ok . :

 $ cargo run Compiling guessing_game v0.1.0 (file:///projects/guessing_game) Finished dev [unoptimized + debuginfo] target(s) in 0.43 secs Running `target/guessing_game` Guess the number! The secret number is: 58 Please input your guess. 76 You guessed: 76 Too big! 

いいね！ , , 76. , - :

• 
  , . , .

loop . :

 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) .expect("Failed to read line"); let guess: u32 = guess.trim().parse() .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!"), } } } 

, . :

 $ cargo run Compiling guessing_game v0.1.0 (file:///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!: ParseIntError { kind: InvalidDigit }', src/libcore/result.rs:785 note: Run with `RUST_BACKTRACE=1` for a backtrace. error: Process didn't exit successfully: `target/debug/guess` (exit code: 101) 

quit , , - . : , , .

, break :

 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) .expect("Failed to read line"); let guess: u32 = guess.trim().parse() .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; } } } } 

break You win! , , , . , .

, , . , :

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

expect match . , . parse , Ok match , , Ok ( num ), parse Ok . guess . parse , Err , . Err Ok(num) match , Err(_) . _ , , Err(_) Err . match — continue , . :

 $ cargo run Compiling guessing_game v0.1.0 (file:///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! 

素晴らしい。 .

 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) .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; } } } } 

おわりに

Rust:

• let — ( type inference )
  
• match —
• . static ++
• ( crates )