From da1d2fd71ed9ef6b028cefc0d2be92c98b451a6b Mon Sep 17 00:00:00 2001 From: Nnwww Date: Thu, 28 Jan 2016 02:43:21 +0900 Subject: [PATCH 01/12] start translating --- 1.6/ja/book/method-syntax.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/1.6/ja/book/method-syntax.md b/1.6/ja/book/method-syntax.md index 41c134b2..dfbdd075 100644 --- a/1.6/ja/book/method-syntax.md +++ b/1.6/ja/book/method-syntax.md @@ -1,4 +1,5 @@ -% Method Syntax +% メソッドシンタックス + Functions are great, but if you want to call a bunch of them on some data, it can be awkward. Consider this code: From 312ca9f48d918a73f73454ee6740671a39259831 Mon Sep 17 00:00:00 2001 From: Nnwww Date: Fri, 29 Jan 2016 19:15:59 +0900 Subject: [PATCH 02/12] finish provisionally translation --- 1.6/ja/book/method-syntax.md | 83 ++++++++++++++++++++++-------------- 1 file changed, 51 insertions(+), 32 deletions(-) diff --git a/1.6/ja/book/method-syntax.md b/1.6/ja/book/method-syntax.md index dfbdd075..572ba97c 100644 --- a/1.6/ja/book/method-syntax.md +++ b/1.6/ja/book/method-syntax.md @@ -1,8 +1,9 @@ % メソッドシンタックス -Functions are great, but if you want to call a bunch of them on some data, it -can be awkward. Consider this code: + +関数は素晴らしいのですが、幾つかのデータに対し複数の関数をまとめて呼び出したい時、困ったことになります。 ```rust,ignore baz(bar(foo)); @@ -11,17 +12,21 @@ baz(bar(foo)); We would read this left-to-right, and so we see ‘baz bar foo’. But this isn’t the order that the functions would get called in, that’s inside-out: ‘foo bar baz’. Wouldn’t it be nice if we could do this instead? +私たちはこれを左から右へ、'baz bar foo'と読むことになりますが、関数が呼び出される順番は異なり、内側から外へ'foo bar baz'となります。もし代わりにこう書けたらいいとは思いませんか？ ```rust,ignore foo.bar().baz(); ``` -Luckily, as you may have guessed with the leading question, you can! Rust provides -the ability to use this ‘method call syntax’ via the `impl` keyword. + +もう分かっているかもしれませんが、あなたは幸いにもこう書けるのです！Rustは `impl` キーワードによってこの「メソッド呼び出し構文」の機能を提供しています。 -# Method calls + +# メソッド呼び出し -Here’s how it works: + +どんな風に書けるかがこちらになります。 ```rust struct Circle { @@ -42,23 +47,27 @@ fn main() { } ``` -This will print `12.566371`. + +これは `12.566371` と出力します。 -We’ve made a `struct` that represents a circle. We then write an `impl` block, -and inside it, define a method, `area`. + +私たちは円を表す構造体を作りました。加えて `impl` ブロックを書き、その中に `area` というメソッドを定義しました。 -Methods take a special first parameter, of which there are three variants: + +メソッドは特別に、 `self` 、 `&self` 、 `&mut self` の3種類の内1つを第1引数に取ります。 `foo.bar()` ならメソッドの第1引数は `foo` であると考えて下さい。3種類の引数はそれぞれ、 `self` がスタック上の値である場合、 `&self` が参照である場合、 `&mut self` がミュータブルな参照である場合に対応しています。 `area` は `&self` で受け取っていますから、他の引数と同じように扱えます。 `self` の内容が `Circle` であることも分かっていますから、他の `struct` と同じように `radius` へアクセス可能です。 -We should default to using `&self`, as you should prefer borrowing over taking + +あなたは所有権を渡すよりも借用を好んで使うべきですし、ミュータブルな参照よりもイミュータブルな参照を渡すべきですから、 `&self` を常用すべきです。以下が3種類全ての例です。 ```rust struct Circle { @@ -82,8 +91,9 @@ impl Circle { } ``` -You can use as many `impl` blocks as you’d like. The previous example could -have also been written like this: + +好きな数だけ `impl` ブロックを使用することができます。前述の例は以下のように書くことも可能です。 ```rust struct Circle { @@ -111,12 +121,13 @@ impl Circle { } ``` -# Chaining method calls + +# メソッド呼び出しの連鎖 -So, now we know how to call a method, such as `foo.bar()`. But what about our + +ここまでで、`foo.bar()` というようなメソッドの呼び出し方は分かりましたね。ですが元の例の `foo.bar().baz()` についてはどうでしょう？これは「メソッドチェーン」と呼ばれています。以下の例を見て下さい。 ```rust struct Circle { x: f64, @@ -143,7 +154,8 @@ fn main() { } ``` -Check the return type: + +返り値の型を確認して下さい。 ```rust # struct Circle; @@ -152,13 +164,16 @@ fn grow(&self, increment: f64) -> Circle { # Circle } } ``` -We just say we’re returning a `Circle`. With this method, we can grow a new -`Circle` to any arbitrary size. + +単に `Circle` を返しているだけです。このメソッドにより、私たちは新しい `Circle` を任意のサイズに成長させられるようになりました。 -# Associated functions + +# 関連付いた関数 -You can also define associated functions that do not take a `self` parameter. -Here’s a pattern that’s very common in Rust code: + +また、あなたは `self` を引数に取らずとも `Circle` に関連付けられた関数を定義することができます。 ```rust struct Circle { @@ -182,18 +197,21 @@ fn main() { } ``` -This ‘associated function’ builds a new `Circle` for us. Note that associated + +この「関連付いた関数」は新たに `Circle` を生成します。この関数は `ref.method()` ではなく、 `Struct::function()` という構文で呼び出されることに注意して下さい。幾つかの言語では、関連付いた関数を 「静的メソッド」 と呼んでいます。 -# Builder Pattern + +# Builderパターン -Let’s say that we want our users to be able to create `Circle`s, but we will + +ユーザーが `Circle` を作成できるようにしたいものの、ユーザーに許可できるのはプロパティを設定することだけだと仮定しましょう。もし指定が無ければ `x` と `y` を `0.0` に、 `radius` を `1.0` に設定するものとします。Rustはメソッドのオーバーロードや名前付き引数、可変個引数といった機能がない代わりにBuilderパターンを採用しており、それは以下のようになります。 ```rust struct Circle { @@ -252,9 +270,10 @@ fn main() { } ``` -What we’ve done here is make another `struct`, `CircleBuilder`. We’ve defined our + +私たちはここでもう1つの `struct` である `CircleBuilder` を作成し、その中にBuilderメソッドを定義しました。また、 `Circle` に `area()` メソッドを定義し、 そして`CircleBuilder` にもう1つ `finalize()` というメソッドを作りました。このメソッドはBuilderから最終的な `Circle` を生成します。今、私たちは最初の仮定をユーザーに強制させるために型システムを利用しました。用意した方法から選ばせて `Circle` を生成するという制約を実現するために、この `CircleBuilder` のメソッドを使うことができます。 From d3de3ee4fdf1135c258dc537376d9669073247b2 Mon Sep 17 00:00:00 2001 From: Nnwww Date: Fri, 29 Jan 2016 19:22:38 +0900 Subject: [PATCH 03/12] =?UTF-8?q?modify=20translation=20of=20'associated?= =?UTF-8?q?=20function'=20to=20=E3=80=8C=E9=96=A2=E9=80=A3=E9=96=A2?= =?UTF-8?q?=E6=95=B0=E3=80=8D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- 1.6/ja/book/method-syntax.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/1.6/ja/book/method-syntax.md b/1.6/ja/book/method-syntax.md index 572ba97c..3a90e064 100644 --- a/1.6/ja/book/method-syntax.md +++ b/1.6/ja/book/method-syntax.md @@ -169,11 +169,11 @@ fn grow(&self, increment: f64) -> Circle { 単に `Circle` を返しているだけです。このメソッドにより、私たちは新しい `Circle` を任意のサイズに成長させられるようになりました。 -# 関連付いた関数 +# 関連関数 -また、あなたは `self` を引数に取らずとも `Circle` に関連付けられた関数を定義することができます。 +また、あなたは `self` を引数に取らずとも `Circle` に関連関数を定義することができます。 ```rust struct Circle { @@ -201,7 +201,7 @@ fn main() { functions are called with the `Struct::function()` syntax, rather than the `ref.method()` syntax. Some other languages call associated functions ‘static methods’. --> -この「関連付いた関数」は新たに `Circle` を生成します。この関数は `ref.method()` ではなく、 `Struct::function()` という構文で呼び出されることに注意して下さい。幾つかの言語では、関連付いた関数を 「静的メソッド」 と呼んでいます。 +この「関連関数」は新たに `Circle` を生成します。この関数は `ref.method()` ではなく、 `Struct::function()` という構文で呼び出されることに注意して下さい。幾つかの言語では、関連関数を 「静的メソッド」 と呼んでいます。 # Builderパターン From 0261f322ee71c93f84d1990e0eb7fb58a9d5507e Mon Sep 17 00:00:00 2001 From: Nnwww Date: Fri, 29 Jan 2016 19:39:52 +0900 Subject: [PATCH 04/12] correct to forget to comment out --- 1.6/ja/book/method-syntax.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/1.6/ja/book/method-syntax.md b/1.6/ja/book/method-syntax.md index 3a90e064..e4d0b2c2 100644 --- a/1.6/ja/book/method-syntax.md +++ b/1.6/ja/book/method-syntax.md @@ -9,9 +9,9 @@ can be awkward. Consider this code: --> baz(bar(foo)); ``` -We would read this left-to-right, and so we see ‘baz bar foo’. But this isn’t the + 私たちはこれを左から右へ、'baz bar foo'と読むことになりますが、関数が呼び出される順番は異なり、内側から外へ'foo bar baz'となります。もし代わりにこう書けたらいいとは思いませんか？ ```rust,ignore From bc3f2e6fc4713b5dba53d58fa3cd43232f0094ed Mon Sep 17 00:00:00 2001 From: Nnwww Date: Fri, 29 Jan 2016 19:51:48 +0900 Subject: [PATCH 05/12] fix trivial translations. --- 1.6/ja/book/method-syntax.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1.6/ja/book/method-syntax.md b/1.6/ja/book/method-syntax.md index e4d0b2c2..652c7da6 100644 --- a/1.6/ja/book/method-syntax.md +++ b/1.6/ja/book/method-syntax.md @@ -3,7 +3,7 @@ -関数は素晴らしいのですが、幾つかのデータに対し複数の関数をまとめて呼び出したい時、困ったことになります。 +関数は素晴らしいのですが、幾つかのデータに対し複数の関数をまとめて呼び出したい時、困ったことになります。以下のコードについて考えてみます。 ```rust,ignore baz(bar(foo)); From ab717bbaec681d24affd6cb0488ac6004000e162 Mon Sep 17 00:00:00 2001 From: Nnwww Date: Sat, 30 Jan 2016 04:26:01 +0900 Subject: [PATCH 06/12] retranslate honestly --- 1.6/ja/book/method-syntax.md | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/1.6/ja/book/method-syntax.md b/1.6/ja/book/method-syntax.md index 652c7da6..ee1b661c 100644 --- a/1.6/ja/book/method-syntax.md +++ b/1.6/ja/book/method-syntax.md @@ -12,7 +12,7 @@ baz(bar(foo)); -私たちはこれを左から右へ、'baz bar foo'と読むことになりますが、関数が呼び出される順番は異なり、内側から外へ'foo bar baz'となります。もし代わりにこう書けたらいいとは思いませんか？ +私たちはこれを左から右へ、「baz bar foo」と読むことになりますが、関数が呼び出される順番は異なり、内側から外へ「foo bar baz」となります。もし代わりにこうできたらいいとは思いませんか? ```rust,ignore foo.bar().baz(); @@ -20,13 +20,13 @@ foo.bar().baz(); -もう分かっているかもしれませんが、あなたは幸いにもこう書けるのです！Rustは `impl` キーワードによってこの「メソッド呼び出し構文」の機能を提供しています。 +最初の質問でもう分かっているかもしれませんが、幸いにもこれは可能です!Rustは `impl` キーワードによってこの「メソッド呼び出し構文」の機能を提供しています。 # メソッド呼び出し -どんな風に書けるかがこちらになります。 +どんな風に動作するかが以下になります。 ```rust struct Circle { @@ -52,7 +52,7 @@ fn main() { -私たちは円を表す構造体を作りました。加えて `impl` ブロックを書き、その中に `area` というメソッドを定義しました。 +私たちは円を表す `struct` を作りました。その際 `impl` ブロックを書き、その中に `area` というメソッドを定義しています。 -メソッドは特別に、 `self` 、 `&self` 、 `&mut self` の3種類の内1つを第1引数に取ります。 `foo.bar()` ならメソッドの第1引数は `foo` であると考えて下さい。3種類の引数はそれぞれ、 `self` がスタック上の値である場合、 `&self` が参照である場合、 `&mut self` がミュータブルな参照である場合に対応しています。 `area` は `&self` で受け取っていますから、他の引数と同じように扱えます。 `self` の内容が `Circle` であることも分かっていますから、他の `struct` と同じように `radius` へアクセス可能です。 +メソッドは特別な第1引数をとり、それは `self` 、 `&self` 、 `&mut self` の3種類です。 `foo.bar()` の第1引数は `foo` であると考えて下さい。3種類の引数は `foo` が成り得る3つの状態に対応しており、それぞれ `self` がスタック上の値である場合、 `&self` が参照である場合、 `&mut self` がミュータブルな参照である場合です。 `area` が `&self` で受け取っているため、他の引数と同じように扱えます。 その引数が `Circle` であるのは分かっていますから、他の `struct` でするように `radius` へアクセスできます。 -あなたは所有権を渡すよりも借用を好んで使うべきですし、ミュータブルな参照よりもイミュータブルな参照を渡すべきですから、 `&self` を常用すべきです。以下が3種類全ての例です。 +所有権を渡すよりも借用を好んで使うべきなのは勿論のこと、ミュータブルな参照よりもイミュータブルな参照を渡すべきですから、 `&self` を常用すべきです。以下が3種類全ての例です。 ```rust struct Circle { @@ -93,7 +93,7 @@ impl Circle { -好きな数だけ `impl` ブロックを使用することができます。前述の例は以下のように書くことも可能です。 +好きな数だけ `impl` ブロックを使用することができます。前述の例は以下のように書くこともできるでしょう。 ```rust struct Circle { @@ -127,7 +127,7 @@ impl Circle { -ここまでで、`foo.bar()` というようなメソッドの呼び出し方は分かりましたね。ですが元の例の `foo.bar().baz()` についてはどうでしょう？これは「メソッドチェーン」と呼ばれています。以下の例を見て下さい。 +ここまでで、`foo.bar()` というようなメソッドの呼び出し方が分かりましたね。ですが元の例の `foo.bar().baz()` はどうなっているのでしょう?これは「メソッドチェーン」と呼ばれています。以下の例を見て下さい。 ```rust struct Circle { x: f64, @@ -155,7 +155,7 @@ fn main() { ``` -返り値の型を確認して下さい。 +以下の返す型を確認して下さい。 ```rust # struct Circle; @@ -166,14 +166,14 @@ fn grow(&self, increment: f64) -> Circle { -単に `Circle` を返しているだけです。このメソッドにより、私たちは新しい `Circle` を任意のサイズに成長させられるようになりました。 +単に `Circle` を返しているだけです。このメソッドにより、私たちは新しい `Circle` を任意のサイズに成長させることができます。 # 関連関数 -また、あなたは `self` を引数に取らずとも `Circle` に関連関数を定義することができます。 +また、あなたは `self` を引数に取らない関連関数を定義することができます。以下のパターンはRustのコードにおいて非常にありふれた物です。 ```rust struct Circle { @@ -201,7 +201,7 @@ fn main() { functions are called with the `Struct::function()` syntax, rather than the `ref.method()` syntax. Some other languages call associated functions ‘static methods’. --> -この「関連関数」は新たに `Circle` を生成します。この関数は `ref.method()` ではなく、 `Struct::function()` という構文で呼び出されることに注意して下さい。幾つかの言語では、関連関数を 「静的メソッド」 と呼んでいます。 +この「関連関数」(associated function)は新たに `Circle` を構築します。この関数は `ref.method()` ではなく、 `Struct::function()` という構文で呼び出されることに注意して下さい。幾つかの言語では、関連関数を「静的メソッド」(static methods)と呼んでいます。 # Builderパターン @@ -211,7 +211,7 @@ allow them to only set the properties they care about. Otherwise, the `x` and `y` attributes will be `0.0`, and the `radius` will be `1.0`. Rust doesn’t have method overloading, named arguments, or variable arguments. We employ the builder pattern instead. It looks like this: --> -ユーザーが `Circle` を作成できるようにしたいものの、ユーザーに許可できるのはプロパティを設定することだけだと仮定しましょう。もし指定が無ければ `x` と `y` を `0.0` に、 `radius` を `1.0` に設定するものとします。Rustはメソッドのオーバーロードや名前付き引数、可変個引数といった機能がない代わりにBuilderパターンを採用しており、それは以下のようになります。 +ユーザが `Circle` を作成できるようにしたいものの、彼らに許可できるのはプロパティを設定することだけだと仮定しましょう。もし指定が無ければ `x` と `y` が `0.0` 、 `radius` が `1.0` であるものとします。Rustはメソッドのオーバーロードや名前付き引数、可変個引数といった機能がない代わりにBuilderパターンを採用しており、それは以下のようになります。 ```rust struct Circle { @@ -276,4 +276,4 @@ also made one more method on `CircleBuilder`: `finalize()`. This method creates our final `Circle` from the builder. Now, we’ve used the type system to enforce our concerns: we can use the methods on `CircleBuilder` to constrain making `Circle`s in any way we choose. --> -私たちはここでもう1つの `struct` である `CircleBuilder` を作成し、その中にBuilderメソッドを定義しました。また、 `Circle` に `area()` メソッドを定義し、 そして`CircleBuilder` にもう1つ `finalize()` というメソッドを作りました。このメソッドはBuilderから最終的な `Circle` を生成します。今、私たちは最初の仮定をユーザーに強制させるために型システムを利用しました。用意した方法から選ばせて `Circle` を生成するという制約を実現するために、この `CircleBuilder` のメソッドを使うことができます。 +ここではもう1つの `struct` である `CircleBuilder` を作成しています。その中にBuilderメソッドを定義しました。また `Circle` に `area()` メソッドを定義しました。 そして `CircleBuilder` にもう1つ `finalize()` というメソッドを作りました。このメソッドはBuilderから最終的な `Circle` を作成します。今回、最初の仮定をユーザに強制するため型システムを利用しました。用意した方法から選ばせて `Circle` を作るという制約を実現するために、この `CircleBuilder` のメソッドを使うことができます。 From cb5d451d8f255b92a5480053fa5bf408e93eeeae Mon Sep 17 00:00:00 2001 From: Nnwww Date: Sat, 30 Jan 2016 04:46:55 +0900 Subject: [PATCH 07/12] modify line 65 --- 1.6/ja/book/method-syntax.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1.6/ja/book/method-syntax.md b/1.6/ja/book/method-syntax.md index ee1b661c..c81e19f7 100644 --- a/1.6/ja/book/method-syntax.md +++ b/1.6/ja/book/method-syntax.md @@ -62,7 +62,7 @@ kinds of things `foo` could be: `self` if it’s just a value on the stack, Because we took the `&self` parameter to `area`, we can use it just like any other parameter. Because we know it’s a `Circle`, we can access the `radius` just like we would with any other `struct`. --> -メソッドは特別な第1引数をとり、それは `self` 、 `&self` 、 `&mut self` の3種類です。 `foo.bar()` の第1引数は `foo` であると考えて下さい。3種類の引数は `foo` が成り得る3つの状態に対応しており、それぞれ `self` がスタック上の値である場合、 `&self` が参照である場合、 `&mut self` がミュータブルな参照である場合です。 `area` が `&self` で受け取っているため、他の引数と同じように扱えます。 その引数が `Circle` であるのは分かっていますから、他の `struct` でするように `radius` へアクセスできます。 +メソッドに渡す特別な第1引数として、 `self` 、 `&self` 、 `&mut self` という3つの変形があります。 `foo.bar()` の第1引数は `foo` であると考えて下さい。3つの変形は `foo` が成り得る3種類の状態に対応しており、それぞれ `self` がスタック上の値である場合、 `&self` が参照である場合、 `&mut self` がミュータブルな参照である場合となっています。 `area` で `&self` を受け取っているため、他の引数と同じように扱えます。引数が `Circle` であるのは分かっていますから、他の `struct` でするように `radius` へアクセスできます。 -また、あなたは `self` を引数に取らない関連関数を定義することができます。以下のパターンはRustのコードにおいて非常にありふれた物です。 +あなたは `self` を引数に取らない関連関数を定義することもできます。以下のパターンはRustのコードにおいて非常にありふれた物です。 ```rust struct Circle { From 4c37d1b2faf0d7ed225a0af8fc953cd81ba75019 Mon Sep 17 00:00:00 2001 From: Nnwww Date: Sat, 30 Jan 2016 05:37:26 +0900 Subject: [PATCH 09/12] modify a last sentence --- 1.6/ja/book/method-syntax.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1.6/ja/book/method-syntax.md b/1.6/ja/book/method-syntax.md index e167567f..d639d02e 100644 --- a/1.6/ja/book/method-syntax.md +++ b/1.6/ja/book/method-syntax.md @@ -276,4 +276,4 @@ also made one more method on `CircleBuilder`: `finalize()`. This method creates our final `Circle` from the builder. Now, we’ve used the type system to enforce our concerns: we can use the methods on `CircleBuilder` to constrain making `Circle`s in any way we choose. --> -ここではもう1つの `struct` である `CircleBuilder` を作成しています。その中にBuilderメソッドを定義しました。また `Circle` に `area()` メソッドを定義しました。 そして `CircleBuilder` にもう1つ `finalize()` というメソッドを作りました。このメソッドはBuilderから最終的な `Circle` を作成します。今回、最初の仮定をユーザに強制するため型システムを利用しました。用意した方法から選ばせて `Circle` を作るという制約を実現するために、この `CircleBuilder` のメソッドを使うことができます。 +ここではもう1つの `struct` である `CircleBuilder` を作成しています。その中にBuilderメソッドを定義しました。また `Circle` に `area()` メソッドを定義しました。 そして `CircleBuilder` にもう1つ `finalize()` というメソッドを作りました。このメソッドはBuilderから最終的な `Circle` を作成します。私たちが用意した方法によって `Circle` を作らせるという制約を `CircleBuilder` のメソッドで実現し、この制約を強制付ける手段として今回は型システムを利用しました。 From 8ede8cc74b3fa9446d8a1794c9b0c30b07c49c98 Mon Sep 17 00:00:00 2001 From: Nnwww Date: Sat, 30 Jan 2016 05:37:26 +0900 Subject: [PATCH 10/12] modify a last sentence --- 1.6/ja/book/method-syntax.md | 1 + 1 file changed, 1 insertion(+) diff --git a/1.6/ja/book/method-syntax.md b/1.6/ja/book/method-syntax.md index e167567f..7a0c1d9d 100644 --- a/1.6/ja/book/method-syntax.md +++ b/1.6/ja/book/method-syntax.md @@ -128,6 +128,7 @@ impl Circle { original example, `foo.bar().baz()`? This is called ‘method chaining’. Let’s look at an example: --> ここまでで、`foo.bar()` というようなメソッドの呼び出し方が分かりましたね。ですが元の例の `foo.bar().baz()` はどうなっているのでしょう?これは「メソッドチェーン」と呼ばれています。以下の例を見て下さい。 + ```rust struct Circle { x: f64, From 3284f677fcb1227539517d1a1c662bcde8cefdb5 Mon Sep 17 00:00:00 2001 From: Nnwww Date: Sat, 30 Jan 2016 06:08:39 +0900 Subject: [PATCH 11/12] tweek a last sentence --- 1.6/ja/book/method-syntax.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/1.6/ja/book/method-syntax.md b/1.6/ja/book/method-syntax.md index 4fdb17a8..f137a40d 100644 --- a/1.6/ja/book/method-syntax.md +++ b/1.6/ja/book/method-syntax.md @@ -277,4 +277,4 @@ also made one more method on `CircleBuilder`: `finalize()`. This method creates our final `Circle` from the builder. Now, we’ve used the type system to enforce our concerns: we can use the methods on `CircleBuilder` to constrain making `Circle`s in any way we choose. --> -ここではもう1つの `struct` である `CircleBuilder` を作成しています。その中にBuilderメソッドを定義しました。また `Circle` に `area()` メソッドを定義しました。 そして `CircleBuilder` にもう1つ `finalize()` というメソッドを作りました。このメソッドはBuilderから最終的な `Circle` を作成します。私たちが用意した方法によって `Circle` を作らせるという制約を `CircleBuilder` のメソッドで実現し、この制約を強制付ける手段として今回は型システムを利用しました。 +ここではもう1つの `struct` である `CircleBuilder` を作成しています。その中にBuilderメソッドを定義しました。また `Circle` に `area()` メソッドを定義しました。 そして `CircleBuilder` にもう1つ `finalize()` というメソッドを作りました。このメソッドはBuilderから最終的な `Circle` を作成します。今回、最初の仮定をユーザに強制するため型システムを利用しました。用意した方法から `Circle` を作るという制約を実現するために、この `CircleBuilder` のメソッドを使うことができます。 From cce6e754f61929eb622ba7c6ead03203ddbce8aa Mon Sep 17 00:00:00 2001 From: Nnwww Date: Mon, 1 Feb 2016 11:24:46 +0900 Subject: [PATCH 12/12] reflect a review --- 1.6/ja/book/method-syntax.md | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/1.6/ja/book/method-syntax.md b/1.6/ja/book/method-syntax.md index f137a40d..1888558a 100644 --- a/1.6/ja/book/method-syntax.md +++ b/1.6/ja/book/method-syntax.md @@ -62,7 +62,7 @@ kinds of things `foo` could be: `self` if it’s just a value on the stack, Because we took the `&self` parameter to `area`, we can use it just like any other parameter. Because we know it’s a `Circle`, we can access the `radius` just like we would with any other `struct`. --> -メソッドに渡す特別な第1引数として、 `self` 、 `&self` 、 `&mut self` という3つの変形があります。 `foo.bar()` の第1引数は `foo` であると考えて下さい。3つの変形は `foo` が成り得る3種類の状態に対応しており、それぞれ `self` がスタック上の値である場合、 `&self` が参照である場合、 `&mut self` がミュータブルな参照である場合となっています。 `area` で `&self` を受け取っているため、他の引数と同じように扱えます。引数が `Circle` であるのは分かっていますから、他の `struct` でするように `radius` へアクセスできます。 +メソッドに渡す特別な第1引数として、 `self` 、 `&self` 、 `&mut self` という3つの変形があります。第一引数は `foo.bar()` に於ける `foo` だと考えて下さい。3つの変形は `foo` が成り得る3種類の状態に対応しており、それぞれ `self` がスタック上の値である場合、 `&self` が参照である場合、 `&mut self` がミュータブルな参照である場合となっています。 `area` では `&self` を受け取っているため、他の引数と同じように扱えます。引数が `Circle` であるのは分かっていますから、他の `struct` でするように `radius` へアクセスできます。 -# メソッド呼び出しの連鎖 +# メソッドチェーン -単に `Circle` を返しているだけです。このメソッドにより、私たちは新しい `Circle` を任意のサイズに成長させることができます。 +単に `Circle` を返しているだけです。このメソッドにより、私たちは新しい `Circle` を任意の大きさに拡大することができます。 # 関連関数 @@ -212,7 +212,7 @@ allow them to only set the properties they care about. Otherwise, the `x` and `y` attributes will be `0.0`, and the `radius` will be `1.0`. Rust doesn’t have method overloading, named arguments, or variable arguments. We employ the builder pattern instead. It looks like this: --> -ユーザが `Circle` を作成できるようにしたいものの、彼らに許可できるのはプロパティを設定することだけだと仮定しましょう。もし指定が無ければ `x` と `y` が `0.0` 、 `radius` が `1.0` であるものとします。Rustはメソッドのオーバーロードや名前付き引数、可変個引数といった機能がない代わりにBuilderパターンを採用しており、それは以下のようになります。 +ユーザが `Circle` を作成できるようにしつつも、書き換えたいプロパティだけを設定すれば良いようにしたいとしましょう。もし指定が無ければ `x` と `y` が `0.0` 、 `radius` が `1.0` であるものとします。Rustはメソッドのオーバーロードや名前付き引数、可変個引数といった機能がない代わりにBuilderパターンを採用しており、それは以下のようになります。 ```rust struct Circle { @@ -277,4 +277,4 @@ also made one more method on `CircleBuilder`: `finalize()`. This method creates our final `Circle` from the builder. Now, we’ve used the type system to enforce our concerns: we can use the methods on `CircleBuilder` to constrain making `Circle`s in any way we choose. --> -ここではもう1つの `struct` である `CircleBuilder` を作成しています。その中にBuilderメソッドを定義しました。また `Circle` に `area()` メソッドを定義しました。 そして `CircleBuilder` にもう1つ `finalize()` というメソッドを作りました。このメソッドはBuilderから最終的な `Circle` を作成します。今回、最初の仮定をユーザに強制するため型システムを利用しました。用意した方法から `Circle` を作るという制約を実現するために、この `CircleBuilder` のメソッドを使うことができます。 +ここではもう1つの `struct` である `CircleBuilder` を作成しています。その中にBuilderメソッドを定義しました。また `Circle` に `area()` メソッドを定義しました。 そして `CircleBuilder` にもう1つ `finalize()` というメソッドを作りました。このメソッドはBuilderから最終的な `Circle` を作成します。さて、先程の要求を実施するために型システムを使いました。 `CircleBuilder` のメソッドを好きなように組み合わせ、作る `Circle` への制約を与えることができます。