Merge branch 'master' into markdown-syntax-space

Author: KeenS

1.6/ja/book/SUMMARY.md

@@ -3,7 +3,7 @@
 * [はじめる](getting-started.md)
 * [Rustを学ぶ](learn-rust.md)
     * [数当てゲーム](guessing-game.md)
-    * [晩餐する哲学者](dining-philosophers.md)
+    * [食事する哲学者](dining-philosophers.md)
     * [他言語と共存する](rust-inside-other-languages.md)
 * [シンタックスとセマンティクス](syntax-and-semantics.md)
     * [変数束縛](variable-bindings.md)
@@ -15,7 +15,7 @@
     * [所有権](ownership.md)
     * [参照と借用](references-and-borrowing.md)
     * [ライフタイム](lifetimes.md)
-    * [可変性](mutability.md)
+    * [ミュータビリティ](mutability.md)
     * [構造体](structs.md)
     * [列挙型](enums.md)
     * [マッチ](match.md)

1.6/ja/book/advanced-linking.md

@@ -95,7 +95,7 @@ $ ldd example
 <!-- Static linking is supported via an alternative `libc`, [`musl`](http://www.musl-libc.org). You can compile -->
 <!-- your own version of Rust with `musl` enabled and install it into a custom -->
 <!-- directory with the instructions below: -->
-スタティックリンクは代わりの `libc` である[`musl`](http://www.musl-libc.org/)によってサポートされています。
+スタティックリンクは代わりの `libc` である [`musl`](http://www.musl-libc.org/) によってサポートされています。
 以下の手順に従い、 `musl` を有効にした独自バージョンのRustをコンパイルして独自のディレクトリにインストールすることができます。
 
 ```text
@@ -142,7 +142,7 @@ $ du -h musldist/bin/rustc
 <!-- You now have a build of a `musl`-enabled Rust! Because we've installed it to a -->
 <!-- custom prefix we need to make sure our system can find the binaries and appropriate -->
 <!-- libraries when we try and run it: -->
-これで`musl`が有効になったRustのビルドが手に入りました!
+これで `musl` が有効になったRustのビルドが手に入りました!
 独自のプレフィックスを付けてインストールしたので、試しに実行するときにはシステムがバイナリと適切なライブラリを見付けられることを確かめなければなりません。
 
 ```text

1.6/ja/book/associated-types.md

@@ -1,11 +1,17 @@
-% Associated Types
-
-Associated types are a powerful part of Rust’s type system. They’re related to
-the idea of a ‘type family’, in other words, grouping multiple types together. That
-description is a bit abstract, so let’s dive right into an example. If you want
-to write a `Graph` trait, you have two types to be generic over: the node type
-and the edge type. So you might write a trait, `Graph<N, E>`, that looks like
-this:
+% 関連型
+<!-- % Associated Types -->
+
+<!-- Associated types are a powerful part of Rust’s type system. They’re related to -->
+<!-- the idea of a ‘type family’, in other words, grouping multiple types together. That -->
+<!-- description is a bit abstract, so let’s dive right into an example. If you want -->
+<!-- to write a `Graph` trait, you have two types to be generic over: the node type -->
+<!-- and the edge type. So you might write a trait, `Graph<N, E>`, that looks like -->
+<!-- this: -->
+関連型は、Rust型システムの強力な部分です。関連型は、「型族」という概念と関連が有り、
+言い換えると、複数の型をグループ化するものです。
+この説明はすこし抽象的なので、実際の例を見ていきましょう。
+例えば、 `Graph` トレイトを定義したいとしましょう、このときジェネリックになる２つの型: 頂点の型、辺の型 が存在します。
+そのため、以下のように `Graph<N, E>` と書きたくなるでしょう:
 
 ```rust
 trait Graph<N, E> {
@@ -15,19 +21,24 @@ trait Graph<N, E> {
 }
 ```
 
-While this sort of works, it ends up being awkward. For example, any function
-that wants to take a `Graph` as a parameter now _also_ needs to be generic over
-the `N`ode and `E`dge types too:
+<!-- While this sort of works, it ends up being awkward. For example, any function -->
+<!-- that wants to take a `Graph` as a parameter now _also_ needs to be generic over -->
+<!-- the `N`ode and `E`dge types too: -->
+たしかに上のようなコードは動作しますが、この `Graph` の定義は少し扱いづらいです。
+たとえば、任意の `Graph` を引数に取る関数は、 _同時に_ 頂点 `N` と辺 `E` についてもジェネリックとなることになります:
 
 ```rust,ignore
 fn distance<N, E, G: Graph<N, E>>(graph: &G, start: &N, end: &N) -> u32 { ... }
 ```
 
-Our distance calculation works regardless of our `Edge` type, so the `E` stuff in
-this signature is just a distraction.
+<!-- Our distance calculation works regardless of our `Edge` type, so the `E` stuff in -->
+<!-- this signature is just a distraction. -->
+この距離を計算する関数distanceは、辺の型に関わらず動作します、そのためシグネチャに含まれる `E` に関連する部分は邪魔でしかありません。
 
-What we really want to say is that a certain `E`dge and `N`ode type come together
-to form each kind of `Graph`. We can do that with associated types:
+<!-- What we really want to say is that a certain `E`dge and `N`ode type come together -->
+<!-- to form each kind of `Graph`. We can do that with associated types: -->
+本当に表現したいことは、それぞれのグラフ( `Graph` )は辺( `E` )や頂点( `N` )で構成されているということです。
+それは、以下のように関連型を用いて表現することができます:
 
 ```rust
 trait Graph {
@@ -40,19 +51,25 @@ trait Graph {
 }
 ```
 
-Now, our clients can be abstract over a given `Graph`:
+<!-- Now, our clients can be abstract over a given `Graph`: -->
+このようにすると、`Graph` を使った関数は以下のように書くことができます:
 
 ```rust,ignore
 fn distance<G: Graph>(graph: &G, start: &G::N, end: &G::N) -> u32 { ... }
 ```
 
-No need to deal with the `E`dge type here!
+<!-- No need to deal with the `E`dge type here! -->
+もう `E` について扱う必要はありません!
+
 
-Let’s go over all this in more detail.
+<!-- Let’s go over all this in more detail. -->
+もっと詳しく見ていきましょう。
 
-## Defining associated types
+<!-- ## Defining associated types -->
+## 関連型を定義する
 
-Let’s build that `Graph` trait. Here’s the definition:
+<!-- Let’s build that `Graph` trait. Here’s the definition: -->
+早速、`Graph` トレイトを定義しましょう。以下がその定義です:
 
 ```rust
 trait Graph {
@@ -64,12 +81,15 @@ trait Graph {
 }
 ```
 
-Simple enough. Associated types use the `type` keyword, and go inside the body
-of the trait, with the functions.
+<!-- Simple enough. Associated types use the `type` keyword, and go inside the body -->
+<!-- of the trait, with the functions. -->
+非常にシンプルですね。関連型には `type` キーワードを使い、そしてトレイトの本体や関数で利用します。
 
-These `type` declarations can have all the same thing as functions do. For example,
-if we wanted our `N` type to implement `Display`, so we can print the nodes out,
-we could do this:
+<!-- These `type` declarations can have all the same thing as functions do. For example, -->
+<!-- if we wanted our `N` type to implement `Display`, so we can print the nodes out, -->
+<!-- we could do this: -->
+これらの `type` 宣言は、関数で利用できるものと同じものが全て利用できます。
+たとえば、 `N` 型が `Display` を実装していて欲しい時、つまり私達が頂点を出力したい時、以下のようにして指定することができます:
 
 ```rust
 use std::fmt;
@@ -83,10 +103,13 @@ trait Graph {
 }
 ```
 
-## Implementing associated types
+<!-- ## Implementing associated types -->
+## 関連型を実装する
 
-Just like any trait, traits that use associated types use the `impl` keyword to
-provide implementations. Here’s a simple implementation of Graph:
+<!-- Just like any trait, traits that use associated types use the `impl` keyword to -->
+<!-- provide implementations. Here’s a simple implementation of Graph: -->
+通常のトレイトと同様に、関連型を使っているトレイトは実装するために `impl` を利用します。
+以下は、シンプルなGraphの実装例です:
 
 ```rust
 # trait Graph {
@@ -115,23 +138,34 @@ impl Graph for MyGraph {
 }
 ```
 
-This silly implementation always returns `true` and an empty `Vec<Edge>`, but it
-gives you an idea of how to implement this kind of thing. We first need three
-`struct`s, one for the graph, one for the node, and one for the edge. If it made
-more sense to use a different type, that would work as well, we’re just going to
-use `struct`s for all three here.
+<!-- This silly implementation always returns `true` and an empty `Vec<Edge>`, but it -->
+<!-- gives you an idea of how to implement this kind of thing. We first need three -->
+<!-- `struct`s, one for the graph, one for the node, and one for the edge. If it made -->
+<!-- more sense to use a different type, that would work as well, we’re just going to -->
+<!-- use `struct`s for all three here. -->
+この奇妙な実装は、つねに `true` と空の `Vec<Edge>` を返しますますが、どのように定義したら良いかのアイデアをくれます。
+まず、はじめに3つの `struct` が必要です、ひとつはグラフのため、そしてひとつは頂点のため、そしてもうひとつは辺のため。
+もし異なる型を利用することが適切ならば、そのようにすると良いでしょう、今回はこの3つの `struct` を用います。
+
 
-Next is the `impl` line, which is just like implementing any other trait.
+<!-- Next is the `impl` line, which is just like implementing any other trait. -->
+次は `impl` の行です、これは他のトレイトを実装するときと同様です。
 
-From here, we use `=` to define our associated types. The name the trait uses
-goes on the left of the `=`, and the concrete type we’re `impl`ementing this
-for goes on the right. Finally, we use the concrete types in our function
-declarations.
+<!-- From here, we use `=` to define our associated types. The name the trait uses -->
+<!-- goes on the left of the `=`, and the concrete type we’re `impl`ementing this -->
+<!-- for goes on the right. Finally, we use the concrete types in our function -->
+<!-- declarations. -->
+そして、`=` を関連型を定義するために利用します。
+トレイトが利用する名前は `=` の左側にある名前で、実装に用いる具体的な型は右側にあるものになります。
+最後に、具体的な型を関数の宣言に利用します。
 
-## Trait objects with associated types
+<!-- ## Trait objects with associated types -->
+## 関連型を伴うトレイト
 
-There’s one more bit of syntax we should talk about: trait objects. If you
-try to create a trait object from an associated type, like this:
+<!-- There’s one more bit of syntax we should talk about: trait objects. If you -->
+<!-- try to create a trait object from an associated type, like this: -->
+すこし触れておきたい構文: トレイトオブジェクト が有ります。
+もし、トレイトオブジェクトを以下のように関連型から作成しようとした場合:
 
 ```rust,ignore
 # trait Graph {
@@ -157,7 +191,8 @@ let graph = MyGraph;
 let obj = Box::new(graph) as Box<Graph>;
 ```
 
-You’ll get two errors:
+<!-- You’ll get two errors: -->
+以下の様なエラーが発生します:
 
 ```text
 error: the value of the associated type `E` (from the trait `main::Graph`) must
@@ -170,8 +205,10 @@ let obj = Box::new(graph) as Box<Graph>;
           ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 ```
 
-We can’t create a trait object like this, because we don’t know the associated
-types. Instead, we can write this:
+<!-- We can’t create a trait object like this, because we don’t know the associated -->
+<!-- types. Instead, we can write this: -->
+上のようにしてトレイトオブジェクトを作ることはできません、なぜなら関連型について知らないからです
+代わりに以下のように書くことができます:
 
 ```rust
 # trait Graph {
@@ -197,6 +234,8 @@ let graph = MyGraph;
 let obj = Box::new(graph) as Box<Graph<N=Node, E=Edge>>;
 ```
 
-The `N=Node` syntax allows us to provide a concrete type, `Node`, for the `N`
-type parameter. Same with `E=Edge`. If we didn’t provide this constraint, we
-couldn’t be sure which `impl` to match this trait object to.
+<!-- The `N=Node` syntax allows us to provide a concrete type, `Node`, for the `N` -->
+<!-- type parameter. Same with `E=Edge`. If we didn’t provide this constraint, we -->
+<!-- couldn’t be sure which `impl` to match this trait object to. -->
+`N=Node` 構文を用いて型パラメータ `N` にたいして具体的な型 `Node` を指定することができます、`E=Edge` についても同様です。
+もしこの制約を指定しなかった場合、このトレイトオブジェクトに対してどの `impl` がマッチするのか定まりません。

1.6/ja/book/attributes.md

@@ -57,7 +57,7 @@ fn check() {
 この関数は `#[test]` によってマークされており、これは [テスト][tests] を走らせた時に実行されるという特別な意味になります。
 通常通りにコンパイルをした場合は、コンパイル結果に含まれません。この関数は今やテスト関数なのです。
 
-[テスト]: testing.html
+[tests]: testing.html
 
 <!-- Attributes may also have additional data: -->
 アトリビュートは以下のように、追加のデータを持つことができます:
@@ -84,4 +84,4 @@ Rustのアトリビュートは様々なことに利用されます。
 すべてのアトリビュートのリストは [リファレンス][reference] に載っています。
 現在は、Rustコンパイラーによって定義されている以外の独自のアトリビュートを作成することは許可されていません。
 
-[リファレンス]: ../reference.html#attributes
+[reference]: ../reference.html#attributes

1.6/ja/book/box-syntax-and-patterns.md

@@ -1,9 +1,11 @@
-%  Box Syntax and Patterns
+% Box構文とパターン
+<!-- %  Box Syntax and Patterns -->
 
-Currently the only stable way to create a `Box` is via the `Box::new` method.
-Also it is not possible in stable Rust to destructure a `Box` in a match
-pattern. The unstable `box` keyword can be used to both create and destructure
-a `Box`. An example usage would be:
+<!-- Currently the only stable way to create a `Box` is via the `Box::new` method. -->
+<!-- Also it is not possible in stable Rust to destructure a `Box` in a match -->
+<!-- pattern. The unstable `box` keyword can be used to both create and destructure -->
+<!-- a `Box`. An example usage would be: -->
+今のところ、安定版において `Box` を作成する唯一の方法は `Box::new` メソッドです。安定版のRustではパターンマッチで `Box` を分解することもできません。不安定版の `box` キーワードは `Box` の作成と分解の両方に使えます。使い方は以下の通りです。
 
 ```rust
 #![feature(box_syntax, box_patterns)]
@@ -25,14 +27,17 @@ fn main() {
 }
 ```
 
-Note that these features are currently hidden behind the `box_syntax` (box
-creation) and `box_patterns` (destructuring and pattern matching) gates
-because the syntax may still change in the future.
+<!-- Note that these features are currently hidden behind the `box_syntax` (box -->
+<!-- creation) and `box_patterns` (destructuring and pattern matching) gates -->
+<!-- because the syntax may still change in the future. -->
+注記: 将来的にこの構文は変わる可能性があるため、現時点でこれらのフィーチャは `box_syntax` (boxの作成)、 `box_patterns` (分解とパターンマッチ)を明示しなければ使えません。
 
-# Returning Pointers
+<!-- # Returning Pointers -->
+# ポインタ返し
 
-In many languages with pointers, you'd return a pointer from a function
-so as to avoid copying a large data structure. For example:
+<!-- In many languages with pointers, you'd return a pointer from a function -->
+<!-- so as to avoid copying a large data structure. For example: -->
+ポインタを持つ多くのプログラミング言語では、巨大なデータ構造のコピーを避けるため、関数からポインタを返してきました。例えば以下のように書くことができます。
 
 ```rust
 struct BigStruct {
@@ -57,10 +62,12 @@ fn main() {
 }
 ```
 
-The idea is that by passing around a box, you're only copying a pointer, rather
-than the hundred `i32`s that make up the `BigStruct`.
+<!-- The idea is that by passing around a box, you're only copying a pointer, rather -->
+<!-- than the hundred `i32`s that make up the `BigStruct`. -->
+考え方としては、boxで渡すことで `BigStruct` を構成する100個の `i32` の代わりにポインタのみのコピーで済む、というものです。
 
-This is an antipattern in Rust. Instead, write this:
+<!-- This is an antipattern in Rust. Instead, write this: -->
+これはRustではアンチパターンです。代わりに以下のように書きます。
 
 ```rust
 #![feature(box_syntax)]
@@ -87,14 +94,17 @@ fn main() {
 }
 ```
 
-This gives you flexibility without sacrificing performance.
+<!-- This gives you flexibility without sacrificing performance. -->
+このように書くことでパフォーマンスを犠牲にすることなく、柔軟性を確保することができます。
 
-You may think that this gives us terrible performance: return a value and then
-immediately box it up ?! Isn't this pattern the worst of both worlds? Rust is
-smarter than that. There is no copy in this code. `main` allocates enough room
-for the `box`, passes a pointer to that memory into `foo` as `x`, and then
-`foo` writes the value straight into the `Box<T>`.
+<!-- You may think that this gives us terrible performance: return a value and then -->
+<!-- immediately box it up ?! Isn't this pattern the worst of both worlds? Rust is -->
+<!-- smarter than that. There is no copy in this code. `main` allocates enough room -->
+<!-- for the `box`, passes a pointer to that memory into `foo` as `x`, and then -->
+<!-- `foo` writes the value straight into the `Box<T>`. -->
+このコードはひどいパフォーマンス低下をもたらすと感じるかもしれません。値を返して即座にboxに入れるなんて?! このパターンは悪いところどりになっているのでは? Rustはもう少し賢いため、このコードでコピーは発生しません。 `main` 内では `box` のために十分なメモリ領域を確保し、そのメモリへのポインタを `foo` へ `x` として渡します。 `foo` はその値を直接 `Box<T>` (訳注: すなわち `y` )の中に書き込みます。
 
-This is important enough that it bears repeating: pointers are not for
-optimizing returning values from your code. Allow the caller to choose how they
-want to use your output.
+<!-- This is important enough that it bears repeating: pointers are not for -->
+<!-- optimizing returning values from your code. Allow the caller to choose how they -->
+<!-- want to use your output. -->
+重要なことなので繰り返しますが、ポインタを戻り値の最適化のために使うべきではありません。呼び出し側が戻り値をどのように使うかを選択できるようにしましょう。