From 81e828ab91114527792193bb81ff127c09579341 Mon Sep 17 00:00:00 2001
From: "Tatsuya Kawano (Circle CI)" <tatsuya@hibaridb.org>
Date: Sat, 25 Jun 2016 13:06:22 +0800
Subject: [PATCH 1/3] Update Method Syntax to 1.9.

---
 1.9/ja/book/method-syntax.md                  |  8 +++---
 .../src/doc/book/method-syntax.md             | 27 -------------------
 2 files changed, 4 insertions(+), 31 deletions(-)
 delete mode 100644 diff-1.6.0..1.9.0/src/doc/book/method-syntax.md

diff --git a/1.9/ja/book/method-syntax.md b/1.9/ja/book/method-syntax.md
index 173a5190..2102c249 100644
--- a/1.9/ja/book/method-syntax.md
+++ b/1.9/ja/book/method-syntax.md
@@ -61,11 +61,11 @@ fn main() {
 <!-- Methods take a special first parameter, of which there are three variants: -->
 <!-- `self`, `&self`, and `&mut self`. You can think of this first parameter as -->
 <!-- being the `foo` in `foo.bar()`. The three variants correspond to the three -->
-<!-- kinds of things `foo` could be: `self` if it’s just a value on the stack, -->
+<!-- kinds of things `foo` could be: `self` if it’s a value on the stack, -->
 <!-- `&self` if it’s a reference, and `&mut self` if it’s a mutable reference. -->
-<!-- Because we took the `&self` parameter to `area`, we can use it just like any -->
+<!-- Because we took the `&self` parameter to `area`, we can use it like any -->
 <!-- other parameter. Because we know it’s a `Circle`, we can access the `radius` -->
-<!-- just like we would with any other `struct`. -->
+<!-- like we would with any other `struct`. -->
 メソッドに渡す特別な第1引数として、 `self` 、 `&self` 、 `&mut self` という3つの変形があります。
 第一引数は `foo.bar()` に於ける `foo` だと考えて下さい。
 3つの変形は `foo` が成り得る3種類の状態に対応しており、それぞれ `self` がスタック上の値である場合、 `&self` が参照である場合、 `&mut self` がミュータブルな参照である場合となっています。
@@ -177,7 +177,7 @@ fn grow(&self, increment: f64) -> Circle {
 # Circle } }
 ```
 
-<!-- We just say we’re returning a `Circle`. With this method, we can grow a new -->
+<!-- We say we’re returning a `Circle`. With this method, we can grow a new -->
 <!-- `Circle` to any arbitrary size. -->
 単に `Circle` を返しているだけです。
 このメソッドにより、私たちは新しい `Circle` を任意の大きさに拡大することができます。
diff --git a/diff-1.6.0..1.9.0/src/doc/book/method-syntax.md b/diff-1.6.0..1.9.0/src/doc/book/method-syntax.md
deleted file mode 100644
index de1b94e6..00000000
--- a/diff-1.6.0..1.9.0/src/doc/book/method-syntax.md
+++ /dev/null
@@ -1,27 +0,0 @@
---- a/src/doc/book/method-syntax.md
-+++ b/src/doc/book/method-syntax.md
-@@ -49,11 +49,11 @@ and inside it, define a method, `area`.
- Methods take a special first parameter, of which there are three variants:
- `self`, `&self`, and `&mut self`. You can think of this first parameter as
- being the `foo` in `foo.bar()`. The three variants correspond to the three
--kinds of things `foo` could be: `self` if it’s just a value on the stack,
-+kinds of things `foo` could be: `self` if it’s a value on the stack,
- `&self` if it’s a reference, and `&mut self` if it’s a mutable reference.
--Because we took the `&self` parameter to `area`, we can use it just like any
-+Because we took the `&self` parameter to `area`, we can use it like any
- other parameter. Because we know it’s a `Circle`, we can access the `radius`
--just like we would with any other `struct`.
-+like we would with any other `struct`.
- 
- We should default to using `&self`, as you should prefer borrowing over taking
- ownership, as well as taking immutable references over mutable ones. Here’s an
-@@ -151,7 +151,7 @@ fn grow(&self, increment: f64) -> Circle {
- # Circle } }
- ```
- 
--We just say we’re returning a `Circle`. With this method, we can grow a new
-+We say we’re returning a `Circle`. With this method, we can grow a new
- `Circle` to any arbitrary size.
- 
- # Associated functions
-diff --git a/src/doc/book/nightly-rust.md b/src/doc/book/nightly-rust.md

From 147a49f090099ef4ae85edb127dcc11076aa52f2 Mon Sep 17 00:00:00 2001
From: "Tatsuya Kawano (Circle CI)" <tatsuya@hibaridb.org>
Date: Thu, 2 Mar 2017 22:24:33 +0800
Subject: [PATCH 2/3] Brush up the translation of Method Syntax (1.9).

---
 1.9/ja/book/method-syntax.md | 45 +++++++++++++++++++-----------------
 1 file changed, 24 insertions(+), 21 deletions(-)

diff --git a/1.9/ja/book/method-syntax.md b/1.9/ja/book/method-syntax.md
index 2102c249..062b5067 100644
--- a/1.9/ja/book/method-syntax.md
+++ b/1.9/ja/book/method-syntax.md
@@ -3,8 +3,8 @@
 
 <!-- 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));
