diff --git a/1.9/ja/book/patterns.md b/1.9/ja/book/patterns.md index da7c5750..7970ba83 100644 --- a/1.9/ja/book/patterns.md +++ b/1.9/ja/book/patterns.md @@ -1,14 +1,11 @@ % パターン - + + + パターンはRustにおいて極めて一般的です。 - - パターンは [変数束縛][bindings], [マッチ文][match] などで使われています。 - - さあ、めくるめくパターンの旅を始めましょう！ [bindings]: variable-bindings.html @@ -16,7 +13,8 @@ bindings][bindings], [match statements][match], and other places, too.--> -簡単な復習：リテラルに対しては直接マッチさせられます。また、 `_` は「任意の」ケースとして振る舞います。 +簡単な復習：リテラルに対しては直接マッチ出来ます。 +また、 `_` は「任意の」ケースとして振る舞います。 ```rust let x = 1; @@ -32,11 +30,14 @@ match x { これは `one` を表示します。 - -パターンには一つ落とし穴があります。新しい束縛を導入すると、他の束縛を導入するものと同じように、シャドーイングします。例えば： + + +パターンには一つ落とし穴があります。 +新しい束縛を導入すると、他の束縛を導入するものと同じように、シャドーイングします。 +例えば： ```rust -let x = 'x'; +let x = 1; let c = 'c'; match c { @@ -51,13 +52,18 @@ println!("x: {}", x) ```text x: c c: c -x: x +x: 1 ``` - -別の言い方をすると、 `x =>` はパターンへのマッチだけでなく、マッチの腕内で有効な `x` という名前の束縛を導入します。既に `x` は束縛されていたので、この新しい `x` はそれを覆い隠します。 + + + + + +別の言い方をすると、 `x =>` はパターンへにマッチし `x` という名前の束縛を導入します。 +この束縛はマッチの腕で有効で、 `c` の値を引き受けます。 +マッチのスコープ外にある `x` は内部での `x` の値に関係していないことに注意して下さい。 +既に `x` は束縛されていたので、この新しい `x` はそれを覆い隠します。 # 複式パターン @@ -82,9 +88,9 @@ match x { # デストラクチャリング - -例えば [`struct`][struct] のような複合データ型を作成したいとき、パターン内でデータを分解することができます。 + + +例えば [`struct`][struct] のような複合データ型があるとき、パターン内でデータを分解することができます。 ```rust struct Point { @@ -136,8 +142,8 @@ match origin { これは `x is 0` を出力します。 - -どのメンバに対してもこの種のマッチを行うことができます。たとえ最初ではなくても： + +最初のものだけでなく、どのメンバに対してもこの種のマッチを行うことができます。 ```rust struct Point { @@ -155,8 +161,8 @@ match origin { これは `y is 0` を出力します。 - + + この「デストラクチャリング(destructuring)」と呼ばれる振る舞いは、 [タプル][tuples] や [列挙型][enums] のような、複合データ型で使用できます。 [tuples]: primitive-types.html#tuples @@ -166,9 +172,8 @@ match origin { # 束縛の無視 -パターン内の型や値を無視するために `_` を使うことができます。 - +パターン内の型や値を無視するために `_` を使うことができます。 例として、 `Result` に対して `match` を適用してみましょう： ```rust @@ -179,14 +184,16 @@ match some_value { } ``` - -最初の部分では `Ok` ヴァリアント内の値を `value` に結びつけています。しかし `Err` 部分では、特定のエラーを避けて、標準的なエラーメッセージを表示するために `_` を使っています。 + + + +最初の部分では `Ok` ヴァリアント内の値を `value` に束縛しています。 +しかし `Err` 部分では、`_` を使って特定のエラーを無視し、一般的なエラーメッセージを表示しています。 - -`_` は束縛を伴うどんなパターンにおいても有効です。これは大きな構造の一部分を無視する際に有用です。 + + +`_` は束縛を伴うどんなパターンにおいても有効です。 +これは大きな構造の一部分を無視する際に有用です。 ```rust fn coordinate() -> (i32, i32, i32) { @@ -198,12 +205,51 @@ fn coordinate() -> (i32, i32, i32) { let (x, _, z) = coordinate(); ``` - + + ここでは、タプルの最初と最後の要素を `x` と `z` に結びつけています。 - -同様に `..` でパターン内の複数の値を無視することができます。 + + +`_` はそもそも値を束縛しない、つまり値がムーブしないということは特筆に値します。 + +```rust +let tuple: (u32, String) = (5, String::from("five")); + +# // Here, tuple is moved, because the String moved: +// これだとタプルはムーブします。何故ならStringがムーブしているからです: +let (x, _s) = tuple; + +# // The next line would give "error: use of partially moved value: `tuple`" +// この行は「error: use of partially moved value: `tuple`」を出します。 +// println!("Tuple is: {:?}", tuple); + +# // However, +// しかしながら、 + +let tuple = (5, String::from("five")); + +# // Here, tuple is _not_ moved, as the String was never moved, and u32 is Copy: +// これだとタプルはムーブ _されません_ 。何故ならStringはムーブされず、u32はCopyだからです: +let (x, _) = tuple; + +# // That means this works: +// つまりこれは動きます: +println!("Tuple is: {:?}", tuple); +``` + + + +また、束縛されていない値は文の終わりでドロップされるということでもあります。 + +```rust +# // Here, the String created will be dropped immediately, as it’s not bound: +// 生成されたStringは束縛されていないので即座にドロップされる +let _ = String::from(" hello ").trim(); +``` + + +複数の値を捨てるのには `..` パターンが使えます。 ```rust enum OptionalTuple { @@ -236,15 +282,17 @@ match x { } ``` - + これは `Got a reference to 5` を出力します。 [ref]: references-and-borrowing.html - -ここで `match` 内の `r` は `&i32` 型を持っています。言い換えると `ref` キーワードがリファレンスを _作ります_ 。 + + + +ここで `match` 内の `r` は `&i32` 型を持っています。 +言い換えると `ref` キーワードがパターン内で使うリファレンスを _作ります_ 。 +ミュータブルなリファレンスが必要なら、 `ref mut` が同じように動作します。 ```rust let mut x = 5; @@ -292,7 +340,7 @@ match x { # 束縛 -`@` で値を名前と結びつけることができます。 +`@` で値を名前に束縛することができます。 ```rust let x = 1; @@ -303,8 +351,8 @@ match x { } ``` - + + これは `got a range element 1` を出力します。 データ構造の一部に対する複雑なマッチが欲しいときに有用です： @@ -315,19 +363,19 @@ struct Person { } let name = "Steve".to_string(); -let mut x: Option = Some(Person { name: Some(name) }); +let x: Option = Some(Person { name: Some(name) }); match x { Some(Person { name: ref a @ Some(_), .. }) => println!("{:?}", a), _ => {} } ``` - + これは `Some("Steve")` を出力します。内側の `name` を `a` に結びつけます。 - -もし `|` で `@` を使うときは、パターンのそれぞれの部分が名前と結びついているか確認する必要があります： + + +もし `|` で `@` を使うときは、必ずそれぞれのパターンが名前と結びついている必要があります。 ```rust let x = 5; @@ -341,8 +389,8 @@ match x { # ガード - -`if` を使うことでマッチガードを導入することができます： + +`if` を使うことで「マッチガード」を導入することができます： ```rust enum OptionalInt { @@ -359,10 +407,10 @@ match x { } ``` - + これは `Got an int!` を出力します。 - + 複式パターンで `if` を使うと、 `if` は両方に適用されます： ```rust @@ -375,8 +423,8 @@ match x { } ``` - + + これは `no` を出力します。なぜなら `if` は `4 | 5` 全体に適用されるのであって、 `5` 単独に対してではないからです。つまり `if` 節は以下のように振舞います： ```text @@ -393,8 +441,8 @@ just the `5`. In other words, the precedence of `if` behaves like this: --> # 混ぜてマッチ - + + ふう、マッチには様々な方法があるのですね。やりたいこと次第で、それらを混ぜてマッチさせることもできます： ```rust,ignore diff --git a/TranslationTable.md b/TranslationTable.md index 7c46fef2..2ec9b0a7 100644 --- a/TranslationTable.md +++ b/TranslationTable.md @@ -20,6 +20,7 @@ | antipattern | アンチパターン | application | アプリケーション | arity | アリティ +| (マッチの)arm | 腕 | array | 配列 | assignment | 代入 | associated - | 関連- @@ -44,6 +45,7 @@ | command line | コマンドライン | compile-time error | コンパイル時エラー | compiler | コンパイラ +| compound data type | 複合データ型 | composable | 合成可能 | computer science | コンピュータサイエンス | concurrency | 並行性 @@ -118,6 +120,7 @@ | lock | ロック | mangling | マングリング | match | マッチ +| match guards | マッチガード | memory | メモリ | method | メソッド | monomorphization | 単相化 diff --git a/diff-1.6.0..1.9.0/src/doc/book/patterns.md b/diff-1.6.0..1.9.0/src/doc/book/patterns.md deleted file mode 100644 index 0d4c508e..00000000 --- a/diff-1.6.0..1.9.0/src/doc/book/patterns.md +++ /dev/null @@ -1,116 +0,0 @@ ---- a/src/doc/book/patterns.md -+++ b/src/doc/book/patterns.md -@@ -1,7 +1,7 @@ - % Patterns - - Patterns are quite common in Rust. We use them in [variable --bindings][bindings], [match statements][match], and other places, too. Let’s go -+bindings][bindings], [match expressions][match], and other places, too. Let’s go - on a whirlwind tour of all of the things patterns can do! - - [bindings]: variable-bindings.html -@@ -27,7 +27,7 @@ There’s one pitfall with patterns: like anything that introduces a new binding - they introduce shadowing. For example: - - ```rust --let x = 'x'; -+let x = 1; - let c = 'c'; - - match c { -@@ -41,12 +41,14 @@ This prints: - - ```text - x: c c: c --x: x -+x: 1 - ``` - - In other words, `x =>` matches the pattern and introduces a new binding named --`x` that’s in scope for the match arm. Because we already have a binding named --`x`, this new `x` shadows it. -+`x`. This new binding is in scope for the match arm and takes on the value of -+`c`. Notice that the value of `x` outside the scope of the match has no bearing -+on the value of `x` within it. Because we already have a binding named `x`, this -+new `x` shadows it. - - # Multiple patterns - -@@ -116,7 +118,7 @@ match origin { - - This prints `x is 0`. - --You can do this kind of match on any member, not just the first: -+You can do this kind of match on any member, not only the first: - - ```rust - struct Point { -@@ -153,7 +155,7 @@ match some_value { - ``` - - In the first arm, we bind the value inside the `Ok` variant to `value`. But --in the `Err` arm, we use `_` to disregard the specific error, and just print -+in the `Err` arm, we use `_` to disregard the specific error, and print - a general error message. - - `_` is valid in any pattern that creates a binding. This can be useful to -@@ -171,7 +173,39 @@ let (x, _, z) = coordinate(); - Here, we bind the first and last element of the tuple to `x` and `z`, but - ignore the middle element. - --Similarly, you can use `..` in a pattern to disregard multiple values. -+It’s worth noting that using `_` never binds the value in the first place, -+which means a value may not move: -+ -+```rust -+let tuple: (u32, String) = (5, String::from("five")); -+ -+// Here, tuple is moved, because the String moved: -+let (x, _s) = tuple; -+ -+// The next line would give "error: use of partially moved value: `tuple`" -+// println!("Tuple is: {:?}", tuple); -+ -+// However, -+ -+let tuple = (5, String::from("five")); -+ -+// Here, tuple is _not_ moved, as the String was never moved, and u32 is Copy: -+let (x, _) = tuple; -+ -+// That means this works: -+println!("Tuple is: {:?}", tuple); -+``` -+ -+This also means that any temporary variables will be dropped at the end of the -+statement: -+ -+```rust -+// Here, the String created will be dropped immediately, as it’s not bound: -+ -+let _ = String::from(" hello ").trim(); -+``` -+ -+You can also use `..` in a pattern to disregard multiple values: - - ```rust - enum OptionalTuple { -@@ -269,7 +303,7 @@ struct Person { - } - - let name = "Steve".to_string(); --let mut x: Option = Some(Person { name: Some(name) }); -+let x: Option = Some(Person { name: Some(name) }); - match x { - Some(Person { name: ref a @ Some(_), .. }) => println!("{:?}", a), - _ => {} -@@ -324,7 +358,7 @@ match x { - ``` - - This prints `no`, because the `if` applies to the whole of `4 | 5`, and not to --just the `5`. In other words, the precedence of `if` behaves like this: -+only the `5`. In other words, the precedence of `if` behaves like this: - - ```text - (4 | 5) if y => ... -diff --git a/src/doc/book/primitive-types.md b/src/doc/book/primitive-types.md