diff --git a/1.6/ja/book/advanced-linking.md b/1.6/ja/book/advanced-linking.md
index c39ca1f1..abbbf420 100644
--- a/1.6/ja/book/advanced-linking.md
+++ b/1.6/ja/book/advanced-linking.md
@@ -14,8 +14,8 @@ Rustにおけるリンクの一般的なケースについては本書の前の
 <!-- the `link_args` attribute. This attribute is applied to `extern` blocks and -->
 <!-- specifies raw flags which need to get passed to the linker when producing an -->
 <!-- artifact. An example usage would be: -->
-どのようにリンクをカスタマイズするかを`rustc`に指示するために、1つの方法があります。それは、`link_args`アトリビュートを使うことです。
-このアトリビュートは`extern`ブロックに適用され、生成物を作るときにリンカに渡したいフラグをそのまま指定します。
+どのようにリンクをカスタマイズするかを `rustc` に指示するために、1つの方法があります。それは、 `link_args` アトリビュートを使うことです。
+このアトリビュートは `extern` ブロックに適用され、生成物を作るときにリンカに渡したいフラグをそのまま指定します。
 使い方の例は次のようになります。
 
 ``` no_run
@@ -34,14 +34,14 @@ extern {}
 <!-- LLVM directly to link native libraries, in which case `link_args` will have no -->
 <!-- meaning. You can achieve the same effect as the `link_args` attribute with the -->
 <!-- `-C link-args` argument to `rustc`. -->
-これはリンクを実行するための認められた方法ではないため、この機能は現在`feature(link_args)`ゲートによって隠されているということに注意しましょう。
-今は`rustc`がシステムリンカ（多くのシステムでは`gcc`、MSVCでは`link.exe`）に渡すので、追加のコマンドライン引数を提供することには意味がありますが、それが今後もそうだとは限りません。
-将来、`rustc`がネイティブライブラリをリンクするためにLLVMを直接使うようになるかもしれませんし、そのような場合には`link_args`は意味がなくなるでしょう。
-`rustc`に`-C link-args`引数をつけることで、`link_args`アトリビュートと同じような効果を得ることができます。
+これはリンクを実行するための認められた方法ではないため、この機能は現在 `feature(link_args)` ゲートによって隠されているということに注意しましょう。
+今は `rustc` がシステムリンカ（多くのシステムでは `gcc` 、MSVCでは `link.exe` ）に渡すので、追加のコマンドライン引数を提供することには意味がありますが、それが今後もそうだとは限りません。
+将来、 `rustc` がネイティブライブラリをリンクするためにLLVMを直接使うようになるかもしれませんし、そのような場合には `link_args` は意味がなくなるでしょう。
+`rustc` に `-C link-args` 引数をつけることで、 `link_args` アトリビュートと同じような効果を得ることができます。
 
 <!-- It is highly recommended to *not* use this attribute, and rather use the more -->
 <!-- formal `#[link(...)]` attribute on `extern` blocks instead. -->
-このアトリビュートは使わ *ない* ことが強く推奨されているので、代わりにもっと正式な`#[link(...)]`アトリビュートを`extern`ブロックに使いましょう。
+このアトリビュートは使わ *ない* ことが強く推奨されているので、代わりにもっと正式な `#[link(...)]` アトリビュートを `extern` ブロックに使いましょう。
 
 <!-- # Static linking -->
 # スタティックリンク
@@ -55,7 +55,7 @@ extern {}
 <!-- change this and statically link them as well. -->
 スタティックリンクとは全ての必要なライブラリを含めた成果物を生成する手順のことで、そうすればコンパイルされたプロジェクトを使いたいシステム全てにライブラリをインストールする必要がなくなります。
 Rustのみで構築された依存関係はデフォルトでスタティックリンクされます。そのため、Rustをインストールしなくても、作成されたバイナリやライブラリを使うことができます。
-対照的に、ネイティブライブラリ（例えば`libc`や`libm`）はダイナミックリンクされるのが普通です。しかし、これを変更してそれらを同様にスタティックリンクすることも可能です。
+対照的に、ネイティブライブラリ（例えば `libc` や `libm` ）はダイナミックリンクされるのが普通です。しかし、これを変更してそれらを同様にスタティックリンクすることも可能です。
 
 <!-- Linking is a very platform-dependent topic, and static linking may not even be -->
 <!-- possible on some platforms! This section assumes some basic familiarity with -->
@@ -69,8 +69,8 @@ Rustのみで構築された依存関係はデフォルトでスタティック
 <!-- By default, all Rust programs on Linux will link to the system `libc` along with -->
 <!-- a number of other libraries. Let's look at an example on a 64-bit Linux machine -->
 <!-- with GCC and `glibc` (by far the most common `libc` on Linux): -->
-デフォルトでは、Linux上の全てのRustのプログラムはシステムの`libc`とその他のいくつものライブラリとリンクされます。
-GCCと`glibc`（Linuxにおける最も一般的な`libc`）を使った64ビットLinuxマシンでの例を見てみましょう。
+デフォルトでは、Linux上の全てのRustのプログラムはシステムの `libc` とその他のいくつものライブラリとリンクされます。
+GCCと `glibc` （Linuxにおける最も一般的な `libc` ）を使った64ビットLinuxマシンでの例を見てみましょう。
 
 ``` text
 $ cat example.rs
@@ -95,8 +95,8 @@ $ 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/)によってサポートされています。
-以下の手順に従い、`musl`を有効にした独自バージョンのRustをコンパイルして独自のディレクトリにインストールすることができます。
+スタティックリンクは代わりの `libc` である [`musl`](http://www.musl-libc.org/) によってサポートされています。
+以下の手順に従い、 `musl` を有効にした独自バージョンのRustをコンパイルして独自のディレクトリにインストールすることができます。
 
 ```text
 $ mkdir musldist
@@ -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
@@ -171,5 +171,5 @@ thread '<main>' panicked at 'failed', example.rs:1
 <!-- `cargo build` also permits the `--target` option so you should be able to build -->
 <!-- your crates as normal. However, you may need to recompile your native libraries -->
 <!-- against `musl` before they can be linked against. -->
-`cargo build`も`--target`オプションを受け付けるので、あなたのクレートも普通にビルドできるはずです。
-ただし、リンクする前にネイティブライブラリを`musl`向けにリコンパイルする必要はあるかもしれません。
+`cargo build` も `--target` オプションを受け付けるので、あなたのクレートも普通にビルドできるはずです。
+ただし、リンクする前にネイティブライブラリを `musl` 向けにリコンパイルする必要はあるかもしれません。
diff --git a/1.6/ja/book/comments.md b/1.6/ja/book/comments.md
index 809db63d..b5bcc8ee 100644
--- a/1.6/ja/book/comments.md
+++ b/1.6/ja/book/comments.md
@@ -28,7 +28,7 @@ let x = 5; // this is also a line comment.
 <!-- The other kind of comment is a doc comment. Doc comments use `///` instead of -->
 <!-- `//`, and support Markdown notation inside: -->
 その他の種類のコメントはドキュメンテーションコメントです。
-ドキュメンテーションコメントは`//`の代わりに`///`を使い、その中でMarkdown記法をサポートします。
+ドキュメンテーションコメントは `//` の代わりに `///` を使い、その中でMarkdown記法をサポートします。
 
 ```rust
 # /// Adds one to the number given.
@@ -52,7 +52,7 @@ fn add_one(x: i32) -> i32 {
 <!-- There is another style of doc comment, `//!`, to comment containing items (e.g. -->
 <!-- crates, modules or functions), instead of the items following it. Commonly used -->
 <!-- inside crates root (lib.rs) or modules root (mod.rs): -->
-もう1つのスタイルのドキュメンテーションコメントに`//!`があります。これは、その後に続く要素ではなく、それを含んでいる要素（例えばクレート、モジュール、関数）にコメントを付けます。
+もう1つのスタイルのドキュメンテーションコメントに `//!` があります。これは、その後に続く要素ではなく、それを含んでいる要素（例えばクレート、モジュール、関数）にコメントを付けます。
 一般的にはクレートルート（lib.rs）やモジュールルート（mod.rs）の中で使われます。
 
 ```
@@ -68,11 +68,11 @@ fn add_one(x: i32) -> i32 {
 <!-- in documentation. There’s another macro, `assert!`, which `panic!`s if the -->
 <!-- value passed to it is `false`. -->
 ドキュメンテーションコメントを書いているとき、いくつかの使い方の例を提供することは非常に非常に有用です。
-ここでは新しいマクロ、`assert_eq!`を使っていることに気付くでしょう。
-これは2つの値を比較し、もしそれらが互いに等しくなければ`panic!`します。
+ここでは新しいマクロ、 `assert_eq!` を使っていることに気付くでしょう。
+これは2つの値を比較し、もしそれらが互いに等しくなければ `panic!` します。
 これはドキュメントの中で非常に便利です。
-もう1つのマクロ、`assert!`は、それに渡された値が`false`であれば`panic!`します。
+もう1つのマクロ、 `assert!` は、それに渡された値が `false` であれば `panic!` します。
 
 <!-- You can use the [`rustdoc`](documentation.html) tool to generate HTML documentation -->
 <!-- from these doc comments, and also to run the code examples as tests! -->
-それらのドキュメンテーションコメントからHTMLドキュメントを生成するため、そしてコード例をテストとして実行するためにも[`rustdoc`](documentation.html)ツールを使うことができます!
+それらのドキュメンテーションコメントからHTMLドキュメントを生成するため、そしてコード例をテストとして実行するためにも [`rustdoc`](documentation.html) ツールを使うことができます!
diff --git a/1.6/ja/book/documentation.md b/1.6/ja/book/documentation.md
index a6dae604..5177f665 100644
--- a/1.6/ja/book/documentation.md
+++ b/1.6/ja/book/documentation.md
@@ -8,12 +8,12 @@
 プロジェクトのドキュメントを作成するために、Rustが提供するツールについて話しましょう。
 
 <!-- ## About `rustdoc` -->
-## `rustdoc`について
+## `rustdoc` について
 
 <!-- The Rust distribution includes a tool, `rustdoc`, that generates documentation. -->
 <!-- `rustdoc` is also used by Cargo through `cargo doc`. -->
-Rustの配布物には`rustdoc`というドキュメントを生成するツールが含まれています。
-`rustdoc`は`cargo doc`によってCargoでも使われます。
+Rustの配布物には `rustdoc` というドキュメントを生成するツールが含まれています。
+`rustdoc` は `cargo doc` によってCargoでも使われます。
 
 <!-- Documentation can be generated in two ways: from source code, and from -->
 <!-- standalone Markdown files. -->
@@ -52,7 +52,7 @@ pub fn new(value: T) -> Rc<T> {
 <!-- The first thing to notice about this annotation is that it uses -->
 <!-- `///` instead of `//`. The triple slash -->
 <!-- indicates a documentation comment. -->