@@ -14,7 +14,7 @@ baz(bar(foo));
 <!-- 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();
@@ -22,7 +22,7 @@ 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 -->
@@ -67,15 +67,16 @@ fn main() {
 <!-- other parameter. Because we know it’s a `Circle`, we can access the `radius` -->
 <!-- like we would with any other `struct`. -->
 メソッドに渡す特別な第1引数として、 `self` 、 `&self` 、 `&mut self` という3つの変形があります。
-第一引数は `foo.bar()` に於ける `foo` だと考えて下さい。
-3つの変形は `foo` が成り得る3種類の状態に対応しており、それぞれ `self` がスタック上の値である場合、 `&self` が参照である場合、 `&mut self` がミュータブルな参照である場合となっています。
+第一引数は `foo.bar()` における `foo` だと考えて下さい。
+3つの変形は `foo` がなりうる3種類の状態に対応しており、それぞれ `self` がスタック上の値である場合、 `&self` が参照である場合、 `&mut self` がミュータブルな参照である場合となっています。
 `area` では `&self` を受け取っているため、他の引数と同じように扱えます。
 引数が `Circle` であるのは分かっていますから、他の `struct` でするように `radius` へアクセスできます。
 
 <!-- We should default to using `&self`, as you should prefer borrowing over taking -->
 <!-- ownership, as well as taking immutable references over mutable ones. Here’s an -->
 <!-- example of all three variants: -->
-所有権を渡すよりも借用を好んで使うべきなのは勿論のこと、ミュータブルな参照よりもイミュータブルな参照を渡すべきですから、 `&self` を常用すべきです。以下が3種類全ての例です。
+所有権を渡すよりも借用を好んで使うべきなのはもちろんのこと、ミュータブルな参照よりもイミュータブルな参照を渡すべきですから、 `&self` を常用すべきです。
+以下が3種類全ての例です。
 
 ```rust
 struct Circle {
@@ -101,8 +102,8 @@ impl Circle {
 
 <!--You can use as many `impl` blocks as you’d like. The previous example could -->
 <!-- have also been written like this: -->
-好きな数だけ `impl` ブロックを使用することができます。
-前述の例は以下のように書くこともできるでしょう。
+好きな数だけ `impl` ブロックを使用できます。
+前述の例は以下のようにも書けるでしょう。
 
 ```rust
 struct Circle {
@@ -168,7 +169,7 @@ fn main() {
 ```
 
 <!-- Check the return type: -->
-以下の返す型を確認して下さい。
+返す型を確認しましょう。
 
 ```rust
 # struct Circle;
@@ -179,15 +180,15 @@ fn grow(&self, increment: f64) -> Circle {
 
 <!-- We say we’re returning a `Circle`. With this method, we can grow a new -->
 <!-- `Circle` to any arbitrary size. -->
-単に `Circle` を返しているだけです。
-このメソッドにより、私たちは新しい `Circle` を任意の大きさに拡大することができます。
+`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` を引数に取らない関連関数を定義することもできます。
+関連関数という `self` を引数に取らない関数も定義できます。
 以下のパターンはRustのコードにおいて非常にありふれた物です。
 
 ```rust
@@ -218,7 +219,7 @@ fn main() {
 <!-- methods’. -->
 この「関連関数」(associated function)は新たに `Circle` を構築します。
 この関数は `ref.method()` ではなく、 `Struct::function()` という構文で呼び出されることに注意して下さい。
-幾つかの言語では、関連関数を「静的メソッド」(static methods)と呼んでいます。
+いくつかの言語では、関連関数を「静的メソッド」(static methods)と呼んでいます。
 
 <!-- # Builder Pattern -->
 # Builderパターン
@@ -228,9 +229,11 @@ fn main() {
 <!-- 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 {
@@ -295,10 +298,10 @@ fn main() {
 <!-- 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メソッドを定義しました。
+ここでは `CircleBuilder` というもう1つの `struct` を作成しています。
+それに対して私たちのBuilderメソッドを定義しました。
 また `Circle` に `area()` メソッドを定義しました。
 そして `CircleBuilder` にもう1つ `finalize()` というメソッドを作りました。
 このメソッドはBuilderから最終的な `Circle` を作成します。
-さて、先程の要求を実施するために型システムを使いました。
-`CircleBuilder` のメソッドを好きなように組み合わせ、作る `Circle` への制約を与えることができます。
+さて、先ほどの要求を実施するために型システムを使いました。
+`CircleBuilder` のメソッドを好きなように組み合わせ、作成する `Circle` への制約を与えられます。

From f3acfbd319d18bbf6dca993bfb3cc998530fc58e Mon Sep 17 00:00:00 2001
From: Tatsuya Kawano <tatsuya@hibaridb.org>
Date: Tue, 7 Mar 2017 21:04:52 +0800
Subject: [PATCH 3/3] Brush up the Japanese translation of Method Syntax (1.9).

---
 1.9/ja/book/method-syntax.md | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/1.9/ja/book/method-syntax.md b/1.9/ja/book/method-syntax.md
index 062b5067..cdb04781 100644
--- a/1.9/ja/book/method-syntax.md
+++ b/1.9/ja/book/method-syntax.md
@@ -4,7 +4,7 @@
 <!-- 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));
@@ -22,7 +22,7 @@ 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 -->
@@ -66,16 +66,16 @@ fn main() {
 <!-- Because we took the `&self` parameter to `area`, we can use it like any -->
 <!-- other parameter. Because we know it’s a `Circle`, we can access the `radius` -->
 <!-- like we would with any other `struct`. -->
-メソッドに渡す特別な第1引数として、 `self` 、 `&self` 、 `&mut self` という3つの変形があります。
+メソッドに渡す特別な第1引数には、 `self` 、 `&self` 、 `&mut self` という3つのバリエーションがあります。
 第一引数は `foo.bar()` における `foo` だと考えて下さい。
-3つの変形は `foo` がなりうる3種類の状態に対応しており、それぞれ `self` がスタック上の値である場合、 `&self` が参照である場合、 `&mut self` がミュータブルな参照である場合となっています。
+これら3つのバリエーションは `foo` がなりうる3種類の状態に対応しており、それぞれ `self` がスタック上の値である場合、 `&self` が参照である場合、 `&mut self` がミュータブルな参照である場合となっています。
 `area` では `&self` を受け取っているため、他の引数と同じように扱えます。
-引数が `Circle` であるのは分かっていますから、他の `struct` でするように `radius` へアクセスできます。
+それが `Circle` であるのは分かっていますから、他の `struct` でするように `radius` へアクセスできます。
 
 <!-- We should default to using `&self`, as you should prefer borrowing over taking -->
 <!-- ownership, as well as taking immutable references over mutable ones. Here’s an -->
 <!-- example of all three variants: -->
-所有権を渡すよりも借用を好んで使うべきなのはもちろんのこと、ミュータブルな参照よりもイミュータブルな参照を渡すべきですから、 `&self` を常用すべきです。
+所有権を渡すよりも借用を好んで使うべきなのはもちろんのこと、ミュータブルな参照よりもイミュータブルな参照を渡すべきですから、基本は `&self` を使うべきです。
 以下が3種類全ての例です。
 
 ```rust
@@ -169,7 +169,7 @@ fn main() {
 ```
 
 <!-- Check the return type: -->
-返す型を確認しましょう。
+戻り値の型を確認しましょう。
 
 ```rust
 # struct Circle;
@@ -181,7 +181,7 @@ fn grow(&self, increment: f64) -> Circle {
 <!-- We say we’re returning a `Circle`. With this method, we can grow a new -->
 <!-- `Circle` to any arbitrary size. -->
 `Circle` を返すと言っています。
-このメソッドにより、任意の大きさへ拡大した新しい `Circle` が得られます。
+このメソッドにより、任意の大きさへと拡大した、新たな `Circle` が得られます。
 
 <!-- # Associated functions -->
 # 関連関数
@@ -189,7 +189,7 @@ fn grow(&self, increment: f64) -> Circle {
 <!-- 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` を引数に取らない関数も定義できます。
-以下のパターンはRustのコードにおいて非常にありふれた物です。
+以下のパターンはRustのコードにおいて、とてもよく使われています。
 
 ```rust
 struct Circle {
@@ -229,8 +229,8 @@ fn main() {
 <!-- 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` になります。
+ユーザが `Circle` を作成する際、関心のあるプロパティだけを指定できるようにしたいとしましょう。
+指定がなければ `x` と `y` は `0.0` 、 `radius` は `1.0` にします。
 Rustにはメソッドのオーバーロードや名前付き引数、可変個引数といった機能がありません。
 代わりにBuilderパターンを採用しましょう。
 以下のようになります。
@@ -298,10 +298,10 @@ fn main() {
 <!-- 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. -->
-ここでは `CircleBuilder` というもう1つの `struct` を作成しています。
-それに対して私たちのBuilderメソッドを定義しました。
+ここでは `CircleBuilder` という、もう1つの `struct` を作成しています。
+それに対してBuilderメソッドを定義しました。
 また `Circle` に `area()` メソッドを定義しました。
 そして `CircleBuilder` にもう1つ `finalize()` というメソッドを作りました。
 このメソッドはBuilderから最終的な `Circle` を作成します。
-さて、先ほどの要求を実施するために型システムを使いました。
-`CircleBuilder` のメソッドを好きなように組み合わせ、作成する `Circle` への制約を与えられます。
+さて、私たちは先ほどの要求を守らせるために型システムを使いました。
+`CircleBuilder` に用意するメソッドによって、作成する `Circle` に、望み通りの制約を与えられます。