-この注釈について注意すべき1つ目のことは、`//`の代わりに`///`が使われていることです。
+この注釈について注意すべき1つ目のことは、 `//` の代わりに `///` が使われていることです。
 3連スラッシュはドキュメンテーションコメントを示します。
 
 <!-- Documentation comments are written in Markdown. -->
@@ -102,7 +102,7 @@ hello.rs:4 }
 <!-- This [unfortunate error](https://github.com/rust-lang/rust/issues/22547) is -->
 <!-- correct: documentation comments apply to the thing after them, and there's -->
 <!-- nothing after that last comment. -->
-この[残念なエラー](https://github.com/rust-lang/rust/issues/22547)は正しいのです。ドキュメンテーションコメントはそれらの後のものに適用されるところ、その最後のコメントの後には何もないからです。
+この [残念なエラー](https://github.com/rust-lang/rust/issues/22547) は正しいのです。ドキュメンテーションコメントはそれらの後のものに適用されるところ、その最後のコメントの後には何もないからです。
 
 [rc-new]: https://doc.rust-lang.org/nightly/std/rc/struct.Rc.html#method.new
 
@@ -146,7 +146,7 @@ hello.rs:4 }
 <!-- are four kinds of headers that are commonly used. They aren't special syntax, -->
 <!-- just convention, for now. -->
 次は特別なセクションです。
-それらには`#`が付いていて、ヘッダであることを示しています。
+それらには `#` が付いていて、ヘッダであることを示しています。
 一般的には、4種類のヘッダが使われます。
 今のところそれらは特別な構文ではなく、単なる慣習です。
 
@@ -171,8 +171,8 @@ Rustにおいて、関数の回復不可能な誤用（つまり、プログラ
 <!-- conditions under which it returns `Err(E)` is a nice thing to do. This is -->
 <!-- slightly less important than `Panics`, because failure is encoded into the type -->
 <!-- system, but it's still a good thing to do. -->
-もし関数やメソッドが`Result<T, E>`を戻すのであれば、それが`Err(E)`を戻したときの状況をドキュメントで説明するのはよいことです。
-これは`Panics`のときに比べると重要性は少し下です。失敗は型システムによってコード化されますが、それでもまだそうすることはよいことだからです。
+もし関数やメソッドが `Result<T, E>` を戻すのであれば、それが `Err(E)` を戻したときの状況をドキュメントで説明するのはよいことです。
+これは `Panics` のときに比べると重要性は少し下です。失敗は型システムによってコード化されますが、それでもまだそうすることはよいことだからです。
 
 ```rust
 /// # Safety
@@ -181,7 +181,7 @@ Rustにおいて、関数の回復不可能な誤用（つまり、プログラ
 
 <!-- If your function is `unsafe`, you should explain which invariants the caller is -->
 <!-- responsible for upholding. -->
-もし関数が`unsafe`であれば、呼出元が動作を続けるためにはどの不変条件について責任を持つべきなのかを説明すべきです。
+もし関数が `unsafe` であれば、呼出元が動作を続けるためにはどの不変条件について責任を持つべきなのかを説明すべきです。
 
 ```rust
 /// # Examples
@@ -198,7 +198,7 @@ Rustにおいて、関数の回復不可能な誤用（つまり、プログラ
 <!-- method, and your users will love you for it. These examples go inside of -->
 <!-- code block annotations, which we'll talk about in a moment, and can have -->
 <!-- more than one section: -->
-4つ目は`Examples`です。
+4つ目は `Examples` です。
 関数やメソッドの使い方の例を1つ以上含めてください。そうすればユーザから愛されることでしょう。
 それらの例はコードブロック注釈内に入れます。コードブロック注釈についてはすぐ後で話しますが、それらは1つ以上のセクションを持つことができます。
 
@@ -252,15 +252,15 @@ Rustにおいて、関数の回復不可能な誤用（つまり、プログラ
 <!-- This will highlight according to whatever language you're showing off. -->
 <!-- If you're just showing plain text, choose `text`. -->
 これは、使われている言語が何であるかに応じてハイライトされます。
-もし単なるプレーンテキストを書いているのであれば、`text`を選択してください。
+もし単なるプレーンテキストを書いているのであれば、 `text` を選択してください。
 
 <!-- It's important to choose the correct annotation here, because `rustdoc` uses it -->
 <!-- in an interesting way: It can be used to actually test your examples in a -->
 <!-- library crate, so that they don't get out of date. If you have some C code but -->
 <!-- `rustdoc` thinks it's Rust because you left off the annotation, `rustdoc` will -->
 <!-- complain when trying to generate the documentation. -->
-ここでは正しい注釈を選ぶことが重要です。なぜなら、`rustdoc`はそれを興味深い方法で使うからです。それらが実際のコードと不整合を起こさないように、ライブラリクレート内で実際にあなたの例をテストするために使うのです。
-もし例の中にCのコードが含まれているのに、あなたが注釈を付けるのを忘れてしまい、`rustdoc`がそれをRustのコードだと考えてしまえば、`rustdoc`はドキュメントを生成しようとするときに怒るでしょう。
+ここでは正しい注釈を選ぶことが重要です。なぜなら、 `rustdoc` はそれを興味深い方法で使うからです。それらが実際のコードと不整合を起こさないように、ライブラリクレート内で実際にあなたの例をテストするために使うのです。
+もし例の中にCのコードが含まれているのに、あなたが注釈を付けるのを忘れてしまい、 `rustdoc` がそれをRustのコードだと考えてしまえば、 `rustdoc` はドキュメントを生成しようとするときに怒るでしょう。
 
 <!-- ## Documentation as tests -->
 ## テストとしてのドキュメント
@@ -278,8 +278,8 @@ Rustにおいて、関数の回復不可能な誤用（つまり、プログラ
 <!-- You'll notice that you don't need a `fn main()` or anything here. `rustdoc` will -->
 <!-- automatically add a `main()` wrapper around your code, using heuristics to attempt -->
 <!-- to put it in the right place. For example: -->
-`fn main()`とかがここでは不要だということに気が付くでしょう。
-`rustdoc`は自動的に`main()`ラッパーをコードの周りに、正しい場所へ配置するためのヒューリスティクスを使って追加します。
+`fn main()` とかがここでは不要だということに気が付くでしょう。
+`rustdoc` は自動的に `main()` ラッパーをコードの周りに、正しい場所へ配置するためのヒューリスティクスを使って追加します。
 例えば、こうです。
 
 ```rust
@@ -313,11 +313,11 @@ fn main() {
 <!--    <mycrate>;` is inserted (note the lack of `#[macro_use]`). -->
 <!-- 4. Finally, if the example does not contain `fn main`, the remainder of the -->
 <!--    text is wrapped in `fn main() { your_code }`. -->
-1. 前の方にある全ての`#![foo]`アトリビュートは、そのままクレートのアトリビュートとして置いておく
-2. `unused_variables`、`unused_assignments`、`unused_mut`、`unused_attributes`、`dead_code`などのいくつかの一般的な`allow`アトリビュートを追加する。
+1. 前の方にある全ての `#![foo]` アトリビュートは、そのままクレートのアトリビュートとして置いておく
+2. `unused_variables` 、 `unused_assignments` 、 `unused_mut` 、 `unused_attributes` 、 `dead_code` などのいくつかの一般的な `allow` アトリビュートを追加する。
    小さな例はしばしばこれらのリントに引っ掛かる
-3. もしその例が`extern crate`を含んでいなければ、`extern crate <mycrate>;`を挿入する（`#[macro_use]`がないことに注意する）
-4. 最後に、もし例が`fn main`を含んでいなければ、テキストの残りの部分を`fn main() { your_code }`で囲む
+3. もしその例が `extern crate` を含んでいなければ、 `extern crate <mycrate>;` を挿入する（ `#[macro_use]` がないことに注意する）
+4. 最後に、もし例が `fn main` を含んでいなければ、テキストの残りの部分を `fn main() { your_code }` で囲む
 
 <!-- This generated `fn main` can be a problem! If you have `extern crate` or a `mod` -->
 <!-- statements in the example code that are referred to by `use` statements, they will -->
@@ -325,15 +325,15 @@ fn main() {
 <!-- `#[macro_use] extern crate` also does not work except at the crate root, so when -->
 <!-- testing macros an explicit `main` is always required. It doesn't have to clutter -->
 <!-- up your docs, though -- keep reading! -->
-こうして生成された`fn main`は問題になり得ます!
-もし`use`文によって参照される例のコードに`extern crate`文や`mod`文が入っていれば、それらはステップ4を抑制するために少なくとも`fn main() {}`を含んでいない限り失敗します。
-`#[macro_use] extern crate`も同様に、クレートのルート以外では動作しません。そのため、マクロのテストには明示的な`main`が常に必要なのです。
+こうして生成された `fn main` は問題になり得ます!
+もし `use` 文によって参照される例のコードに `extern crate` 文や `mod` 文が入っていれば、それらはステップ4を抑制するために少なくとも `fn main() {}` を含んでいない限り失敗します。
+`#[macro_use] extern crate` も同様に、クレートのルート以外では動作しません。そのため、マクロのテストには明示的な `main` が常に必要なのです。
 しかし、ドキュメントを散らかす必要はありません……続きを読みましょう!
 
 <!-- Sometimes this algorithm isn't enough, though. For example, all of these code samples -->
 <!-- with `///` we've been talking about? The raw text: -->
 しかし、これでは不十分なことがときどきあります。
-例えば、今まで話してきた全ての`///`の付いたコード例はどうだったでしょうか。
+例えば、今まで話してきた全ての `///` の付いたコード例はどうだったでしょうか。
 生のテキストはこうなっています。
 
 ```text
@@ -359,7 +359,7 @@ fn main() {
 <!-- it makes the example more clear. You can use this technique to explain -->
 <!-- longer examples in detail, while still preserving the testability of your -->
 <!-- documentation. -->
-そうです。正解です。`# `で始まる行を追加することで、コードをコンパイルするときには使われるけれども、出力はされないというようにすることができます。
+そうです。正解です。 `# ` で始まる行を追加することで、コードをコンパイルするときには使われるけれども、出力はされないというようにすることができます。
 これは都合のよいように使うことができます。
 この場合、ドキュメンテーションコメントそのものを見せたいので、ドキュメンテーションコメントを何らかの関数に適用する必要があります。そのため、その後に小さい関数定義を追加する必要があります。
 同時に、それは単にコンパイラを満足させるためだけのものなので、それを隠すことで、例がすっきりするのです。
@@ -477,13 +477,13 @@ macro_rules! panic_unless {
 <!-- we can add the `#[macro_use]` attribute. Second, we’ll need to add our own -->
 <!-- `main()` as well (for reasons discussed above). Finally, a judicious use of -->
 <!-- `#` to comment out those two things, so they don’t show up in the output. -->
-3つのことに気が付くでしょう。`#[macro_use]`アトリビュートを追加するために、自分で`extern crate`行を追加しなければなりません。
-2つ目に、`main()`も自分で追加する必要があります（理由は前述しました）。
-最後に、それらの2つが出力されないようにコメントアウトするという`#`の賢い使い方です。
+3つのことに気が付くでしょう。 `#[macro_use]` アトリビュートを追加するために、自分で `extern crate` 行を追加しなければなりません。
+2つ目に、 `main()` も自分で追加する必要があります（理由は前述しました）。
+最後に、それらの2つが出力されないようにコメントアウトするという `#` の賢い使い方です。
 
 <!-- Another case where the use of `#` is handy is when you want to ignore -->
 <!-- error handling. Lets say you want the following, -->
-`#`の使うと便利な場所のもう1つのケースは、エラーハンドリングを無視したいときです。
+`#` の使うと便利な場所のもう1つのケースは、エラーハンドリングを無視したいときです。
 次のようにしたいとしましょう。
 
 ```rust,ignore
@@ -494,7 +494,7 @@ macro_rules! panic_unless {
 
 <!-- The problem is that `try!` returns a `Result<T, E>` and test functions -->
 <!-- don't return anything so this will give a mismatched types error. -->
-問題は`try!`が`Result<T, E>`を返すところ、テスト関数は何も返さないことで、これは型のミスマッチエラーを起こします。
+問題は `try!` が `Result<T, E>` を返すところ、テスト関数は何も返さないことで、これは型のミスマッチエラーを起こします。
 
 ```rust,ignore
 # /// A doc test using try!
@@ -515,7 +515,7 @@ macro_rules! panic_unless {
 <!-- and swallows the `Result<T, E>` when running tests on the docs. This -->
 <!-- pattern appears regularly in the standard library. -->
 これは関数内のコードをラッピングすることで回避できます。
-これはドキュメント上のテストが実行されるときに`Result<T, E>`を捕まえて飲み込みます。
+これはドキュメント上のテストが実行されるときに `Result<T, E>` を捕まえて飲み込みます。
 このパターンは標準ライブラリ内でよく現れます。
 
 <!-- ### Running documentation tests -->
@@ -534,13 +534,13 @@ $ cargo test
 <!-- `cargo test` will not test binary crates, only library ones.** This is -->
 <!-- due to the way `rustdoc` works: it links against the library to be tested, -->
 <!-- but with a binary, there’s nothing to link to. -->
-正解です。`cargo test`は組み込まれたドキュメントもテストします。
+正解です。 `cargo test` は組み込まれたドキュメントもテストします。
 **しかし、`cargo test`がテストするのはライブラリクレートだけで、バイナリクレートはテストしません。**
-これは`rustdoc`の動き方によるものです。それはテストするためにライブラリをリンクしますが、バイナリには何もリンクするものがないからです。
+これは `rustdoc` の動き方によるものです。それはテストするためにライブラリをリンクしますが、バイナリには何もリンクするものがないからです。
 
 <!-- There are a few more annotations that are useful to help `rustdoc` do the right -->
 <!-- thing when testing your code: -->
-`rustdoc`がコードをテストするときに正しく動作するのを助けるために便利な注釈があと少しあります。
+`rustdoc` がコードをテストするときに正しく動作するのを助けるために便利な注釈があと少しあります。
 
 ```rust
 /// ```ignore
@@ -553,9 +553,9 @@ $ cargo test
 <!-- what you want, as it's the most generic. Instead, consider annotating it -->
 <!-- with `text` if it's not code, or using `#`s to get a working example that -->
 <!-- only shows the part you care about. -->
-`ignore`ディレクティブはRustにコードを無視するよう指示します。
+`ignore` ディレクティブはRustにコードを無視するよう指示します。
 これはあまりに汎用的なので、必要になることはほとんどありません。
-もしそれがコードではなければ、代わりに`text`の注釈を付けること、又は問題となる部分だけが表示された、動作する例を作るために`#`を使うことを検討してください。
+もしそれがコードではなければ、代わりに `text` の注釈を付けること、又は問題となる部分だけが表示された、動作する例を作るために `#` を使うことを検討してください。
 
 ```rust
 /// ```should_panic
@@ -566,7 +566,7 @@ $ cargo test
 
 <!-- `should_panic` tells `rustdoc` that the code should compile correctly, but -->
 <!-- not actually pass as a test. -->
-`should_panic`は、そのコードは正しくコンパイルされるべきではあるが、実際にテストとして成功する必要まではないということを`rustdoc`に教えます。
+`should_panic` は、そのコードは正しくコンパイルされるべきではあるが、実際にテストとして成功する必要まではないということを `rustdoc` に教えます。
 
 ```rust
 /// ```no_run
@@ -580,14 +580,14 @@ $ cargo test
 <!-- The `no_run` attribute will compile your code, but not run it. This is -->
 <!-- important for examples such as "Here's how to start up a network service," -->
 <!-- which you would want to make sure compile, but might run in an infinite loop! -->
-`no_run`アトリビュートはコードをコンパイルしますが、実行はしません。
+`no_run` アトリビュートはコードをコンパイルしますが、実行はしません。
 これは「これはネットワークサービスを開始する方法です」というような例や、コンパイルされることは保証したいけれども、無限ループになってしまうような例にとって重要です!
 
 <!-- ### Documenting modules -->
 ### モジュールのドキュメントの作成
 
 <!-- Rust has another kind of doc comment, `//!`. This comment doesn't document the next item, but the enclosing item. In other words: -->
-Rustには別の種類のドキュメンテーションコメント、`//!`があります。
+Rustには別の種類のドキュメンテーションコメント、 `//!` があります。
 このコメントは次に続く要素のドキュメントではなく、それを囲っている要素のドキュメントです。
 言い換えると、こうです。
 
@@ -604,8 +604,8 @@ mod foo {
 
 <!-- This is where you'll see `//!` used most often: for module documentation. If -->
 <!-- you have a module in `foo.rs`, you'll often open its code and see this: -->
-`//!`を頻繁に見る場所がここ、モジュールドキュメントです。
-もし`foo.rs`内にモジュールを持っていれば、しばしばそのコードを開くとこれを見るでしょう。
+`//!` を頻繁に見る場所がここ、モジュールドキュメントです。
+もし `foo.rs` 内にモジュールを持っていれば、しばしばそのコードを開くとこれを見るでしょう。
 
 ```rust
 # //! A module for using `foo`s.
@@ -620,7 +620,7 @@ mod foo {
 
 <!-- Check out [RFC 505][rfc505] for full conventions around the style and format of -->
 <!-- documentation. -->
-ドキュメントのスタイルや書式についての全ての慣習を知るには[RFC 505][rfc505]をチェックしてください。
+ドキュメントのスタイルや書式についての全ての慣習を知るには [RFC 505][rfc505] をチェックしてください。
 
 [rfc505]: https://github.com/rust-lang/rfcs/blob/master/text/0505-api-comment-conventions.md
 
@@ -630,7 +630,7 @@ mod foo {
 <!-- All of this behavior works in non-Rust source files too. Because comments -->
 <!-- are written in Markdown, they're often `.md` files. -->
 ここにある振舞いは全て、Rust以外のソースコードファイルでも働きます。
-コメントはMarkdownで書かれるので、しばしば`.md`ファイルになります。
+コメントはMarkdownで書かれるので、しばしば `.md` ファイルになります。
 
 <!-- When you write documentation in Markdown files, you don't need to prefix -->
 <!-- the documentation with comments. For example: -->
@@ -675,10 +675,10 @@ Markdownファイルの中ではこうします。
 ```
 
 <!-- This `%` line needs to be the very first line of the file. -->
-この`%`行はそのファイルの一番先頭の行に書く必要があります。
+この `%` 行はそのファイルの一番先頭の行に書く必要があります。
 
 <!-- ## `doc` attributes -->
-## `doc`アトリビュート
+## `doc` アトリビュート
 
 <!-- At a deeper level, documentation comments are syntactic sugar for documentation -->
 <!-- attributes: -->
@@ -709,7 +709,7 @@ Markdownファイルの中ではこうします。
 ### 再エクスポート
 
 <!-- `rustdoc` will show the documentation for a public re-export in both places: -->
-`rustdoc`はパブリックな再エクスポートがなされた場合に、両方の場所にドキュメントを表示します。
+`rustdoc` はパブリックな再エクスポートがなされた場合に、両方の場所にドキュメントを表示します。
 
 ```ignore
 extern crate foo;
@@ -720,11 +720,11 @@ pub use foo::bar;
 <!-- This will create documentation for `bar` both inside the documentation for the -->
 <!-- crate `foo`, as well as the documentation for your crate. It will use the same -->
 <!-- documentation in both places. -->
-これは`bar`のドキュメントをクレートのドキュメントの中に生成するのと同様に、`foo`クレートのドキュメントの中にも生成します。
+これは `bar` のドキュメントをクレートのドキュメントの中に生成するのと同様に、 `foo` クレートのドキュメントの中にも生成します。
 同じドキュメントが両方の場所で使われます。
 
 <!-- This behavior can be suppressed with `no_inline`: -->
-この振舞いは`no_inline`で抑制することができます。
+この振舞いは `no_inline` で抑制することができます。
 
 ```ignore
 extern crate foo;
@@ -742,14 +742,14 @@ pub use foo::bar;
 <!-- To generate warnings you use `warn`: -->
 ときどき、プロジェクト内の公開されている全てのものについて、ドキュメントが作成されていることを確認したいことがあります。これは特にライブラリについて作業をしているときにあります。
 Rustでは、要素にドキュメントがないときに警告やエラーを生成することができます。
-警告を生成するためには、`warn`を使います。
+警告を生成するためには、 `warn` を使います。
 
 ```rust
 #![warn(missing_docs)]
 ```
 
 <!-- And to generate errors you use `deny`: -->
-そしてエラーを生成するとき、`deny`を使います。
+そしてエラーを生成するとき、 `deny` を使います。
 
 ```rust,ignore
 #![deny(missing_docs)]
@@ -758,7 +758,7 @@ Rustでは、要素にドキュメントがないときに警告やエラーを
 <!-- There are cases where you want to disable these warnings/errors to explicitly -->
 <!-- leave something undocumented. This is done by using `allow`: -->
 何かを明示的にドキュメント化されていないままにするため、それらの警告やエラーを無効にしたい場合があります。
-これは`allow`を使えば可能です。
+これは `allow` を使えば可能です。
 
 ```rust
 #[allow(missing_docs)]
@@ -778,7 +778,7 @@ struct Hidden;
 
 <!-- You can control a few aspects of the HTML that `rustdoc` generates through the -->
 <!-- `#![doc]` version of the attribute: -->
-`rustdoc`の生成するHTMLのいくつかの外見は、`#![doc]`アトリビュートを通じて制御することができます。
+`rustdoc` の生成するHTMLのいくつかの外見は、 `#![doc]` アトリビュートを通じて制御することができます。
 
 ```rust
 #![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
@@ -794,7 +794,7 @@ struct Hidden;
 
 <!-- You can also configure the way that `rustdoc` tests your documentation examples -->
 <!-- through the `#![doc(test(..))]` attribute. -->
-`rustdoc`がドキュメントの例をテストする方法は、`#[doc(test(..))]`アトリビュートを通じて設定することができます。
+`rustdoc` がドキュメントの例をテストする方法は、 `#[doc(test(..))]` アトリビュートを通じて設定することができます。
 
 ```rust
 #![doc(test(attr(allow(unused_variables), deny(warnings))))]
@@ -808,16 +808,16 @@ struct Hidden;
 ## 生成オプション
 
 <!-- `rustdoc` also contains a few other options on the command line, for further customization: -->
-`rustdoc`はさらなるカスタマイズのために、その他にもコマンドラインのオプションをいくつか持っています。
+`rustdoc` はさらなるカスタマイズのために、その他にもコマンドラインのオプションをいくつか持っています。
 
 <!-- - `--html-in-header FILE`: includes the contents of FILE at the end of the -->
 <!--   `<head>...</head>` section. -->
 <!-- - `--html-before-content FILE`: includes the contents of FILE directly after -->
 <!--   `<body>`, before the rendered content (including the search bar). -->
 <!-- - `--html-after-content FILE`: includes the contents of FILE after all the rendered content. -->
-- `--html-in-header FILE`: FILEの内容を`<head>...</head>`セクションの末尾に加える
-- `--html-before-content FILE`: FILEの内容を`<body>`の直後、レンダリングされた内容（検索バーを含む）の直前に加える
-- `--html-after-content FILE`: FILEの内容を全てのレンダリングされた内容の後に加える
+- `--html-in-header FILE` : FILEの内容を `<head>...</head>` セクションの末尾に加える
+- `--html-before-content FILE` : FILEの内容を `<body>` の直後、レンダリングされた内容（検索バーを含む）の直前に加える
+- `--html-after-content FILE` : FILEの内容を全てのレンダリングされた内容の後に加える
 
 <!-- ## Security note -->
 ## セキュリティ上の注意
diff --git a/1.6/ja/book/functions.md b/1.6/ja/book/functions.md
index 59125259..54c056b1 100644
--- a/1.6/ja/book/functions.md
+++ b/1.6/ja/book/functions.md
@@ -2,7 +2,7 @@
 <!-- % Functions -->
 
 <!--Every Rust program has at least one function, the `main` function:-->
-Rustのプログラムには全て、少なくとも1つの関数、`main`関数があります。
+Rustのプログラムには全て、少なくとも1つの関数、 `main` 関数があります。
 
 ```rust
 fn main() {
@@ -14,8 +14,8 @@ fn main() {
 <!--this function takes no arguments, and then some curly braces to indicate the-->
 <!--body. Here’s a function named `foo`:-->
 これは評価可能な関数定義の最も単純なものです。
-前に言ったように、`fn`は「これは関数です」ということを示します。この関数には引数がないので、名前と丸括弧が続きます。そして、その本文を表す波括弧が続きます。
-これが`foo`という名前の関数です。
+前に言ったように、 `fn` は「これは関数です」ということを示します。この関数には引数がないので、名前と丸括弧が続きます。そして、その本文を表す波括弧が続きます。
+これが `foo` という名前の関数です。
 
 ```rust
 fn foo() {
@@ -33,7 +33,7 @@ fn print_number(x: i32) {
 ```
 
 <!--Here’s a complete program that uses `print_number`:-->
-これが`print_number`を使う完全なプログラムです。
+これが `print_number` を使う完全なプログラムです。
 
 ```rust
 fn main() {
@@ -47,7 +47,7 @@ fn print_number(x: i32) {
 
 <!--As you can see, function arguments work very similar to `let` declarations:-->
 <!--you add a type to the argument name, after a colon.-->
-見てのとおり、関数の引数は`let`宣言と非常によく似た動きをします。
+見てのとおり、関数の引数は `let` 宣言と非常によく似た動きをします。
 引数の名前にコロンに続けて型を追加します。
 
 <!--Here’s a complete program that adds two numbers together and prints them:-->
@@ -69,7 +69,7 @@ fn print_sum(x: i32, y: i32) {
 
 <!--Unlike `let`, you _must_ declare the types of function arguments. This does-->
 <!--not work:-->
-`let`と異なり、あなたは関数の引数の型を宣言 _しなければなりません_ 。
+`let` と異なり、あなたは関数の引数の型を宣言 _しなければなりません_ 。
 これは動きません。
 
 ```rust,ignore
@@ -109,7 +109,7 @@ fn add_one(x: i32) -> i32 {
 <!--‘arrow’, which is a dash (`-`) followed by a greater-than sign (`>`). The last-->
 <!--line of a function determines what it returns. You’ll note the lack of a-->
 <!--semicolon here. If we added it in:-->
-Rustの関数はちょうど1つだけの値を返します。そして、ダッシュ（`-`）の後ろに大なりの記号（`>`）を続けた「矢印」の後にその型を宣言します。
+Rustの関数はちょうど1つだけの値を返します。そして、ダッシュ（ `-` ）の後ろに大なりの記号（ `>` ）を続けた「矢印」の後にその型を宣言します。
 関数の最後の行が何を返すのかを決定します。
 ここにセミコロンがないことに気が付くでしょう。
 もしそれを追加すると、こうなります。
@@ -155,7 +155,7 @@ Rustは主として式ベースの言語です。
 <!--an expression. Let’s talk about declaration statements first.-->
 ではその違いは何でしょうか。
 式は値を返しますが、文は返しません。
-それが「not all control paths return a value」で終わった理由です。文`x + 1;`は値を返さないからです。
+それが「not all control paths return a value」で終わった理由です。文 `x + 1;` は値を返さないからです。
 Rustには2種類の文があります。「宣言文」と「式文」です。
 その他の全ては式です。
 まずは宣言文について話しましょう。
@@ -171,7 +171,7 @@ x = y = 5
 
 <!--In Rust, however, using `let` to introduce a binding is _not_ an expression. The-->
 <!--following will produce a compile-time error:-->
-しかし、Rustでは束縛を導入するための`let`の使用は式では _ありません_ 。
+しかし、Rustでは束縛を導入するための `let` の使用は式では _ありません_ 。
 次の例はコンパイルエラーを起こします。
 
 ```ignore
@@ -180,7 +180,7 @@ let x = (let y = 5); // expected identifier, found keyword `let`
 
 <!--The compiler is telling us here that it was expecting to see the beginning of-->
 <!--an expression, and a `let` can only begin a statement, not an expression.-->
-ここでコンパイラは次のことを教えています。式の先頭を検出することが期待されていたところ、`let`は式ではなく文の先頭にしかなれないということです。
+ここでコンパイラは次のことを教えています。式の先頭を検出することが期待されていたところ、 `let` は式ではなく文の先頭にしかなれないということです。
 
 <!--Note that assigning to an already-bound variable (e.g. `y = 5`) is still an-->
 <!--expression, although its value is not particularly useful. Unlike other-->
@@ -188,7 +188,7 @@ let x = (let y = 5); // expected identifier, found keyword `let`
 <!--previous example), in Rust the value of an assignment is an empty tuple `()`-->
 <!--because the assigned value can have [just one owner](ownership.html), and any-->
 <!--other returned value would be too surprising:-->
-次のことに注意しましょう。既に束縛されている変数（例えば、`y = 5`）への割当ては、その値が特に役に立つものではなかったとしてもやはり式です。割当てが割り当てられる値（例えば、前の例では`5`）を評価する他の言語とは異なり、Rustでは割当ての値は空のタプル`()`です。なぜなら、割り当てられる値には[単一の所有者](ownership.html)しかおらず、他のどんな値を返したとしても予想外の出来事になってしまうからです。
+次のことに注意しましょう。既に束縛されている変数（例えば、 `y = 5` ）への割当ては、その値が特に役に立つものではなかったとしてもやはり式です。割当てが割り当てられる値（例えば、前の例では `5` ）を評価する他の言語とは異なり、Rustでは割当ての値は空のタプル `()` です。なぜなら、割り当てられる値には [単一の所有者](ownership.html) しかおらず、他のどんな値を返したとしても予想外の出来事になってしまうからです。
 
 
 ```rust
@@ -224,7 +224,7 @@ fn add_one(x: i32) -> i32 {
 <!--Our function claims to return an `i32`, but with a semicolon, it would return-->
 <!--`()` instead. Rust realizes this probably isn’t what we want, and suggests-->
 <!--removing the semicolon in the error we saw before.-->
-この関数は`i32`を返そうとしていますが、セミコロンを付ければ、それは代わりに`()`を返します。
+この関数は `i32` を返そうとしていますが、セミコロンを付ければ、それは代わりに `()` を返します。
 Rustはこの挙動がおそらく求めているものではないということを理解するので、前に見たエラーの中で、セミコロンを削除することを提案するのです。
 
 <!--## Early returns-->
@@ -232,7 +232,7 @@ Rustはこの挙動がおそらく求めているものではないというこ
 
 <!--But what about early returns? Rust does have a keyword for that, `return`:-->
 しかし、早期リターンについてはどうでしょうか。
-Rustはそのためのキーワード`return`を持っています。
+Rustはそのためのキーワード `return` を持っています。
 
 ```rust
 fn foo(x: i32) -> i32 {
@@ -245,7 +245,7 @@ fn foo(x: i32) -> i32 {
 
 <!--Using a `return` as the last line of a function works, but is considered poor-->
 <!--style:-->
-`return`を関数の最後の行で使っても動きますが、それはよろしくないスタイルだと考えられています。
+`return` を関数の最後の行で使っても動きますが、それはよろしくないスタイルだと考えられています。
 
 ```rust
 fn foo(x: i32) -> i32 {
@@ -256,7 +256,7 @@ fn foo(x: i32) -> i32 {
 <!--The previous definition without `return` may look a bit strange if you haven’t-->
 <!--worked in an expression-based language before, but it becomes intuitive over-->
 <!--time.-->
-あなたがこれまで式ベースの言語を使ったことがなければ、`return`のない前の定義の方がちょっと変に見えるかもしれません。しかし、それは時間とともに直観的に感じられるようになります。
+あなたがこれまで式ベースの言語を使ったことがなければ、 `return` のない前の定義の方がちょっと変に見えるかもしれません。しかし、それは時間とともに直観的に感じられるようになります。
 
 <!--## Diverging functions-->
 ## ダイバージング関数
@@ -275,13 +275,13 @@ fn diverges() -> ! {
 <!--`println!()`, `panic!()` causes the current thread of execution to crash with-->
 <!--the given message. Because this function will cause a crash, it will never-->
 <!--return, and so it has the type ‘`!`’, which is read ‘diverges’.-->
-`panic!`は既に見てきた`println!`と同様にマクロです。
-`println!`とは違って、`panic!`は実行中の現在のスレッドを与えられたメッセージとともにクラッシュさせます。
-この関数はクラッシュを引き起こすので、決してリターンしません。そのため、それは「ダイバージ」と読む、「`!`」型を持つのです。
+`panic!` は既に見てきた `println!` と同様にマクロです。
+`println!` とは違って、 `panic!` は実行中の現在のスレッドを与えられたメッセージとともにクラッシュさせます。
+この関数はクラッシュを引き起こすので、決してリターンしません。そのため、それは「ダイバージ」と読む、「 `!` 」型を持つのです。
 
 <!--If you add a main function that calls `diverges()` and run it, you’ll get-->
 <!--some output that looks like this:-->
-もし`diverges()`を呼び出すメイン関数を追加してそれを実行するならば、次のようなものが出力されるでしょう。
+もし `diverges()` を呼び出すメイン関数を追加してそれを実行するならば、次のようなものが出力されるでしょう。
 
 ```text
 thread ‘<main>’ panicked at ‘This function never returns!’, hello.rs:2
@@ -289,7 +289,7 @@ thread ‘<main>’ panicked at ‘This function never returns!’, hello.rs:2
 
 <!--If you want more information, you can get a backtrace by setting the-->
 <!--`RUST_BACKTRACE` environment variable:-->
-もしもっと情報を得たいと思うのであれば、`RUST_BACKTRACE`環境変数をセットすることでバックトレースを得ることができます。
+もしもっと情報を得たいと思うのであれば、 `RUST_BACKTRACE` 環境変数をセットすることでバックトレースを得ることができます。
 
 ```text
 $ RUST_BACKTRACE=1 ./diverges
@@ -311,7 +311,7 @@ stack backtrace:
 ```
 
 <!--`RUST_BACKTRACE` also works with Cargo’s `run` command:-->
-`RUST_BACKTRACE`はCargoの`run`コマンドでも使うことができます。
+`RUST_BACKTRACE` はCargoの `run` コマンドでも使うことができます。
 
 ```text
 $ RUST_BACKTRACE=1 cargo run
@@ -356,7 +356,7 @@ let f: fn(i32) -> i32;
 
 <!--`f` is a variable binding which points to a function that takes an `i32` as-->
 <!--an argument and returns an `i32`. For example:-->
-`f`は`i32`を引数として受け取り、`i32`を返す関数を指示する変数束縛です。
+`f` は `i32` を引数として受け取り、 `i32` を返す関数を指示する変数束縛です。
 例えばこうです。
 
 ```rust
@@ -372,7 +372,7 @@ let f = plus_one;
 ```
 
 <!--We can then use `f` to call the function:-->
-そして、その関数を呼び出すために`f`を使うことができます。
+そして、その関数を呼び出すために `f` を使うことができます。
 
 ```rust
 # fn plus_one(i: i32) -> i32 { i + 1 }
diff --git a/1.6/ja/book/lifetimes.md b/1.6/ja/book/lifetimes.md
index 82830119..0afbcf53 100644
--- a/1.6/ja/book/lifetimes.md
+++ b/1.6/ja/book/lifetimes.md
@@ -15,7 +15,7 @@
 <!-- * lifetimes, which you’re reading now -->
 * キーとなる概念、 [所有権][ownership]
 * [借用][borrowing] 、そしてそれらに関連する機能、「参照」
-* 今読んでいる、 ライフタイム
+* 今読んでいる、ライフタイム
 
 <!-- These three chapters are related, and in order. You’ll need all three to fully -->
 <!-- understand the ownership system. -->
diff --git a/1.6/ja/book/ownership.md b/1.6/ja/book/ownership.md
index 4a415268..72619028 100644
--- a/1.6/ja/book/ownership.md
+++ b/1.6/ja/book/ownership.md
@@ -15,8 +15,8 @@
 <!-- * [borrowing][borrowing], and their associated feature ‘references’ -->
 <!-- * [lifetimes][lifetimes], an advanced concept of borrowing -->
 * 今読んでいる、所有権
-* [借用][borrowing]、そしてそれらに関連する機能、「参照」
-* 借用のもう一歩進んだ概念、[ライフタイム][lifetimes]
+* [借用][borrowing] 、そしてそれらに関連する機能、「参照」
+* 借用のもう一歩進んだ概念、 [ライフタイム][lifetimes]
 
 <!-- These three chapters are related, and in order. You’ll need all three to fully -->
 <!-- understand the ownership system. -->
@@ -67,7 +67,7 @@ Rustはそれらの目標をたくさんの「ゼロコスト抽象化」を通
 <!-- [Variable bindings][bindings] have a property in Rust: they ‘have ownership’ -->
 <!-- of what they’re bound to. This means that when a binding goes out of scope, -->
 <!-- Rust will free the bound resources. For example: -->
-Rustでは[変数束縛][bindings]は所有物を持ちます。つまり、それらはそれらが束縛されているものの「所有権を持つ」ということです。
+Rustでは [変数束縛][bindings] は所有物を持ちます。つまり、それらはそれらが束縛されているものの「所有権を持つ」ということです。
 これは束縛がスコープから外れるとき、Rustは束縛されているリソースを解放するだろうということを意味します。
 例えばこうです。
 
@@ -82,9 +82,9 @@ fn foo() {
 <!-- `v` goes out of scope at the end of `foo()`, Rust will clean up everything -->
 <!-- related to the vector, even the heap-allocated memory. This happens -->
 <!-- deterministically, at the end of the scope. -->
-`v`がスコープに入るとき、新しい[`Vec<T>`][vect]が作られます。
-この場合、ベクタも3つの要素のために[ヒープ][heap]に空間を割り当てます。
-`foo()`の最後で`v`がスコープから外れるとき、Rustはベクタに関連するもの全てを取り除くでしょう。それがヒープ割当てのメモリであってもです。
+`v` がスコープに入るとき、新しい [`Vec<T>`][vect] が作られます。
+この場合、ベクタも3つの要素のために [ヒープ][heap] に空間を割り当てます。
+`foo()` の最後で `v` がスコープから外れるとき、Rustはベクタに関連するもの全てを取り除くでしょう。それがヒープ割当てのメモリであってもです。
 これはスコープの最後で決定的に起こります。
 
 [vect]: ../std/vec/struct.Vec.html
@@ -107,7 +107,7 @@ let v2 = v;
 ```
 
 <!-- But, if we try to use `v` afterwards, we get an error: -->
-しかし、もし後で`v`を使おうとすると、エラーが出ます。
+しかし、もし後で `v` を使おうとすると、エラーが出ます。
 
 ```rust,ignore
 let v = vec![1, 2, 3];
@@ -172,12 +172,12 @@ let v2 = v;
 <!-- pointers to the content of the vector on the heap. It would violate Rust’s -->
 <!-- safety guarantees by introducing a data race. Therefore, Rust forbids using `v` -->
 <!-- after we’ve done the move. -->
-最初の行はベクタオブジェクト`v`とそれの含むデータのためのメモリを割り当てます。
-ベクタオブジェクトは[スタック][sh]に保存され、[ヒープ][sh]に保存された内容（`[1, 2, 3]`）へのポインタを含みます。
-`v`を`v2`にムーブするとき、それは`v2`のためにそのポインタのコピーを作ります。
+最初の行はベクタオブジェクト `v` とそれの含むデータのためのメモリを割り当てます。
+ベクタオブジェクトは [スタック][sh] に保存され、 [ヒープ][sh] に保存された内容（ `[1, 2, 3]` ）へのポインタを含みます。
+`v` を `v2` にムーブするとき、それは `v2` のためにそのポインタのコピーを作ります。
 それは、ヒープ上のベクタの内容へのポインタが2つあることを意味します。
 それはデータ競合を持ち込むことでRustの安全性保証に違反するでしょう。
-そのため、Rustはムーブを終えた後の`v`の使用を禁止するのです。
+そのため、Rustはムーブを終えた後の `v` の使用を禁止するのです。
 
 [sh]: the-stack-and-the-heap.html
 
@@ -188,7 +188,7 @@ let v2 = v;
 そのため、それは最初に思ったほど非効率ではないかもしれません。
 
 <!-- ## `Copy` types -->
-## `Copy`型
+## `Copy` 型
 
 <!-- We’ve established that when ownership is transferred to another binding, you -->
 <!-- cannot use the original binding. However, there’s a [trait][traits] that changes this -->
@@ -196,7 +196,7 @@ let v2 = v;
 <!-- you can think of them as an annotation to a particular type that adds extra -->
 <!-- behavior. For example: -->
 所有権が他の束縛に転送されるとき、元の束縛を使うことができないということを証明しました。
-しかし、この挙動を変更する[トレイト][traits]があります。それは`Copy`と呼ばれます。
+しかし、この挙動を変更する [トレイト][traits] があります。それは `Copy` と呼ばれます。
 トレイトについてはまだ議論していませんが、とりあえずそれらを挙動を追加するある型への注釈として考えることができます。
 例えばこうです。
 
@@ -212,17 +212,17 @@ println!("v is: {}", v);
 <!-- that, just like a move, when we assign `v` to `v2`, a copy of the data is made. -->
 <!-- But, unlike a move, we can still use `v` afterward. This is because an `i32` -->
 <!-- has no pointers to data somewhere else, copying it is a full copy. -->
-この場合、`v`は`i32`で、それは`Copy`トレイトを実装します。
-これはちょうどムーブと同じように、`v`を`v2`に割り当てるとき、データのコピーが作られるということを意味します。
-しかし、ムーブと違って後でまだ`v`を使うことができます。
-これは`i32`がどこか別の場所へのポインタを持たず、コピーが完全コピーだからです。
+この場合、 `v` は `i32` で、それは `Copy` トレイトを実装します。
+これはちょうどムーブと同じように、 `v` を `v2` に割り当てるとき、データのコピーが作られるということを意味します。
+しかし、ムーブと違って後でまだ `v` を使うことができます。
+これは `i32` がどこか別の場所へのポインタを持たず、コピーが完全コピーだからです。
 
 <!-- All primitive types implement the `Copy` trait and their ownership is -->
 <!-- therefore not moved like one would assume, following the ´ownership rules´. -->
 <!-- To give an example, the two following snippets of code only compile because the -->
 <!-- `i32` and `bool` types implement the `Copy` trait. -->
-全てのプリミティブ型は`Copy`トレイトを実装しているので、推測どおりそれらの所有権は「所有権ルール」に従ってはムーブしません。
-例として、次の2つのコードスニペットはコンパイルが通ります。なぜなら、`i32`型と`bool`型は`Copy`トレイトを実装するからです。
+全てのプリミティブ型は `Copy` トレイトを実装しているので、推測どおりそれらの所有権は「所有権ルール」に従ってはムーブしません。
+例として、次の2つのコードスニペットはコンパイルが通ります。なぜなら、 `i32` 型と `bool` 型は `Copy` トレイトを実装するからです。
 
 ```rust
 fn main() {
@@ -252,7 +252,7 @@ fn change_truth(x: bool) -> bool {
 
 <!-- If we had used types that do not implement the `Copy` trait, -->
 <!-- we would have gotten a compile error because we tried to use a moved value. -->
-もし`Copy`トレイトを実装していない型を使っていたならば、ムーブした値を使おうとしたため、コンパイルエラーが出ていたでしょう。
+もし `Copy` トレイトを実装していない型を使っていたならば、ムーブした値を使おうとしたため、コンパイルエラーが出ていたでしょう。
 
 ```text
 error: use of moved value: `a`
@@ -262,7 +262,7 @@ println!("{}", a);
 
 <!-- We will discuss how to make your own types `Copy` in the [traits][traits] -->
 <!-- section. -->
-独自の`Copy`型を作る方法は[トレイト][traits]セクションで議論するでしょう。
+独自の `Copy` 型を作る方法は [トレイト][traits] セクションで議論するでしょう。
 
 [traits]: traits.html
 
diff --git a/1.6/ja/book/primitive-types.md b/1.6/ja/book/primitive-types.md
index e0215015..b4591922 100644
--- a/1.6/ja/book/primitive-types.md
+++ b/1.6/ja/book/primitive-types.md
@@ -13,8 +13,8 @@ Rust言語は「プリミティブ」であると考えられるかなりの数
 # ブーリアン型
 
 <!-- Rust has a built in boolean type, named `bool`. It has two values, `true` and `false`: --> 
-Rustには`bool`と名付けられた組込みのブーリアン型があります。
-それは`true`と`false`という2つの値を持ちます。
+Rustには `bool` と名付けられた組込みのブーリアン型があります。
+それは `true` と `false` という2つの値を持ちます。
 
 ```rust
 let x = true;
@@ -23,13 +23,13 @@ let y: bool = false;
 ```
 
 <!-- A common use of booleans is in [`if` conditionals][if]. --> 
-ブーリアンの一般的な使い方は、[`if`条件][if]の中で用いるものです。
+ブーリアンの一般的な使い方は、 [`if`条件][if] の中で用いるものです。
 
 [if]: if.html
 
 <!-- You can find more documentation for `bool`s [in the standard library --> 
 <!-- documentation][bool]. --> 
-`bool`のさらなるドキュメントは[標準ライブラリのドキュメントの中][bool]で見付けることができます。
+`bool` のさらなるドキュメントは [標準ライブラリのドキュメントの中][bool] で見付けることができます。
 
 [bool]: ../std/primitive.bool.html
 
@@ -38,8 +38,8 @@ let y: bool = false;
 
 <!-- The `char` type represents a single Unicode scalar value. You can create `char`s --> 
 <!-- with a single tick: (`'`) --> 
-`char`型は1つのユニコードのスカラ値を表現します。
-`char`はシングルクオート（`'`）で作ることができます。
+`char` 型は1つのユニコードのスカラ値を表現します。
+`char` はシングルクオート（ `'` ）で作ることができます。
 
 ```rust
 let x = 'x';
@@ -48,11 +48,11 @@ let two_hearts = '💕';
 
 <!-- Unlike some other languages, this means that Rust’s `char` is not a single byte, --> 
 <!-- but four. --> 
-`char`が1バイトである他の言語と異なり、これはRustの`char`が1バイトではなく4バイトであるということを意味します。
+`char` が1バイトである他の言語と異なり、これはRustの `char` が1バイトではなく4バイトであるということを意味します。
 
 <!-- You can find more documentation for `char`s [in the standard library --> 
 <!-- documentation][char]. --> 
-`char`のさらなるドキュメントは[標準ライブラリのドキュメントの中][char]で見付けることができます。
+`char` のさらなるドキュメントは [標準ライブラリのドキュメントの中][char] で見付けることができます。
 
 [char]: ../std/primitive.char.html
 
@@ -67,7 +67,7 @@ Rustにはいくつかのカテゴリの中にたくさんの種類の数値型
 <!-- `u16` is an unsigned type with sixteen bits of size. More bits lets you have --> 
 <!-- bigger numbers. --> 
 それらの型はカテゴリとサイズという2つの部分から成ります。
-例えば、`u16`はサイズ16ビットで符号なしの型です。
+例えば、 `u16` はサイズ16ビットで符号なしの型です。
 ビット数を大きくすれば、より大きな数値を扱うことができます。
 
 <!-- If a number literal has nothing to cause its type to be inferred, it defaults: --> 
@@ -109,16 +109,16 @@ let y = 1.0; // y has type f64
 <!-- not need to store negatives, can store values from `0` to `+15`. --> 
 整数型には符号ありと符号なしという2つの種類があります。
 違いを理解するために、サイズ4ビットの数値を考えましょう。
-符号あり4ビット整数は`-8`から`+7`までの数値を保存することができます。
+符号あり4ビット整数は `-8` から `+7` までの数値を保存することができます。
 符号ありの数値は「2の補数表現」を使います。
-符号なし4ビット整数は、マイナスを保存する必要がないため、`0`から`+15`までの値を保存することができます。
+符号なし4ビット整数は、マイナスを保存する必要がないため、 `0` から `+15` までの値を保存することができます。
 
 <!-- Unsigned types use a `u` for their category, and signed types use `i`. The `i` --> 
 <!-- is for ‘integer’. So `u8` is an eight-bit unsigned number, and `i8` is an --> 
 <!-- eight-bit signed number. --> 
-符号なし（訳注：unsigned）型はそれらのカテゴリに`u`を使い、符号あり型は`i`を使います。
-`i`は「整数（訳注：integer）」の頭文字です。
-そのため、`u8`は8ビット符号なし数値、`i8`は8ビット符号あり数値です。
+符号なし（訳注：unsigned）型はそれらのカテゴリに `u` を使い、符号あり型は `i` を使います。
+`i` は「整数（訳注：integer）」の頭文字です。
+そのため、 `u8` は8ビット符号なし数値、 `i8` は8ビット符号あり数値です。
 
 <!-- ## Fixed size types --> 
 ## 固定長型
@@ -127,8 +127,8 @@ let y = 1.0; // y has type f64
 <!-- bit sizes are `8`, `16`, `32`, and `64`. So, `u32` is an unsigned, 32-bit integer, --> 
 <!-- and `i64` is a signed, 64-bit integer. --> 
 固定長型はそれらの表現の中に特定のビット数を持ちます。
-指定することのできるビット長は`8`、`16`、`32`、`64`です。
-そのため、`u32`は符号なし32ビット整数、`i64`は符号あり64ビット整数です。
+指定することのできるビット長は `8` 、 `16` 、 `32` 、 `64` です。
+そのため、 `u32` は符号なし32ビット整数、 `i64` は符号あり64ビット整数です。
 
 <!-- ## Variable sized types --> 
 ## 可変長型
@@ -138,14 +138,14 @@ let y = 1.0; // y has type f64
 <!-- and unsigned varieties. This makes for two types: `isize` and `usize`. --> 
 Rustはそのサイズが実行しているマシンのポインタのサイズに依存する型も提供します。
 それらの型はカテゴリとして「size」を使い、符号ありと符号なしの種類があります。
-これが`isize`と`usize`という2つの型を作ります。
+これが `isize` と `usize` という2つの型を作ります。
 
 <!-- ## Floating-point types --> 
 ## 浮動小数点型
 
 <!-- Rust also has two floating point types: `f32` and `f64`. These correspond to --> 
 <!-- IEEE-754 single and double precision numbers. --> 
-Rustは`f32`と`f64`という2つの浮動小数点型を持ちます。
+Rustは `f32` と `f64` という2つの浮動小数点型を持ちます。
 それらはIEEE-754単精度及び倍精度小数点数に対応します。
 
 <!-- # Arrays --> 
@@ -166,21 +166,21 @@ let mut m = [1, 2, 3]; // m: [i32; 3]
 <!-- Arrays have type `[T; N]`. We’ll talk about this `T` notation [in the generics --> 
 <!-- section][generics]. The `N` is a compile-time constant, for the length of the --> 
 <!-- array. --> 
-配列は`[T; N]`という型を持ちます。
-この`T`記法については[ジェネリクスのセクションの中][generics]で話します。
-`N`は配列の長さのためのコンパイル時の定数です。
+配列は `[T; N]` という型を持ちます。
+この `T` 記法については [ジェネリクスのセクションの中][generics] で話します。
+`N` は配列の長さのためのコンパイル時の定数です。
 
 <!-- There’s a shorthand for initializing each element of an array to the same --> 
 <!-- value. In this example, each element of `a` will be initialized to `0`: --> 
 配列の各要素を同じ値で初期化するための省略表現があります。
-この例では、`a`の各要素は`0`で初期化されます。
+この例では、 `a` の各要素は `0` で初期化されます。
 
 ```rust
 let a = [0; 20]; // a: [i32; 20]
 ```
 
 <!-- You can get the number of elements in an array `a` with `a.len()`: --> 
-配列`a`の要素の個数は`a.len()`で得ることができます。
+配列 `a` の要素の個数は `a.len()` で得ることができます。
 
 ```rust
 let a = [1, 2, 3];
@@ -203,14 +203,14 @@ println!("The second name is: {}", names[1]);
 <!-- array, you will get an error: array access is bounds-checked at run-time. Such --> 
 <!-- errant access is the source of many bugs in other systems programming --> 
 <!-- languages. --> 
-添字はほとんどのプログラミング言語と同じように0から始まります。そのため、最初の名前は`names[0]`で2つ目の名前は`names[1]`です。
-前の例は`The second name is: Brian`とプリントします。
+添字はほとんどのプログラミング言語と同じように0から始まります。そのため、最初の名前は `names[0]` で2つ目の名前は `names[1]` です。
+前の例は `The second name is: Brian` とプリントします。
 もし配列に含まれない添字を使おうとすると、エラーが出ます。配列アクセスは実行時に境界チェックを受けます。
 他のシステムプログラミング言語では、そのような誤ったアクセスは多くのバグの源となります。
 
 <!-- You can find more documentation for `array`s [in the standard library --> 
 <!-- documentation][array]. --> 
-`array`のさらなるドキュメントは[標準ライブラリのドキュメントの中][array]で見付けることができます。
+`array` のさらなるドキュメントは [標準ライブラリのドキュメントの中][array] で見付けることができます。
 
 [array]: ../std/primitive.array.html
 
@@ -234,8 +234,8 @@ println!("The second name is: {}", names[1]);
 <!-- You can use a combo of `&` and `[]` to create a slice from various things. The --> 
 <!-- `&` indicates that slices are similar to references, and the `[]`s, with a --> 
 <!-- range, let you define the length of the slice: --> 
-様々なものからスライスを作るためには`&`と`[]`の組合せを使うことができます。
-`&`はスライスが参照と同じであることを示し、`[]`はレンジを持ち、スライスの長さを定義します。
+様々なものからスライスを作るためには `&` と `[]` の組合せを使うことができます。
+`&` はスライスが参照と同じであることを示し、 `[]` はレンジを持ち、スライスの長さを定義します。
 
 ```rust
 let a = [0, 1, 2, 3, 4];
@@ -245,14 +245,14 @@ let middle = &a[1..4]; // A slice of a: just the elements 1, 2, and 3
 
 <!-- Slices have type `&[T]`. We’ll talk about that `T` when we cover --> 
 <!-- [generics][generics]. --> 
-スライスは型`&[T]`を持ちます。
-[ジェネリクス][generics]をカバーするときにその`T`について話すでしょう。
+スライスは型 `&[T]` を持ちます。
+[ジェネリクス][generics] をカバーするときにその `T` について話すでしょう。
 
 [generics]: generics.html
 
 <!-- You can find more documentation for slices [in the standard library --> 
 <!-- documentation][slice]. --> 
-`slice`のさらなるドキュメントは[標準ライブラリのドキュメントの中][slice]で見付けることができます。
+`slice` のさらなるドキュメントは [標準ライブラリのドキュメントの中][slice] で見付けることができます。
 
 [slice]: ../std/primitive.slice.html
 
@@ -262,8 +262,8 @@ let middle = &a[1..4]; // A slice of a: just the elements 1, 2, and 3
 <!-- Rust’s `str` type is the most primitive string type. As an [unsized type][dst], --> 
 <!-- it’s not very useful by itself, but becomes useful when placed behind a reference, --> 
 <!-- like [`&str`][strings]. As such, we’ll just leave it at that. --> 
-Rustの`str`型は最もプリミティブな文字列型です。
-[サイズ不定型][dst]のように、それはそれ自体で非常に便利なものではありませんが、[`&str`][strings]のように参照の後ろに置かれたときに便利になります。
+Rustの `str` 型は最もプリミティブな文字列型です。
+[サイズ不定型][dst] のように、それはそれ自体で非常に便利なものではありませんが、 [`&str`][strings] のように参照の後ろに置かれたときに便利になります。
 そのため、それはそのまま置いておきましょう。
 
 [dst]: unsized-types.html
@@ -271,7 +271,7 @@ Rustの`str`型は最もプリミティブな文字列型です。
 
 <!-- You can find more documentation for `str` [in the standard library --> 
 <!-- documentation][str]. --> 
-`str`のさらなるドキュメントは[標準ライブラリのドキュメントの中][str]で見付けることができます。
+`str` のさらなるドキュメントは [標準ライブラリのドキュメントの中][str] で見付けることができます。
 
 [str]: ../std/primitive.str.html
 
@@ -302,13 +302,13 @@ let x: (i32, &str) = (1, "hello");
 <!-- languages. For now, just read `&str` as a *string slice*, and we’ll learn more --> 
 <!-- soon. --> 
 見てのとおり、タプルの型はタプルとちょうど同じように見えます。しかし、各位置には値ではなく型名が付いています。
-注意深い読者は、タプルが異なる型の値を含んでいることにも気が付くでしょう。このタプルには`i32`と`&str`が入っています。
+注意深い読者は、タプルが異なる型の値を含んでいることにも気が付くでしょう。このタプルには `i32` と `&str` が入っています。
 システムプログラミング言語では、文字列は他の言語よりも少し複雑です。
-今のところ、`&str`を *文字列スライス* と読むだけにしましょう。それ以上のことは後で学ぶでしょう。
+今のところ、 `&str` を *文字列スライス* と読むだけにしましょう。それ以上のことは後で学ぶでしょう。
 
 <!-- You can assign one tuple into another, if they have the same contained types --> 
 <!-- and [arity]. Tuples have the same arity when they have the same length. --> 
-もしそれらの持っている型と[アリティ][arity]が同じであれば、あるタプルを他のタプルに割り当てることができます。
+もしそれらの持っている型と [アリティ][arity] が同じであれば、あるタプルを他のタプルに割り当てることができます。
 タプルの長さが同じであれば、それらのタプルのアリティは同じです。
 
 [arity]: glossary.html#arity
@@ -336,10 +336,10 @@ println!("x is {}", x);
 <!-- the left-hand side of the `let`, and if it matches up to the right-hand side, --> 
 <!-- we can assign multiple bindings at once. In this case, `let` “destructures” --> 
 <!-- or “breaks up” the tuple, and assigns the bits to three bindings. --> 
-[前に][let]`let`文の左辺は単なる束縛の割当てよりももっと強力だと言ったときのことを覚えていますか。
+[前に][let]`let` 文の左辺は単なる束縛の割当てよりももっと強力だと言ったときのことを覚えていますか。
 ここで説明します。
-`let`の左辺にはパターンを書くことができ、もしそれが右辺とマッチしたならば、複数の束縛を一度に割り当てることができます。
-この場合、`let`が「分配束縛」、つまりタプルを「分解して」、要素を3つの束縛に割り当てます。
+`let` の左辺にはパターンを書くことができ、もしそれが右辺とマッチしたならば、複数の束縛を一度に割り当てることができます。
+この場合、 `let` が「分配束縛」、つまりタプルを「分解して」、要素を3つの束縛に割り当てます。
 
 [let]: variable-bindings.html
 
@@ -373,11 +373,11 @@ println!("x is {}", x);
 
 <!-- Like array indexing, it starts at zero, but unlike array indexing, it uses a --> 
 <!-- `.`, rather than `[]`s. --> 
-配列のインデックスと同じように、それは0から始まります。しかし、配列のインデックスと異なり、それは`[]`ではなく`.`を使います。
+配列のインデックスと同じように、それは0から始まります。しかし、配列のインデックスと異なり、それは `[]` ではなく `.` を使います。
 
 <!-- You can find more documentation for tuples [in the standard library --> 
 <!-- documentation][tuple]. --> 
-タプルのさらなるドキュメントは[標準ライブラリのドキュメントの中][tuple]で見付けることができます。
+タプルのさらなるドキュメントは [標準ライブラリのドキュメントの中][tuple] で見付けることができます。
 
 [tuple]: ../std/primitive.tuple.html
 
@@ -396,4 +396,4 @@ let x: fn(i32) -> i32 = foo;
 
 <!-- In this case, `x` is a ‘function pointer’ to a function that takes an `i32` and --> 
 <!-- returns an `i32`. --> 
-この場合、`x`は`i32`を受け取り`i32`を戻す関数への「関数ポインタ」です。
+この場合、 `x` は `i32` を受け取り `i32` を戻す関数への「関数ポインタ」です。
diff --git a/1.6/ja/book/references-and-borrowing.md b/1.6/ja/book/references-and-borrowing.md
index 051dd0e2..f81578f0 100644
--- a/1.6/ja/book/references-and-borrowing.md
+++ b/1.6/ja/book/references-and-borrowing.md
@@ -14,9 +14,9 @@
 <!-- * [ownership][ownership], the key concept -->
 <!-- * borrowing, which you’re reading now -->
 <!-- * [lifetimes][lifetimes], an advanced concept of borrowing -->
-* キーとなる概念、[所有権][ownership]
+* キーとなる概念、 [所有権][ownership]
 * 今読んでいる、借用
-* 借用のもう一歩進んだ概念、[ライフタイム][lifetimes]
+* 借用のもう一歩進んだ概念、 [ライフタイム][lifetimes]
 
 <!-- These three chapters are related, and in order. You’ll need all three to fully -->
 <!-- understand the ownership system. -->
@@ -66,7 +66,7 @@ Rustはそれらの目標をたくさんの「ゼロコスト抽象化」を通
 
 <!-- At the end of the [ownership][ownership] section, we had a nasty function that looked -->
 <!-- like this: -->
-[所有権][ownership]セクションの最後に、このような感じの厄介な関数に出会いました。
+[所有権][ownership] セクションの最後に、このような感じの厄介な関数に出会いました。
 
 ```rust
 fn foo(v1: Vec<i32>, v2: Vec<i32>) -> (Vec<i32>, Vec<i32>, i32) {
@@ -114,16 +114,16 @@ let answer = foo(&v1, &v2);
 <!-- it borrows ownership. A binding that borrows something does not deallocate the -->
 <!-- resource when it goes out of scope. This means that after the call to `foo()`, -->
 <!-- we can use our original bindings again. -->
-引数として`Vec<i32>`を使う代わりに、参照、つまり`&Vec<i32>`を使います。
-そして、`v1`と`v2`を直接渡す代わりに、`&v1`と`&v2`を渡します。
-`&T`型は「参照」と呼ばれ、それは、リソースを所有するのではなく、所有権を借用します。
+引数として `Vec<i32>` を使う代わりに、参照、つまり `&Vec<i32>` を使います。
+そして、 `v1` と `v2` を直接渡す代わりに、 `&v1` と `&v2` を渡します。
+`&T` 型は「参照」と呼ばれ、それは、リソースを所有するのではなく、所有権を借用します。
 何かを借用した束縛はそれがスコープから外れるときにリソースを割当解除しません。
-これは`foo()`の呼出しの後に元の束縛を再び使うことができることを意味します。
+これは `foo()` の呼出しの後に元の束縛を再び使うことができることを意味します。
 
 <!-- References are immutable, just like bindings. This means that inside of `foo()`, -->
 <!-- the vectors can’t be changed at all: -->
 参照は束縛とちょうど同じようにイミュータブルです。
-これは`foo()`の中ではベクタは全く変更できないことを意味します。
+これは `foo()` の中ではベクタは全く変更できないことを意味します。
 
 ```rust,ignore
 fn foo(v: &Vec<i32>) {
@@ -152,7 +152,7 @@ v.push(5);
 
 <!-- There’s a second kind of reference: `&mut T`. A ‘mutable reference’ allows you -->
 <!-- to mutate the resource you’re borrowing. For example: -->
-参照には2つ目の種類、`&mut T`があります。
+参照には2つ目の種類、 `&mut T` があります。
 「ミュータブルな参照」によって借用しているリソースを変更することができるようになります。
 例は次のとおりです。
 
@@ -168,24 +168,24 @@ println!("{}", x);
 <!-- This will print `6`. We make `y` a mutable reference to `x`, then add one to -->
 <!-- the thing `y` points at. You’ll notice that `x` had to be marked `mut` as well. -->
 <!-- If it wasn’t, we couldn’t take a mutable borrow to an immutable value. -->
-これは`6`をプリントするでしょう。
-`y`を`x`へのミュータブルな参照にして、それから`y`の指示先に1を足します。
-`x`も`mut`とマークしなければならないことに気付くでしょう。
+これは `6` をプリントするでしょう。
+`y` を `x` へのミュータブルな参照にして、それから `y` の指示先に1を足します。
+`x` も `mut` とマークしなければならないことに気付くでしょう。
 そうしないと、イミュータブルな値へのミュータブルな借用ということになってしまい、使うことができなくなってしまいます。
 
 <!-- You'll also notice we added an asterisk (`*`) in front of `y`, making it `*y`, -->
 <!-- this is because `y` is an `&mut` reference. You'll also need to use them for -->
 <!-- accessing the contents of a reference as well. -->
-アスタリスク（`*`）を`y`の前に追加して、それを`*y`にしたことにも気付くでしょう。これは、`y`が`&mut`参照だからです。
+アスタリスク（ `*` ）を `y` の前に追加して、それを `*y` にしたことにも気付くでしょう。これは、 `y` が `&mut` 参照だからです。
 参照の内容にアクセスするためにもそれらを使う必要があるでしょう。
 
 <!-- Otherwise, `&mut` references are just like references. There _is_ a large -->
 <!-- difference between the two, and how they interact, though. You can tell -->
 <!-- something is fishy in the above example, because we need that extra scope, with -->
 <!-- the `{` and `}`. If we remove them, we get an error: -->
-それ以外は、`&mut`参照は普通の参照と全く同じです。
+それ以外は、 `&mut` 参照は普通の参照と全く同じです。
 しかし、2つの間には、そしてそれらがどのように相互作用するかには大きな違いが _あります_ 。
-前の例で何かが怪しいと思ったかもしれません。なぜなら、`{`と`}`を使って追加のスコープを必要とするからです。
+前の例で何かが怪しいと思ったかもしれません。なぜなら、 `{` と `}` を使って追加のスコープを必要とするからです。
 もしそれらを削除すれば、次のようなエラーが出ます。
 
 ```text
@@ -220,8 +220,8 @@ fn main() {
 
 <!-- * one or more references (`&T`) to a resource, -->
 <!-- * exactly one mutable reference (`&mut T`). -->
-* リソースに対する1つ以上の参照（`&T`）
-* ただ1つのミュータブルな参照（`&mut T`）
+* リソースに対する1つ以上の参照（ `&T` ）
+* ただ1つのミュータブルな参照（ `&mut T` ）
 
 <!-- You may notice that this is very similar, though not exactly the same as, -->
 <!-- to the definition of a data race: -->
@@ -237,7 +237,7 @@ fn main() {
 <!-- have a data race. This is how Rust prevents data races at compile time: we’ll -->
 <!-- get errors if we break the rules. -->
 書込みを行わないのであれば、参照は好きな数だけ使うことができます。
-`&mut`は同時に1つしか持つことができないので、データ競合は起き得ません。
+`&mut` は同時に1つしか持つことができないので、データ競合は起き得ません。
 これがRustがデータ競合をコンパイル時に回避する方法です。もしルールを破れば、そのときはエラーが出るでしょう。
 
 <!-- With this in mind, let’s consider our example again. -->
@@ -270,7 +270,7 @@ error: cannot borrow `x` as immutable because it is also borrowed as mutable
 <!-- This is because we’ve violated the rules: we have a `&mut T` pointing to `x`, -->
 <!-- and so we aren’t allowed to create any `&T`s. One or the other. The note -->
 <!-- hints at how to think about this problem: -->
-なぜなら、これはルールに違反しているからです。つまり、`x`を指示する`&mut T`を持つので、`&T`を作ることは許されないのです。
+なぜなら、これはルールに違反しているからです。つまり、 `x` を指示する `&mut T` を持つので、 `&T` を作ることは許されないのです。
 どちらか1つです。
 メモはこの問題についての考え方のヒントを示します。
 
@@ -287,7 +287,7 @@ fn main() {
 <!-- make an immutable borrow. In Rust, borrowing is tied to the scope that the -->
 <!-- borrow is valid for. And our scopes look like this: -->
 言い換えると、ミュータブルな借用は先程の例の残りの間ずっと保持されるということです。
-必要なものは、`println!`を呼び出し、イミュータブルな借用を作ろうとする _前に_ 終わるミュータブルな借用です。
+必要なものは、 `println!` を呼び出し、イミュータブルな借用を作ろうとする _前に_ 終わるミュータブルな借用です。
 Rustでは借用はその有効なスコープと結び付けられます。
 そしてスコープはこのように見えます。
 
@@ -309,7 +309,7 @@ println!("{}", x); // -+ - ここでxを借用しようとする
 ```
 
 <!-- The scopes conflict: we can’t make an `&x` while `y` is in scope. -->
-スコープは衝突します。`y`がスコープにある間は、`&x`を作ることができません。
+スコープは衝突します。 `y` がスコープにある間は、 `&x` を作ることができません。
 
 <!-- So when we add the curly braces: -->
 そして、波括弧を追加するときはこうなります。
@@ -367,7 +367,7 @@ for i in &v {
 <!-- which means we can’t change it while we’re iterating: -->
 これは1から3までをプリントアウトします。
 ベクタに対して繰り返すとき、要素への参照だけを受け取ります。
-そして、`v`はそれ自体イミュータブルとして借用され、それは繰返しを行っている間はそれを変更できないことを意味します。
+そして、 `v` はそれ自体イミュータブルとして借用され、それは繰返しを行っている間はそれを変更できないことを意味します。
 
 ```rust,ignore
 let mut v = vec![1, 2, 3];
@@ -398,7 +398,7 @@ for i in &v {
 ```
 
 <!-- We can’t modify `v` because it’s borrowed by the loop. -->
-`v`はループによって借用されるので、それを変更することはできません。
+`v` はループによって借用されるので、それを変更することはできません。
 
 <!-- ### use after free -->
 ### 解放後の使用
@@ -449,8 +449,8 @@ statement 0 at 4:18
 <!-- `x` goes away, it becomes invalid to refer to it. As such, the error says that -->
 <!-- the borrow ‘doesn’t live long enough’ because it’s not valid for the right -->
 <!-- amount of time. -->
-言い換えると、`y`は`x`が存在するスコープの中でだけ有効だということです。
-`x`がなくなるとすぐに、それを指示することは不正になります。
+言い換えると、 `y` は `x` が存在するスコープの中でだけ有効だということです。
+`x` がなくなるとすぐに、それを指示することは不正になります。
 そのように、エラーは借用が「十分長く生存していない」ことを示します。なぜなら、それが正しい期間有効ではないからです。
 
 <!-- The same problem occurs when the reference is declared _before_ the variable it -->
@@ -494,4 +494,4 @@ statement 1 at 3:14
 
 <!-- In the above example, `y` is declared before `x`, meaning that `y` lives longer -->
 <!-- than `x`, which is not allowed. -->
-前の例では、`y`は`x`より前に宣言されています。それは、`y`が`x`より長く生存することを意味し、それは許されません。
+前の例では、 `y` は `x` より前に宣言されています。それは、 `y` が `x` より長く生存することを意味し、それは許されません。