diff --git a/1.6/ja/book/SUMMARY.md b/1.6/ja/book/SUMMARY.md
index 169db56e..da6a9872 100644
--- a/1.6/ja/book/SUMMARY.md
+++ b/1.6/ja/book/SUMMARY.md
@@ -31,9 +31,9 @@
     * [クロージャ](closures.md)
     * [共通の関数呼出構文](ufcs.md)
     * [クレートとモジュール](crates-and-modules.md)
-    * [`const`と`static`](const-and-static.md)
+    * [`const` と `static`](const-and-static.md)
     * [アトリビュート](attributes.md)
-    * [`type`エイリアス](type-aliases.md)
+    * [`type` エイリアス](type-aliases.md)
     * [型間のキャスト](casting-between-types.md)
     * [関連型](associated-types.md)
     * [サイズ不定型](unsized-types.md)
diff --git a/1.6/ja/book/conditional-compilation.md b/1.6/ja/book/conditional-compilation.md
index 07f2afa6..d729b1b2 100644
--- a/1.6/ja/book/conditional-compilation.md
+++ b/1.6/ja/book/conditional-compilation.md
@@ -39,7 +39,7 @@ Rustには `#[cfg]` という特別なアトリビュートがあり、
 
 <!-- As for how to enable or disable these switches, if you’re using Cargo, -->
 <!-- they get set in the [`[features]` section][features] of your `Cargo.toml`: -->
-このようなスイッチの有効・無効の切り替えはCargoを利用している場合`Cargo.toml`中の [`[features]` セクション][features] で設定できます。
+このようなスイッチの有効・無効の切り替えはCargoを利用している場合 `Cargo.toml` 中の [`[features]` セクション][features] で設定できます。
 
 [features]: http://doc.crates.io/manifest.html#the-features-section
 
@@ -76,7 +76,7 @@ mod foo {
 <!-- and so, no `foo` module will exist. -->
 もしこのコードを `cargo build --features "foo"` としてコンパイルを行うと、
 `--cfg features="foo"` が `rustc` に渡され、出力には `mod foo` が含まれます。
-もし標準的な `cargo build` でコンパイルを行った場合、`rustc` に追加のフラグは渡されず`foo` モジュールは存在しない事になります。
+もし標準的な `cargo build` でコンパイルを行った場合、`rustc` に追加のフラグは渡されず `foo` モジュールは存在しない事になります。
 
 # cfg_attr
 
diff --git a/1.6/ja/book/getting-started.md b/1.6/ja/book/getting-started.md
index ab9fe6d3..528544d6 100644
--- a/1.6/ja/book/getting-started.md
+++ b/1.6/ja/book/getting-started.md
@@ -22,9 +22,9 @@ Rustを使い始める最初のステップはインストールです。
 <!-- the start of each command. We’ll see many tutorials and examples around the web -->
 <!-- that follow this convention: `$` for commands run as our regular user, and `#` -->
 <!-- for commands we should be running as an administrator. -->
-コマンドを色々提示しますが、それらは全て`$`から始まります。`$`を入力する必要はありません。
-`$`はただコマンドの先頭を示しているだけです。
-これから、Web上でも「`$`で始まるものは一般ユーザで実行し`#`で始まるものは管理者権限で実行する」というルールに従ったチュートリアルや例をよく見ることになります。
+コマンドを色々提示しますが、それらは全て `$` から始まります。 `$` を入力する必要はありません。
+`$` はただコマンドの先頭を示しているだけです。
+これから、Web上でも「 `$` で始まるものは一般ユーザで実行し `#` で始まるものは管理者権限で実行する」というルールに従ったチュートリアルや例をよく見ることになります。
 
 <!-- ## Platform support -->
 ## プラットフォームのサポート
@@ -55,7 +55,7 @@ Rustのサポートレベルは3階級に分かれていて、それぞれ違う
 <!-- * Official release artifacts are provided for the platform. -->
 <!-- * Documentation for how to use and how to build the platform is available. -->
 * 自動テストがそのプラットフォーム上で走るようセットアップされている
-* `rust-lang/rust`レポジトリのmasterブランチへの変更はテストが通ってからされる
+* `rust-lang/rust` レポジトリのmasterブランチへの変更はテストが通ってからされる
 * 公式のリリースがそのプラットフォーム向けに提供される
 * 使用方法及びビルド方法のドキュメントがある
 
@@ -86,7 +86,7 @@ Rustのサポートレベルは3階級に分かれていて、それぞれ違う
 <!--   standard library is compiled, but for others the full bootstrap is run. -->
 <!-- * Official release artifacts are provided for the platform. -->
 * 自動ビルドはセットアップされているがテストは走っていないかもしれない
-* `rust-lang/rust`レポジトリのmasterブランチへの変更は **ビルドが** 通ってからされる。
+* `rust-lang/rust` レポジトリのmasterブランチへの変更は **ビルドが** 通ってからされる。
   これは標準ライブラリしかコンパイル出来ないものもあれば完全なブートストラップまで出来るものもあることを意味するということに注意してください。
 * 公式のリリースがそのプラットフォーム向けに提供される
 
@@ -195,7 +195,7 @@ Continue? (y/N)
 > ```
 
 <!-- From here, press `y` for ‘yes’, and then follow the rest of the prompts. -->
-ここで「はい」の意味で`y`を押しましょう。そして以後のプロンプトに従って下さい。
+ここで「はい」の意味で `y` を押しましょう。そして以後のプロンプトに従って下さい。
 
 <!-- ## Installing on Windows -->
 ## Windowsでのインストール
@@ -219,7 +219,7 @@ $ sudo /usr/local/lib/rustlib/uninstall.sh
 
 <!-- If we used the Windows installer, we can re-run the `.msi` and it will give us -->
 <!-- an uninstall option. -->
-Windowsのインストーラを使ったなら`.msi`をもう一度実行すればアンインストールのオプションが出てきます。
+Windowsのインストーラを使ったなら `.msi` をもう一度実行すればアンインストールのオプションが出てきます。
 
 <!-- ## Troubleshooting -->
 ## トラブルシューティング
@@ -267,8 +267,8 @@ repair, or remove installation」ページの「Change」を選択し、「Add t
 <!-- On Windows, it's in a `share/doc` directory, inside the directory to which Rust -->
 <!-- was installed. -->
 インストーラはドキュメントのコピーもローカルにインストールしますので、オフラインで読めます。
-UNIXシステムでは`/usr/local/share/doc/rust`にあります。
-WindowsではRustをインストールした所の`share/doc`ディレクトリにあります。
+UNIXシステムでは `/usr/local/share/doc/rust` にあります。
+WindowsではRustをインストールした所の `share/doc` ディレクトリにあります。
 
 
 <!-- # Hello, world! -->
@@ -328,7 +328,7 @@ $ cd hello_world
 
 <!-- &gt; Note: If you’re on Windows and not using PowerShell, the `~` may not work. -->
 <!-- &gt; Consult the documentation for your shell for more details. -->
-> 留意: WindowsでかつPowerShellを使っていないのなら `~`は上手く動かないかもしれません。
+> 留意: WindowsでかつPowerShellを使っていないのなら  `~` は上手く動かないかもしれません。
 > 使っているシェルのドキュメントをあたってみて下さい。
 
 <!-- ## Writing and Running a Rust Program -->
@@ -365,7 +365,7 @@ Hello, world!
 <!-- system, you should see the string `Hello, world!` print to the terminal. If you -->
 <!-- did, then congratulations! You've officially written a Rust program. That makes -->
 <!-- you a Rust programmer! Welcome.  -->
-Windowsでは`main`を`main.exe`と読み替えて下さい。使っているOSに関わらず、`Hello, world!`の文字列がターミナルに印字されるのを目にする筈です。
+Windowsでは `main` を `main.exe` と読み替えて下さい。使っているOSに関わらず、 `Hello, world!` の文字列がターミナルに印字されるのを目にする筈です。
 目にしたなら、おめでとうございます！あなたは正式にRustのプログラムを記述しました。これであなたもRustプログラマです！ようこそ。
 
 
@@ -389,20 +389,20 @@ fn main() {
 <!-- were arguments, they would go inside the parentheses (`(` and `)`), and because -->
 <!-- we aren’t returning anything from this function, we can omit the return type -->
 <!-- entirely. -->
-これらの行はRustの *関数* を定義します。`main`関数は特別です。全てのRustプログラムの開始点になります。
-最初の行は「引数を取らず、返り値も返さない関数`main`を宣言します」といっています。
-引数があれば、括弧(`(`と`)`)の中に入りますし、今回はこの関数から何も値を返さないので返り値の型を完全に省略出来ます。
+これらの行はRustの *関数* を定義します。 `main` 関数は特別です。全てのRustプログラムの開始点になります。
+最初の行は「引数を取らず、返り値も返さない関数 `main` を宣言します」といっています。
+引数があれば、括弧(`(` と `)`)の中に入りますし、今回はこの関数から何も値を返さないので返り値の型を完全に省略出来ます。
 
 <!-- Also note that the function body is wrapped in curly braces (`{` and `}`). Rust -->
 <!-- requires these around all function bodies. It's considered good style to put -->
 <!-- the opening curly brace on the same line as the function declaration, with one -->
 <!-- space in between. -->
-さらに、関数の本体部が波括弧(`{`と`}`)で括られていることに留意して下さい。
+さらに、関数の本体部が波括弧(`{` と `}`)で括られていることに留意して下さい。
 Rustは全ての関数の本体部に波括弧を要請します。
 関数宣言と同じ行に1スペース空けて開き波括弧を置くのが良いスタイルとされます。
 
 <!-- Inside the `main()` function: -->
-`main()`関数の中では
+`main()` 関数の中では
 
 ```rust
     println!("Hello, world!");
@@ -420,9 +420,9 @@ Rustは全ての関数の本体部に波括弧を要請します。
 <!-- discuss Rust macros in more detail later, but for now you just need to -->
 <!-- know that when you see a `!` that means that you’re calling a macro instead of -->
 <!-- a normal function.  -->
-2つ目の重要な部分は`println!()`の行です。これはRustのメタプログラミング機構、 *[マクロ][macro]* の呼び出しです。
-もし関数を呼び出しているのなら、`println()`のようになります(! がありません)。
-Rustのマクロについては後程詳細に議論しますが、今のところ`!`を見たら普通の関数ではなくマクロを呼び出していることを意味するということだけ知っておいて下さい。
+2つ目の重要な部分は `println!()` の行です。これはRustのメタプログラミング機構、 *[マクロ][macro]* の呼び出しです。
+もし関数を呼び出しているのなら、 `println()` のようになります(! がありません)。
+Rustのマクロについては後程詳細に議論しますが、今のところ `!` を見たら普通の関数ではなくマクロを呼び出していることを意味するということだけ知っておいて下さい。
 
 
 [macro]: macros.html
@@ -431,9 +431,9 @@ Rustのマクロについては後程詳細に議論しますが、今のとこ
 <!-- complicated topic in a systems programming language, and this is a *[statically -->
 <!-- allocated]* string. We pass this string as an argument to `println!`, which -->
 <!-- prints the string to the screen. Easy enough! -->
-次は 文字列の`"Hello, world"`です。
+次は 文字列の `"Hello, world"` です。
 システムプログラミング言語では文字列は驚くほど複雑なトピックで、これは *[静的に確保された][statically allocated]* 文字列です。
-文字列をスクリーンに印字してくれる`println!`にこれを引数として渡します。簡単ですね！
+文字列をスクリーンに印字してくれる `println!` にこれを引数として渡します。簡単ですね！
 
 [statically allocated]: the-stack-and-the-heap.html
 
@@ -442,7 +442,7 @@ Rustのマクロについては後程詳細に議論しますが、今のとこ
 <!-- The `;` indicates that this expression is over, and the next one is ready to -->
 <!-- begin. Most lines of Rust code end with a `;`. -->
 件の行はセミコロン(`;`)で終わります。Rustは *[式指向言語][expression-oriented language]* で、ほとんどのものは文ではなく式になります。
-`;`は式が終わり、次の式が始まることを示します。Rustのコードのほとんどの行は`;`で終わります。
+`;` は式が終わり、次の式が始まることを示します。Rustのコードのほとんどの行は `;` で終わります。
 
 <!-- [expression-oriented language]: glossary.html#expression-oriented-language -->
 [expression-oriented language]: glossary.html#式指向言語
@@ -459,7 +459,7 @@ Rustのマクロについては後程詳細に議論しますが、今のとこ
 <!-- compiler by entering the `rustc` command and passing it the name of your source -->
 <!-- file, like this: -->
 Rustのプログラムを走らせる前に、コンパイルする必要があります。
-Rustのコンパイラはこのように`rustc`と入力してソースファイルの名前を渡してあげることで使えます。
+Rustのコンパイラはこのように `rustc` と入力してソースファイルの名前を渡してあげることで使えます。
 
 ```bash
 $ rustc main.rs
@@ -469,9 +469,9 @@ $ rustc main.rs
 <!-- `gcc` or `clang`. After compiling successfully, Rust should output a binary -->
 <!-- executable, which you can see on Linux or OSX by entering the `ls` command in -->
 <!-- your shell as follows: -->
-CまたはC++のバックグラウンドを持つならこれが`gcc`や`clang`に似ていことに気付くでしょう。
+CまたはC++のバックグラウンドを持つならこれが `gcc` や `clang` に似ていことに気付くでしょう。
 コンパイルが成功したら、Rustは実行可能バイナリを吐いている筈です。
-LinuxかOSXなら以下のように`ls`コマンドで確認出来ます。
+LinuxかOSXなら以下のように `ls` コマンドで確認出来ます。
 
 ```bash
 $ ls
@@ -489,8 +489,8 @@ main.exe  main.rs
 <!-- This shows we have two files: the source code, with an `.rs` extension, and the -->
 <!-- executable (`main.exe` on Windows, `main` everywhere else). All that's left to -->
 <!-- do from here is run the `main` or `main.exe` file, like this: -->
-2つのファイルがあるといっています。`.rs`拡張子を持ったソースコードと実行可能ファイル(Windowsでは`main.exe`、それ以外では`main`)。
-ここからあとは`main`または`main.exe`のファイルをこのように実行するだけです。
+2つのファイルがあるといっています。 `.rs` 拡張子を持ったソースコードと実行可能ファイル(Windowsでは `main.exe` 、それ以外では `main` )。
+ここからあとは `main` または `main.exe` のファイルをこのように実行するだけです。
 
 
 ```bash
@@ -499,7 +499,7 @@ $ ./main  # あるいはWindowsならmain.exe
 
 <!-- If *main.rs* were your "Hello, world!" program, this would print `Hello, -->
 <!-- world!` to your terminal. -->
-もし *main.rs* が「Hello, world!」プログラムなら、これで`Hello, world!`とターミナルに印字することでしょう。
+もし *main.rs* が「Hello, world!」プログラムなら、これで `Hello, world!` とターミナルに印字することでしょう。
 
 <!-- If you come from a dynamic language like Ruby, Python, or JavaScript, you may -->
 <!-- not be used to compiling and running a program being separate steps. Rust is an -->
@@ -511,7 +511,7 @@ $ ./main  # あるいはWindowsならmain.exe
 <!-- is a tradeoff in language design. -->
 もしRubyやPython、JavaScriptなどの動的な言語から来たのならコンパイルと実行が別の手順になっていることに馴れないでしょう。
 Rustは、プログラムをコンパイルして、それを別の誰かに渡したら、Rustがなくても動く、 *事前コンパイル* 言語です。
-他方別の誰かに`.rb`や`.py`、`.js`を渡したら(それぞれ)Ruby、PythonあるいはJavaScriptの実装が必要になりますが、コンパイルにも実行にも1つのコマンドで事足ります。
+他方別の誰かに `.rb` や `.py` 、 `.js` を渡したら(それぞれ)Ruby、PythonあるいはJavaScriptの実装が必要になりますが、コンパイルにも実行にも1つのコマンドで事足ります。
 全ては言語設計上のトレードオフです。
 
 <!-- Just compiling with `rustc` is fine for simple programs, but as your project -->
@@ -519,7 +519,7 @@ Rustは、プログラムをコンパイルして、それを別の誰かに渡
 <!-- and make it easy to share your code with other people and projects. Next, I'll -->
 <!-- introduce you to a tool called Cargo, which will help you write real-world Rust -->
 <!-- programs. -->
-単純なプログラムなら単に`rustc`でコンパイルすれば十分ですがプロジェクトが大きくなるにつれてプロジェクトの全てのオプションを管理したり他の人やプロジェクトと容易に共有出来るようにしたくなるでしょう。
+単純なプログラムなら単に `rustc` でコンパイルすれば十分ですがプロジェクトが大きくなるにつれてプロジェクトの全てのオプションを管理したり他の人やプロジェクトと容易に共有出来るようにしたくなるでしょう。
 次は現実世界のRustプログラムを書く手助けになるCargoというツールを紹介します。
 
 <!-- # Hello, Cargo! -->
@@ -556,7 +556,7 @@ $ cargo --version
 <!-- Into a terminal. If you see a version number, great! If you see an error like -->
 <!-- ‘`command not found`’, then you should look at the documentation for the system -->
 <!-- in which you installed Rust, to determine if Cargo is separate. -->
-バージョン番号を確認出来たなら、良かった！「`コマンドが見つかりません`」などのエラーが出たなら
+バージョン番号を確認出来たなら、良かった！「 `コマンドが見つかりません` 」などのエラーが出たなら
 Rustをインストールしたシステムのドキュメントを見て、Cargoが別になっているか判断しましょう。
 
 <!-- ## Converting to Cargo -->
@@ -572,7 +572,7 @@ Hello WorldプログラムをCargoに変換しましょう。
 <!--    and make a new one. -->
 <!-- 3. Make a Cargo configuration file. -->
 1. ソースファイルを正しいディレクトリに置く
-2. 古い実行可能ファイル(Windowsなら`main.exe`、他では`main`)を消し、新しいものを作る
+2. 古い実行可能ファイル(Windowsなら `main.exe` 、他では `main`)を消し、新しいものを作る
 3. Cargoの設定ファイルを作る
 
 <!-- Let's get started! -->
@@ -604,15 +604,15 @@ READMEやライセンス情報、他のコードに関係ないものはプロ
 <!-- Now, copy *main.rs* to the *src* directory, and delete the compiled file you -->
 <!-- created with `rustc`. As usual, replace `main` with `main.exe` if you're on -->
 <!-- Windows. -->
-では、 *main.rs* を *src* ディレクトリにコピーして、`rustc`でコンパイルして作ったファイルを削除します。
-これまで通り、Windowsなら`main`を`main.exe`に読み替えて下さい。
+では、 *main.rs* を *src* ディレクトリにコピーして、 `rustc` でコンパイルして作ったファイルを削除します。
+これまで通り、Windowsなら `main` を `main.exe` に読み替えて下さい。
 
 <!-- This example retains `main.rs` as the source filename because it's creating an -->
 <!-- executable. If you wanted to make a library instead, you'd name the file -->
 <!-- `lib.rs`. This convention is used by Cargo to successfully compile your -->
 <!-- projects, but it can be overridden if you wish.  -->
-今回の例では実行可能ファイルを作るので`main.rs`の名前を引き続き使います。
-もしライブラリを作りたいなら`lib.rs`という名前にすることになります。
+今回の例では実行可能ファイルを作るので `main.rs` の名前を引き続き使います。
+もしライブラリを作りたいなら `lib.rs` という名前にすることになります。
 この規約はCargoでプロジェクトを正しくコンパイルするのに使われていますが、望むなら上書きすることも出来ます。
 
 <!-- ### Creating a Configuration File -->
@@ -620,11 +620,11 @@ READMEやライセンス情報、他のコードに関係ないものはプロ
 
 <!-- Next, create a new file inside your *hello_world* directory, and call it -->
 <!-- `Cargo.toml`. -->
-次に、 *hello_world* ディレクトリ下にファイルを作ります。それを`Cargo.toml`とします。
+次に、 *hello_world* ディレクトリ下にファイルを作ります。それを `Cargo.toml` とします。
 
 <!-- Make sure to capitalize the `C` in `Cargo.toml`, or Cargo won't know what to do -->
 <!-- with the configuration file.  -->
-ちゃんと`Cargo.toml`の`C`が大文字になっていることを確認しましょう、そうしないとCargoが設定ファイルと認識出来なくなります。
+ちゃんと `Cargo.toml` の `C` が大文字になっていることを確認しましょう、そうしないとCargoが設定ファイルと認識出来なくなります。
 
 <!-- This file is in the *[TOML]* (Tom's Obvious, Minimal Language) format. TOML is -->
 <!-- similar to INI, but has some extra goodies, and is used as Cargo’s -->
@@ -649,7 +649,7 @@ authors = [ "あなたの名前 <you@example.com>" ]
 <!-- The first line, `[package]`, indicates that the following statements are -->
 <!-- configuring a package. As we add more information to this file, we’ll add other -->
 <!-- sections, but for now, we just have the package configuration. -->
-最初の行、`[package]`は下に続く記述がパッケージの設定であることを示します。
+最初の行、 `[package]` は下に続く記述がパッケージの設定であることを示します。
 さらなる情報をこのファイルに追加する時には他のセクションを追加することになりますが、今のところパッケージの設定しかしていません。
 
 <!-- The other three lines set the three bits of configuration that Cargo needs to -->
@@ -677,12 +677,12 @@ Hello, world!
 ```
 
 <!-- Bam! If all goes well, `Hello, world!` should print to the terminal once more.  -->
-ババーン!全てが上手くいったら、もう一度`Hello, world!`がターミナルに印字される筈です。
+ババーン!全てが上手くいったら、もう一度 `Hello, world!` がターミナルに印字される筈です。
 
 <!-- You just built a project with `cargo build` and ran it with -->
 <!-- `./target/debug/hello_world`, but you can actually do both in one step with -->
 <!-- `cargo run` as follows: -->
-`cargo build`でプロジェクトをビルドして`./target/debug/hello_world`でそれを実行したのですが、実は次のように`cargo run`一発でそれらを実行出来ます。
+`cargo build` でプロジェクトをビルドして `./target/debug/hello_world` でそれを実行したのですが、実は次のように `cargo run` 一発でそれらを実行出来ます。
 
 ```bash
 $ cargo run
@@ -713,10 +713,10 @@ Cargoはプロジェクトのファイルのどれかが変更されていない
 <!-- but it will become useful in future. With complex projects composed of multiple -->
 <!-- crates, it’s much easier to let Cargo coordinate the build. With Cargo, you can -->
 <!-- just run `cargo build`, and it should work the right way. -->
-単純なプロジェクトではCargoを使っても単に`rustc`を使うのとさほど変わないでしょうが将来において役に立つでしょう。
+単純なプロジェクトではCargoを使っても単に `rustc` を使うのとさほど変わないでしょうが将来において役に立つでしょう。
 特に、クレートを使い始めた時によく当て嵌ります。
 複数のクレートで構成された複雑なプロジェクトではCargoにビルドを任せた方がとても簡単になります。
-Cargoを使えば`cargo build`を実行するだけで正しく動いてくれます。
+Cargoを使えば `cargo build` を実行するだけで正しく動いてくれます。
 
 <!-- ## Building for Release -->
 ## リリースビルド
@@ -726,7 +726,7 @@ Cargoを使えば`cargo build`を実行するだけで正しく動いてくれ
 <!-- your Rust code run faster, but turning them on makes your program take longer -->
 <!-- to compile. This is why there are two different profiles, one for development, -->
 <!-- and one for building the final program you’ll give to a user. -->
-最終的にプロジェクトのリリース準備が整ったら`cargo build --release`を使うことで最適化を掛けてプロジェクトをコンパイル出来ます。
+最終的にプロジェクトのリリース準備が整ったら `cargo build --release` を使うことで最適化を掛けてプロジェクトをコンパイル出来ます。
 最適化を掛けることでRustのコードは速くなりますが、コンパイル時間は長くなります。
 こういう訳で、開発向けとユーザへ配布する最終版プログラムを作る時向けの2つの違うプロファイルが存在するのです。
 
@@ -753,7 +753,7 @@ Cargoは *Cargo.lock* でアプリケーションの依存を追跡します。
 
 <!-- That’s it! If you've been following along, you should have successfully built -->
 <!-- `hello_world` with Cargo.  -->
-出来ました!ここまでついて来たならCargoで`hello_world`をビルドする所まで出来た筈です。
+出来ました!ここまでついて来たならCargoで `hello_world` をビルドする所まで出来た筈です。
 
 <!-- Even though the project is simple, it now uses much of the real tooling you’ll -->
 <!-- use for the rest of your Rust career. In fact, you can expect to start -->
@@ -777,7 +777,7 @@ $ cargo build
 Cargoで即座に開発を始められる骨組だけのプロジェクトを素早く作ることが出来ます。
 
 <!-- To start a new project with Cargo, enter `cargo new` at the command line: -->
-Cargoで新たなプロジェクトを始めるには、`cargo new`をコマンドラインに入力します。
+Cargoで新たなプロジェクトを始めるには、 `cargo new` をコマンドラインに入力します。
 
 ```bash
 $ cargo new hello_world --bin
@@ -786,18 +786,18 @@ $ cargo new hello_world --bin
 <!-- This command passes `--bin` because the goal is to get straight to making an -->
 <!-- executable application, as opposed to a library. Executables are often called -->
 <!-- *binaries* (as in `/usr/bin`, if you’re on a Unix system). -->
-ライブラリではなく実行可能アプリケーションを作りたいのでこのコマンドは`--bin`を渡しています。
-実行可能ファイルはよく *バイナリ* と呼ばれます(なのでUnixシステムでは`/usr/bin/`に入っています)。
+ライブラリではなく実行可能アプリケーションを作りたいのでこのコマンドは `--bin` を渡しています。
+実行可能ファイルはよく *バイナリ* と呼ばれます(なのでUnixシステムでは `/usr/bin/` に入っています)。
 
 <!-- Cargo has generated two files and one directory for us: a `Cargo.toml` and a -->
 <!-- *src* directory with a *main.rs* file inside. These should look familliar, -->
 <!-- they’re exactly what we created by hand, above. -->
-Cargoは2つのファイルと1つのディレクトリ、`Cargo.toml`と *main.rs* の入った *src* ディレクトリを生成します。
+Cargoは2つのファイルと1つのディレクトリ、 `Cargo.toml` と *main.rs* の入った *src* ディレクトリを生成します。
 上で作ったのと全く同じ、見たことのある構成ですね。
 
 <!-- This output is all you need to get started. First, open `Cargo.toml`. It should -->
 <!-- look something like this: -->
-これさえあれば始められます。まず、`Cargo.toml`を開きます。このようになっている筈です。
+これさえあれば始められます。まず、 `Cargo.toml` を開きます。このようになっている筈です。
 
 ```toml
 [package]
@@ -810,11 +810,11 @@ authors = ["あなたの名前 <you@example.com>"]
 <!-- Cargo has populated *Cargo.toml* with reasonable defaults based on the arguments -->
 <!-- you gave it and your `git` global configuration. You may notice that Cargo has -->
 <!-- also initialized the `hello_world` directory as a `git` repository. -->
-Cargoは引数と`git`の設定を基に *Cargo.toml* に適当な値を埋めます。
-Cargoが`hello_world`ディレクトリを`git`レポジトリとして初期化していることにも気付くでしょう。
+Cargoは引数と `git` の設定を基に *Cargo.toml* に適当な値を埋めます。
+Cargoが `hello_world` ディレクトリを `git` レポジトリとして初期化していることにも気付くでしょう。
 
 <!-- Here’s what should be in `src/main.rs`: -->
-`src/main.rs`の中身はこのようになっている筈です。
+`src/main.rs` の中身はこのようになっている筈です。
 
 ```rust
 fn main() {
diff --git a/1.6/ja/book/glossary.md b/1.6/ja/book/glossary.md
index d71ca264..6093665a 100644
--- a/1.6/ja/book/glossary.md
+++ b/1.6/ja/book/glossary.md
@@ -63,7 +63,7 @@ A type without a statically known size or alignment. ([more info][link])
 <!-- that expressions can have side-effects. For example, a function included in an -->
 <!-- expression might perform actions other than simply returning a value. -->
 コンピュータプログラミングに於いて、式は値、定数、変数、演算子、1つの値へと評価される関数の組み合わせです。
-例えば、`2 + (3 * 4)`は値14を返す式です。式が副作用を持ちうることに意味はありません。
+例えば、 `2 + (3 * 4)` は値14を返す式です。式が副作用を持ちうることに意味はありません。
 例えば、ある式に含まれる関数がただ値を返す以外にも何か作用をするかもしれません。
 
 
diff --git a/1.6/ja/book/guessing-game.md b/1.6/ja/book/guessing-game.md
index 7c52e2ce..f9982be3 100644
--- a/1.6/ja/book/guessing-game.md
+++ b/1.6/ja/book/guessing-game.md
@@ -20,7 +20,7 @@
 <!-- to create our directory structure and a `Cargo.toml` for `hello_world`? Cargo -->
 <!-- has a command that does that for us. Let’s give it a shot: -->
 新しいプロジェクトを作りましょう。プロジェクトのディレクトリへ行って下さい。
-`hello_world`の時にどのようなディレクトリ構成で、どのように`Cargo.toml`を作る必要があったか覚えてますか?
+`hello_world` の時にどのようなディレクトリ構成で、どのように `Cargo.toml` を作る必要があったか覚えてますか?
 Cargoにはそれらのことをしてくれるコマンドがあるのでした。使いましょう。
 
 ```bash
@@ -31,10 +31,10 @@ $ cd guessing_game
 
 <!-- We pass the name of our project to `cargo new`, and then the `--bin` flag, -->
 <!-- since we’re making a binary, rather than a library. -->
-`cargo new`にプロジェクトの名前と、そしてライブラリではなくバイナリを作るので`--bin`フラグを渡します。
+`cargo new` にプロジェクトの名前と、そしてライブラリではなくバイナリを作るので `--bin` フラグを渡します。
 
 <!-- Check out the generated `Cargo.toml`: -->
-生成された`Cargo.toml`を確認しましょう。
+生成された `Cargo.toml` を確認しましょう。
 
 ```toml
 [package]
@@ -50,7 +50,7 @@ Cargoはこれらの情報を環境から取得します。もし合ってなか
 
 
 <!-- Finally, Cargo generated a ‘Hello, world!’ for us. Check out `src/main.rs`: -->
-最後に、Cargoは「Hello, world!」を生成します。`src/main.rs`を確認しましょう。
+最後に、Cargoは「Hello, world!」を生成します。 `src/main.rs` を確認しましょう。
 
 
 ```rust
@@ -70,14 +70,14 @@ $ cargo build
 
 <!-- Excellent! Open up your `src/main.rs` again. We’ll be writing all of -->
 <!-- our code in this file. -->
-素晴しい!もう一度`src/main.rs`を開きましょう。全てのコードをこの中に書いていきます。
+素晴しい!もう一度 `src/main.rs` を開きましょう。全てのコードをこの中に書いていきます。
 
 
 <!-- Before we move on, let me show you one more Cargo command: `run`. `cargo run` -->
 <!-- is kind of like `cargo build`, but it also then runs the produced executable. -->
 <!-- Try it out: -->
-行動する前に、もう一つCargoのコマンドを紹介させて下さい。`run`です。
-`cargo run`は`cargo build`のようなものですが、生成された実行可能ファイルの実行までします。
+行動する前に、もう一つCargoのコマンドを紹介させて下さい。 `run` です。
+`cargo run` は `cargo build` のようなものですが、生成された実行可能ファイルの実行までします。
 試してみましょう。
 
 ```bash
@@ -90,7 +90,7 @@ Hello, world!
 <!-- Great! The `run` command comes in handy when you need to rapidly iterate on a -->
 <!-- project. Our game is such a project, we need to quickly test each -->
 <!-- iteration before moving on to the next one. -->
-すごい! `run`コマンドはプロジェクトを細かく回す必要があるときに手頃でしょう。
+すごい! `run` コマンドはプロジェクトを細かく回す必要があるときに手頃でしょう。
 今回のゲームがまさにそのようなプロジェクトです。すぐに試してから次の行動に移るの繰り返しをする必要があります。
 
 <!-- # Processing a Guess -->
@@ -100,7 +100,7 @@ Hello, world!
 <!-- allow our player to input a guess. Put this in your `src/main.rs`: -->
 とりかかりましょう!
 数当てゲームでまずしなければいけないことはプレイヤーに予想値を入力させることです。
-これを`src/main.rs`に書きましょう。
+これを `src/main.rs` に書きましょう。
 
 
 ```rust,no_run
@@ -145,10 +145,10 @@ use std::io;
 <!-- [`io` prelude][ioprelude], which serves a similar function: you import it, and it -->
 <!-- imports a number of useful, `io`-related things. -->
 ユーザの入力を取得して結果を出力する必要があります。
-なので`io`標準ライブラリからライブラリが必要になります。
+なので `io` 標準ライブラリからライブラリが必要になります。
 Rustが全てのプログラムにデフォルトで読み込むものは少しだけで、[「プレリュード」][prelude]といいます。
-プレリュードになければ、直接`use`しなければいけません。
-2つめの「プレリュード」、[`io`プレリュード][ioprelude]もあり、同様にそれをインポートすると`io`に関連した多数の有用なものがインポートされます。
+プレリュードになければ、直接 `use` しなければいけません。
+2つめの「プレリュード」、[`io` プレリュード][ioprelude]もあり、同様にそれをインポートすると `io` に関連した多数の有用なものがインポートされます。
 
 
 [prelude]: ../std/prelude/index.html
@@ -163,9 +163,9 @@ fn main() {
 <!-- there are no arguments, and `{` starts the body of the function. Because -->
 <!-- we didn’t include a return type, it’s assumed to be `()`, an empty -->
 <!-- [tuple][tuples]. -->
-以前見たように`main()`関数がプログラムのエントリーポイントになります。
-`fn`構文で新たな関数を宣言し、`()`が引数がないことを示し、`{`が関数の本体部の始まりです。
-返り値の型は書いていないので`()`、空の[タプル][tuples]として扱われます。
+以前見たように `main()` 関数がプログラムのエントリーポイントになります。
+`fn` 構文で新たな関数を宣言し、 `()` が引数がないことを示し、 `{` が関数の本体部の始まりです。
+返り値の型は書いていないので `()` 、空の[タプル][tuples]として扱われます。
 
 
 [tuples]: primitive-types.html#tuples
@@ -178,7 +178,7 @@ fn main() {
 
 <!-- We previously learned that `println!()` is a [macro][macros] that -->
 <!-- prints a [string][strings] to the screen. -->
-前に`println!()`が[文字列][strings]をスクリーンに印字する[マクロ][macros]であることを学びました。
+前に `println!()` が[文字列][strings]をスクリーンに印字する[マクロ][macros]であることを学びました。
 
 [macros]: macros.html
 [strings]: strings.html
@@ -204,7 +204,7 @@ let foo = bar;
 <!-- This will create a new binding named `foo`, and bind it to the value `bar`. In -->
 <!-- many languages, this is called a ‘variable’, but Rust’s variable bindings have -->
 <!-- a few tricks up their sleeves. -->
-これは`foo`という名前の束縛を作り、それを値`bar`に束縛します。
+これは `foo` という名前の束縛を作り、それを値 `bar` に束縛します。
 多くの言語ではこれは「変数」と呼ばれるものですが、Rustの変数束縛は少しばかり皮を被せてあります。
 
 <!-- For example, they’re [immutable][immutable] by default. That’s why our example -->
@@ -213,8 +213,8 @@ let foo = bar;
 <!-- ‘[pattern][patterns]’. We’ll use patterns later. It’s easy enough -->
 <!-- to use for now: -->
 例えば、束縛はデフォルトで[イミュータブル][immutable] (不変)です。
-なので、この例ではイミュータブルではなくミュータブル(可変)な束縛にするために`mut`を使っているのです。
-`let`は代入の左辺に名前を取る訳ではなくて実際には[パターン][patterns]を受け取ります。
+なので、この例ではイミュータブルではなくミュータブル(可変)な束縛にするために `mut` を使っているのです。
+`let` は代入の左辺に名前を取る訳ではなくて実際には[パターン][patterns]を受け取ります。
 後程パターンを使います。簡単なのでもう使えますね。
 
 ```rust
@@ -227,19 +227,19 @@ let mut bar = 5; // ミュータブル
 
 <!-- Oh, and `//` will start a comment, until the end of the line. Rust ignores -->
 <!-- everything in [comments][comments]. -->
-ああ、そして`//`から行末までがコメントです。Rustは[コメント][comments]にある全てのものを無視します。
+ああ、そして `//` から行末までがコメントです。Rustは[コメント][comments]にある全てのものを無視します。
 
 [comments]: comments.html
 
 <!-- So now we know that `let mut guess` will introduce a mutable binding named -->
 <!-- `guess`, but we have to look at the other side of the `=` for what it’s -->
 <!-- bound to: `String::new()`. -->
-という訳で`let mut guess`がミュータブルな束縛`guess`を導入することを知りました。
-しかし`=`の反対側、`String::new()`が何であるかを見る必要があります。
+という訳で `let mut guess` がミュータブルな束縛 `guess` を導入することを知りました。
+しかし `=` の反対側、 `String::new()` が何であるかを見る必要があります。
 
 <!-- `String` is a string type, provided by the standard library. A -->
 <!-- [`String`][string] is a growable, UTF-8 encoded bit of text. -->
-`String`は文字列型で、標準ライブラリで提供されています。
+`String` は文字列型で、標準ライブラリで提供されています。
 [`String`][string]は伸長可能でUTF-8でエンコードされたテキスト片です。
 
 [string]: ../std/string/struct.String.html
@@ -248,15 +248,15 @@ let mut bar = 5; // ミュータブル
 <!-- a particular type. That is to say, it’s associated with `String` itself, -->
 <!-- rather than a particular instance of a `String`. Some languages call this a -->
 <!-- ‘static method’. -->
-`::new()`構文は特定の型の「関連関数」なので`::`構文を使っています。
-つまり、これは`String`のインスタンスではなく`String`自体に関連付けられているということです。
+`::new()` 構文は特定の型の「関連関数」なので `::` 構文を使っています。
+つまり、これは `String` のインスタンスではなく `String` 自体に関連付けられているということです。
 これを「スタティックメソッド」と呼ぶ言語もあります。
 
 <!-- This function is named `new()`, because it creates a new, empty `String`. -->
 <!-- You’ll find a `new()` function on many types, as it’s a common name for making -->
 <!-- a new value of some kind. -->
-この関数は新たな空の`String`を作るので`new()`の名付けられています。
-`new()`関数はある種の新たな値を作るのによく使われる名前なので様々な型でこの関数を見るでしょう。
+この関数は新たな空の `String` を作るので `new()` の名付けられています。
+`new()` 関数はある種の新たな値を作るのによく使われる名前なので様々な型でこの関数を見るでしょう。
 
 
 <!-- Let’s move forward: -->
@@ -279,8 +279,8 @@ io::stdin()
 <!-- Remember how we `use`d `std::io` on the first line of the program? We’re now -->
 <!-- calling an associated function on it. If we didn’t `use std::io`, we could -->
 <!-- have written this line as `std::io::stdin()`. -->
-プログラムの最初の行でどのように`std::io`を`use`したかを覚えていますか?
-それの関連関数を呼び出しているのです。`use std::io`していないなら`std::io::stdin()`と書くことになります。
+プログラムの最初の行でどのように `std::io` を `use` したかを覚えていますか?
+それの関連関数を呼び出しているのです。 `use std::io` していないなら `std::io::stdin()` と書くことになります。
 
 <!-- This particular function returns a handle to the standard input for your -->
 <!-- terminal. More specifically, a [std::io::Stdin][iostdin]. -->
@@ -301,7 +301,7 @@ io::stdin()
 <!-- one argument to `read_line()`: `&mut guess`. -->
 ここで、ハンドルに対して[`read_line()`][read_line]メソッドを呼んでいます。
 [メソッド][method]は関連関数のようなものですが、型自体ではなくインスタンスに対してだけ使えます。
-`read_line()`に1つ引数を渡してもいます。`&mut guess`です。
+`read_line()` に1つ引数を渡してもいます。 `&mut guess` です。
 
 [read_line]: ../std/io/struct.Stdin.html#method.read_line
 [method]: method-syntax.html
@@ -315,20 +315,20 @@ io::stdin()
 <!-- finish our program right now, though. For now, all we need to know is that -->
 <!-- like `let` bindings, references are immutable by default. Hence, we need to -->
 <!-- write `&mut guess`, rather than `&guess`. -->
-`guess`がどのように束縛されたか覚えてますか?ミュータブルであると言いました。
-しかしながら`read_line`は`String`を引数に取りません。`&mut String`を取るのです。
+`guess` がどのように束縛されたか覚えてますか?ミュータブルであると言いました。
+しかしながら `read_line` は `String` を引数に取りません。 `&mut String` を取るのです。
 Rustには[参照][references]と呼ばれる機能があって、1つのデータに対して複数の参照を持つことが出来、コピーを減らすことが出来ます。
 Rustの主要な売りの1つが参照をいかに安全に簡単に使えるかなので、参照は複雑な機能です。
 しかしこのプログラムを作り終えるのに今すぐ詳細を知る必要はありません。
-今のところ、`let`と同じように参照はデフォルトでイミュータブルであるということだけ覚えておいて下さい。
-なので`&guess`ではなく`&mut guess`と書く必要があるのです。
+今のところ、 `let` と同じように参照はデフォルトでイミュータブルであるということだけ覚えておいて下さい。
+なので `&guess` ではなく `&mut guess` と書く必要があるのです。
 
 <!-- Why does `read_line()` take a mutable reference to a string? Its job is -->
 <!-- to take what the user types into standard input, and place that into a -->
 <!-- string. So it takes that string as an argument, and in order to add -->
 <!-- the input, it needs to be mutable. -->
-何故`read_line()`は文字列へのミュータブルな参照を取るのでしょうか?
-`read_line()`はユーザが標準入力に打ったものを取得し、それを文字列に入れる役割を果たします。
+何故 `read_line()` は文字列へのミュータブルな参照を取るのでしょうか?
+`read_line()` はユーザが標準入力に打ったものを取得し、それを文字列に入れる役割を果たします。
 なのでその文字列を引数として受け取り、そして入力文字列を追加するために文字列はミュータブルである必要があるのです。
 
 [references]: references-and-borrowing.html
@@ -345,7 +345,7 @@ Rustの主要な売りの1つが参照をいかに安全に簡単に使えるか
 <!-- When you call a method with the `.foo()` syntax, you may introduce a newline -->
 <!-- and other whitespace. This helps you split up long lines. We _could_ have -->
 <!-- done: -->
-メソッドを`.foo()`構文で呼び出す時、改行してスペースを入れても構いません。
+メソッドを `.foo()` 構文で呼び出す時、改行してスペースを入れても構いません。
 そうすることで長い行を分割出来ます。
 こうすることだって _出来ました_
 
@@ -361,10 +361,10 @@ Rustの主要な売りの1つが参照をいかに安全に簡単に使えるか
 <!-- standard library: a generic [`Result`][result], and then specific versions for -->
 <!-- sub-libraries, like `io::Result`. -->
 ですがこれだと読み辛いです。ですので3つのメソッド呼び出しを3行に分割します。
-`read_line()`については話しましたが`expect`についてはどうでしょう?
-さて、`read_line()`がユーザの入力を`&mut String`に入れることには言及しました。
+`read_line()` については話しましたが `expect` についてはどうでしょう?
+さて、 `read_line()` がユーザの入力を `&mut String` に入れることには言及しました。
 しかし値も返します。
-この場合、標準ライブラリにある汎用の[`Result`][result]であり、そしてそれをサブライブラリに特殊化したバージョンの`io::Result`になります。
+この場合、標準ライブラリにある汎用の[`Result`][result]であり、そしてそれをサブライブラリに特殊化したバージョンの `io::Result` になります。
 
 [ioresult]: ../std/io/type.Result.html
 [result]: ../std/result/enum.Result.html
@@ -375,10 +375,10 @@ Rustの主要な売りの1つが参照をいかに安全に簡単に使えるか
 <!-- it’s called on, and if it isn’t a successful one, [`panic!`][panic]s with a -->
 <!-- message you passed it. A `panic!` like this will cause our program to crash, -->
 <!-- displaying the message. -->
-これらの`Result`型の目的は、エラーハンドリング情報をエンコードすることです。
-`Result`型の値には、他の型と同じように、メソッドが定義されています。
-今回は`io::Result`に[`expect()`メソッド][expect]が定義されていて、それが呼び出された値が成功でなければ与えたメッセージと共に[`panic!`][panic]します。
-このような`panic!`はメッセージを表示してプログラムをクラッシュさせます。
+これらの `Result` 型の目的は、エラーハンドリング情報をエンコードすることです。
+`Result` 型の値には、他の型と同じように、メソッドが定義されています。
+今回は `io::Result` に[`expect()`メソッド][expect]が定義されていて、それが呼び出された値が成功でなければ与えたメッセージと共に[`panic!`][panic]します。
+このような `panic!` はメッセージを表示してプログラムをクラッシュさせます。
 
 [expect]: ../std/option/enum.Option.html#method.expect
 [panic]: error-handling.html
@@ -403,7 +403,7 @@ src/main.rs:10     io::stdin().read_line(&mut guess);
 <!-- a problem, we can use these two little methods. If we can recover from the -->
 <!-- error somehow, we’d do something else, but we’ll save that for a future -->
 <!-- project. -->
-Rustは値`Result`を使っていないことを警告します。警告は`io::Result`が持つ特別なアノテーションに由来します。
+Rustは値 `Result` を使っていないことを警告します。警告は `io::Result` が持つ特別なアノテーションに由来します。
 Rustはエラーの可能性があるのに処理していないことを教えてくれるのです。
 エラーを出さないためには実際にエラー処理を書くのが正しやり方です。
 幸運にも、問題があった時にそのままクラッシュさせたいならこの小さな2つのメソッドをそのまま使えます。
@@ -421,8 +421,8 @@ Rustはエラーの可能性があるのに処理していないことを教え
 <!-- This prints out the string we saved our input in. The `{}`s are a placeholder, -->
 <!-- and so we pass it `guess` as an argument. If we had multiple `{}`s, we would -->
 <!-- pass multiple arguments: -->
-これは入力を保持している文字列を印字します。`{}`はプレースホルダで、引数として`guess`を渡しています。
-複数の`{}`があれば、複数を引数を渡すことになります。
+これは入力を保持している文字列を印字します。 `{}` はプレースホルダで、引数として `guess` を渡しています。
+複数の `{}` があれば、複数を引数を渡すことになります。
 
 ```rust
 let x = 5;
@@ -435,7 +435,7 @@ println!("x and y: {} and {}", x, y);
 簡単簡単。
 
 <!-- Anyway, that’s the tour. We can run what we have with `cargo run`: -->
-いずれにせよ、一巡り終えました。これまでのものを`cargo run`で実行出来ます。
+いずれにせよ、一巡り終えました。これまでのものを `cargo run` で実行出来ます。
 
 ```bash
 $ cargo run
@@ -461,17 +461,17 @@ You guessed: 6
 <!-- ‘library crate’, which contains code that’s intended to be used with other -->
 <!-- programs. -->
 次に、秘密の数を生成する必要があります。Rustの標準ライブラリには乱数の機能がまだありません。
-ですが、Rustチームは[`rand`クレート][randcrate]を提供します。
+ですが、Rustチームは[`rand` クレート][randcrate]を提供します。
 「クレート」はRustのコードのパッケージです。今まで作ってきたのは実行可能な「バイナリクレート」です。
-`rand`は「ライブラリクレート」で、他のプログラムから使われることを意図したコードが入っています。
+`rand` は「ライブラリクレート」で、他のプログラムから使われることを意図したコードが入っています。
 
 [randcrate]: https://crates.io/crates/rand
 
 <!-- Using external crates is where Cargo really shines. Before we can write -->
 <!-- the code using `rand`, we need to modify our `Cargo.toml`. Open it up, and -->
 <!-- add these few lines at the bottom: -->
-外部のクレートを使う時にこそCargoが光ります。`rand`を使う前に`Cargo.toml`を修正する必要があります。
-`Cargo.toml`を開いて、この数行を末尾に追記しましょう。
+外部のクレートを使う時にこそCargoが光ります。 `rand` を使う前に `Cargo.toml` を修正する必要があります。
+`Cargo.toml` を開いて、この数行を末尾に追記しましょう。
 
 ```toml
 [dependencies]
@@ -492,14 +492,14 @@ rand="0.3.0"
 <!-- And if we wanted to use the latest version we could use `*`. -->
 <!-- We could also use a range of versions. -->
 <!-- [Cargo’s documentation][cargodoc] contains more details. -->
-`Cargo.toml`の`[dependencies]`(訳注: 依存)セクションは`[package]`セクションに似ています。
+`Cargo.toml` の `[dependencies]` (訳注: 依存)セクションは `[package]` セクションに似ています。
 後続の行は次のセクションが始まるまでそのセクションに属します。
 Cargoはどの外部クレートのどのバージョンに依存するのかの情報を取得するのにdependenciesセクションを使います。
 今回のケースではバージョン`0.3.0`を指定していますが、Cargoは指定されたバージョンと互換性のあるバージョンを理解します。
 Cargoはバージョン記述の標準、[セマンティックバージョニング][semver]を理解します。
-上記のようなそのままのバージョンは`^0.3.0`の略記で、「0.3.0と互換性のあるもの」という意味です。
-正確に`0.3.0`だけを使いたいなら`rand="=0.3.0"`(等号が2つあることに注意して下さい)と書きます。
-そして最新版を使いたいなら`*`を使います。また、バージョンの範囲を使うことも出来ます。
+上記のようなそのままのバージョンは `^0.3.0` の略記で、「0.3.0と互換性のあるもの」という意味です。
+正確に `0.3.0` だけを使いたいなら `rand="=0.3.0"` (等号が2つあることに注意して下さい)と書きます。
+そして最新版を使いたいなら `*` を使います。また、バージョンの範囲を使うことも出来ます。
 [Cargoのドキュメント][cargodoc]にさらなる詳細があります。
 
 [semver]: http://semver.org
@@ -536,12 +536,12 @@ Crates.ioはRustのエコシステムに居る人が他人が使うためにオ
 <!-- `rand`, we’ve also grabbed a copy of `libc`. This is because `rand` depends on -->
 <!-- `libc` to work. After downloading them, it compiles them, and then compiles -->
 <!-- our project. -->
-レジストリをアップデートした後にCargoは`[dependencies]`を確認し、まだダウンロードしていないものをダウンロードします。
-今回のケースでは`rand`に依存するとだけ書いてますが`libc`も取得されています。これは`rand`が動作するのに`libc`に依存するためです。
+レジストリをアップデートした後にCargoは `[dependencies]` を確認し、まだダウンロードしていないものをダウンロードします。
+今回のケースでは `rand` に依存するとだけ書いてますが `libc` も取得されています。これは `rand` が動作するのに `libc` に依存するためです。
 これらのダウンロードが終わったら、それらのコンパイル、そしてプロジェクトのコンパイルをします。
 
 <!-- If we run `cargo build` again, we’ll get different output: -->
-もう一度`cargo build`を走らせると、異なった出力になります。
+もう一度 `cargo build` を走らせると、異なった出力になります。
 
 ```bash
 $ cargo build
@@ -552,7 +552,7 @@ $ cargo build
 <!-- stuff. With nothing to do, it simply exits. If we open up `src/main.rs` again, -->
 <!-- make a trivial change, and then save it again, we’ll just see one line: -->
 そうです、何も出力がありません!Cargoはプロジェクトがビルドされていて、依存もビルドされていることを知っているのでそれらのことをする必要がないのです。
-何もすることがなければそのまま終了します。もし`src/main.rs`を少し変更して保存したら、次のような行を目にするはずです。
+何もすることがなければそのまま終了します。もし `src/main.rs` を少し変更して保存したら、次のような行を目にするはずです。
 
 ```bash
 $ cargo build
@@ -564,9 +564,9 @@ $ cargo build
 <!-- week, version `v0.3.9` comes out, with an important bugfix? While getting -->
 <!-- bugfixes is important, what if `0.3.9` contains a regression that breaks our -->
 <!-- code? -->
-Cargoには`rand`の`0.3.x`を使うと伝えたので、それが書かれた時点での最新版、`v0.3.8`を取得しました。
-ですが来週`v0.3.9`が出て、重要なバグフィクスがされたらどうなるのでしょう?
-バグフィクスを取り込むのは重要ですが、`0.3.9`にコードが動かなくなるようなリグレッションがあったらどうしましょう?
+Cargoには `rand` の `0.3.x` を使うと伝えたので、それが書かれた時点での最新版、 `v0.3.8` を取得しました。
+ですが来週 `v0.3.9` が出て、重要なバグフィクスがされたらどうなるのでしょう?
+バグフィクスを取り込むのは重要ですが、 `0.3.9` にコードが動かなくなるようなリグレッションがあったらどうしましょう?
 
 <!-- The answer to this problem is the `Cargo.lock` file you’ll now find in your -->
 <!-- project directory. When you build your project for the first time, Cargo -->
@@ -577,11 +577,11 @@ Cargoには`rand`の`0.3.x`を使うと伝えたので、それが書かれた
 <!-- have a repeatable build automatically. In other words, we’ll stay at `0.3.8` -->
 <!-- until we explicitly upgrade, and so will anyone who we share our code with, -->
 <!-- thanks to the lock file. -->
-この問題への回答はプロジェクトのディレクトリにある`Cargo.lock`です。
-プロジェクトを最初にビルドした時に、Cargoは基準を満たす全てのバージョンを探索し、`Cargo.lock`ファイルに書き出します。
-その後のビルドではCargoはまず`Cargo.lock`ファイルがあるか確認し、再度バージョンを探索することなく、そこで指定されたバージョンを使います。
+この問題への回答はプロジェクトのディレクトリにある `Cargo.lock` です。
+プロジェクトを最初にビルドした時に、Cargoは基準を満たす全てのバージョンを探索し、 `Cargo.lock` ファイルに書き出します。
+その後のビルドではCargoはまず `Cargo.lock` ファイルがあるか確認し、再度バージョンを探索することなく、そこで指定されたバージョンを使います。
 これで自動的に再現性のあるビルドが手に入ります。
-言い換えると、明示的にアップグレードしない限り我々は`0.3.8`を使い続けますし、ロックファイルのおかげでコードを共有する人も`0.3.8`を使い続けます。
+言い換えると、明示的にアップグレードしない限り我々は `0.3.8` を使い続けますし、ロックファイルのおかげでコードを共有する人も `0.3.8` を使い続けます。
 
 <!-- What about when we _do_ want to use `v0.3.9`? Cargo has another command, -->
 <!-- `update`, which says ‘ignore the lock, figure out all the latest versions that -->
@@ -590,11 +590,11 @@ Cargoには`rand`の`0.3.x`を使うと伝えたので、それが書かれた
 <!-- and smaller than `0.4.0`. If we want to move to `0.4.x`, we’d have to update -->
 <!-- the `Cargo.toml` directly. When we do, the next time we `cargo build`, Cargo -->
 <!-- will update the index and re-evaluate our `rand` requirements. -->
-`v0.3.9`を使いたい時はどうすればいいのでしょうか?
-Cargoには「ロックを無視して、指定したバージョンを満たす全ての最新版を探しなさい。もし出来たらそれをロックファイルに書きなさい」を意味する別のコマンド、`update`があります。
-しかし、デフォルトではCargoは`0.3.0`より大きく、`0.4.0`より小さいバージョンを探しにいきます。
-`0.4.x`より大きなバージョンを使いたいなら直接`Cargo.toml`を更新する必要があります。
-そうしたら、次に`cargo build`をする時に、Cargoはインデックスをアップデートして`rand`への制約を再度評価します。
+`v0.3.9` を使いたい時はどうすればいいのでしょうか?
+Cargoには「ロックを無視して、指定したバージョンを満たす全ての最新版を探しなさい。もし出来たらそれをロックファイルに書きなさい」を意味する別のコマンド、 `update` があります。
+しかし、デフォルトではCargoは `0.3.0` より大きく、 `0.4.0` より小さいバージョンを探しにいきます。
+`0.4.x` より大きなバージョンを使いたいなら直接 `Cargo.toml` を更新する必要があります。
+そうしたら、次に `cargo build` をする時に、Cargoはインデックスをアップデートして `rand` への制約を再度評価します。
 
 <!-- There’s a lot more to say about [Cargo][doccargo] and [its -->
 <!-- ecosystem][doccratesio], but for now, that’s all we need to know. Cargo makes -->
@@ -607,7 +607,7 @@ Cargoのお陰でライブラリの再利用は本当に簡単になりますし
 [doccratesio]: http://doc.crates.io/crates-io.html
 
 <!-- Let’s get on to actually _using_ `rand`. Here’s our next step: -->
-`rand`を実際に _使う_ ところに進みましょう。次のステップはこれです。
+`rand` を実際に _使う_ ところに進みましょう。次のステップはこれです。
 
 ```rust,ignore
 extern crate rand;
@@ -645,17 +645,17 @@ fn main() {
 <!-- can use `extern crate` to let Rust know we’ll be making use of it. This also -->
 <!-- does the equivalent of a `use rand;` as well, so we can make use of anything -->
 <!-- in the `rand` crate by prefixing it with `rand::`. -->
-まず最初に変更したのは最初の行です。`extern crate rand`となっています。
-`rand`を`[dependencies]`に宣言したので、`extern crate`でそれを使うことをRustに伝えれます。
-これはまた、`use rand;`とするのと同じこともしますので、`rand`にあるものは`rand::`と前置すれば使えるようになります。
+まず最初に変更したのは最初の行です。 `extern crate rand` となっています。
+`rand` を `[dependencies]` に宣言したので、 `extern crate` でそれを使うことをRustに伝えれます。
+これはまた、 `use rand;` とするのと同じこともしますので、 `rand` にあるものは `rand::` と前置すれば使えるようになります。
 
 <!-- Next, we added another `use` line: `use rand::Rng`. We’re going to use a -->
 <!-- method in a moment, and it requires that `Rng` be in scope to work. The basic -->
 <!-- idea is this: methods are defined on something called ‘traits’, and for the -->
 <!-- method to work, it needs the trait to be in scope. For more about the -->
 <!-- details, read the [traits][traits] section. -->
-次に、もう1行`use`を追加しました。`use rand::Rng`です。
-すぐに、とあるメソッドを使うのですが、それが動作するには`Rng`がスコープに入っている必要があるのです。
+次に、もう1行 `use` を追加しました。 `use rand::Rng` です。
+すぐに、とあるメソッドを使うのですが、それが動作するには `Rng` がスコープに入っている必要があるのです。
 基本的な考え方はこうです: メソッドは「トレイト」と呼ばれるのもで定義されており、メソッドが動作するにはそのトレイトがスコープにある必要があるのです。
 詳しくは[トレイト][traits]セクションを読んで下さい。
 
@@ -676,10 +676,10 @@ fn main() {
 <!-- available. This method takes two arguments, and generates a number between -->
 <!-- them. It’s inclusive on the lower bound, but exclusive on the upper bound, -->
 <!-- so we need `1` and `101` to get a number ranging from one to a hundred. -->
-`rand::thread_rng()`を使って現在いる[スレッド][concurrency]にローカルな乱数生成器のコピーを取得しています。
-上で`use rand::Rnd`したので生成器は`gen_range()`メソッドを使えます。
+`rand::thread_rng()` を使って現在いる[スレッド][concurrency]にローカルな乱数生成器のコピーを取得しています。
+上で `use rand::Rnd` したので生成器は `gen_range()` メソッドを使えます。
 このメソッドは2つの引数を取り、それらの間にある数を生成します。
-下限は含みますが、上限は含まないので1から100までの数を生成するには`1`と`101`を渡す必要があります。
+下限は含みますが、上限は含まないので1から100までの数を生成するには `1` と `101` を渡す必要があります。
 
 [concurrency]: concurrency.html
 
@@ -766,7 +766,7 @@ fn main() {
 <!-- A few new bits here. The first is another `use`. We bring a type called -->
 <!-- `std::cmp::Ordering` into scope. Then, five new lines at the bottom that use -->
 <!-- it: -->
-いくか新しいことがあります。まず、新たに`use`が増えました。`std::cmp::Ordering`をスコープに導入します。
+いくか新しいことがあります。まず、新たに `use` が増えました。 `std::cmp::Ordering` をスコープに導入します。
 そして、末尾にそれを使うコードが5行増えてます。
 
 
@@ -783,10 +783,10 @@ match guess.cmp(&secret_number) {
 <!-- `Ordering` type we `use`d earlier. We use a [`match`][match] statement to -->
 <!-- determine exactly what kind of `Ordering` it is. `Ordering` is an -->
 <!-- [`enum`][enum], short for ‘enumeration’, which looks like this: -->
-`cmp()`は比較可能なものに対しならなんでも呼べて、引数に比較したい対象の参照を取ります。
-`cmp()`は先程`use`した`Ordering`を返します。
-[`match`][match]文を使って正確に`Ordering`のどれであるかを判断しています。
-`Ordering`は[`enum`][enum] (訳注: 列挙型)で、enumは「enumeration(訳注: 列挙)」の略です。
+`cmp()` は比較可能なものに対しならなんでも呼べて、引数に比較したい対象の参照を取ります。
+`cmp()` は先程 `use` した `Ordering` を返します。
+[`match`][match]文を使って正確に `Ordering` のどれであるかを判断しています。
+`Ordering` は[`enum`][enum] (訳注: 列挙型)で、enumは「enumeration(訳注: 列挙)」の略です。
 このようなものです。
 
 ```rust
@@ -802,16 +802,16 @@ enum Foo {
 <!-- With this definition, anything of type `Foo` can be either a -->
 <!-- `Foo::Bar` or a `Foo::Baz`. We use the `::` to indicate the -->
 <!-- namespace for a particular `enum` variant. -->
-この定義だと、`Foo`のに属するものは`Foo::Bar`あるいは`Foo::Baz`です。
-`::`を使って`enum`のバリアントの名前空間を指示します。
+この定義だと、 `Foo` のに属するものは `Foo::Bar` あるいは `Foo::Baz` です。
+`::` を使って `enum` のバリアントの名前空間を指示します。
 
 <!-- The [`Ordering`][ordering] `enum` has three possible variants: `Less`, `Equal`, -->
 <!-- and `Greater`. The `match` statement takes a value of a type, and lets you -->
 <!-- create an ‘arm’ for each possible value. Since we have three types of -->
 <!-- `Ordering`, we have three arms: -->
-[`Ordering`][ordering]`enum`は3つのバリアントを持ちます。`Less`、`Equal`そして`Greater`です。
-`match`文ではある型の値を取って、それぞれの可能な値に対する「腕」を作れます。
-`Ordering`には3種類あるので、3つの腕を作っています。
+[`Ordering`][ordering] `enum` は3つのバリアントを持ちます。 `Less` 、 `Equal` そして `Greater` です。
+`match` 文ではある型の値を取って、それぞれの可能な値に対する「腕」を作れます。
+`Ordering` には3種類あるので、3つの腕を作っています。
 
 ```rust,ignore
 match guess.cmp(&secret_number) {
@@ -825,8 +825,8 @@ match guess.cmp(&secret_number) {
 
 <!-- If it’s `Less`, we print `Too small!`, if it’s `Greater`, `Too big!`, and if -->
 <!-- `Equal`, `You win!`. `match` is really useful, and is used often in Rust. -->
-`Less`なら`Too small!`を、`Greater`なら`Too big!`を、`Equal`なら`You win!`を印字します。
-`match`はとても便利で、Rustでよく使われます。
+`Less` なら `Too small!` を、 `Greater` なら `Too big!` を、 `Equal` なら `You win!` を印字します。
+`match` はとても便利で、Rustでよく使われます。
 
 <!-- I did mention that this won’t quite compile yet, though. Let’s try it: -->
 これはコンパイルが通らないと言いました。試してみましょう。
@@ -859,12 +859,12 @@ Could not compile `guessing_game`.
 <!-- with three more lines. Here’s our new program: -->
 ふぅ!大きなエラーです。核心になっているのは「型の不一致」です。
 Rustには強い静的な型システムがあります。しかし型推論も持っています。
-`let guess = String::new()`と書いた時、Rustは`guess`が文字列である筈だと推論出来るのでわざわざ型を書かなくてもよいのです。
-`secret_number`には、は1から100までの数字を持っている数値型、32bit数の`i32`、あるいは符号なし32bit数の`u32`、あるいは64bit不動小数点数`f64`あるいはそれ以外、様々な型がありえます。
-これまで、それは問題ではありませんでしたので、Rustは`i32`をデフォルトとしてました。
-しかしながらここで、`guess`と`secret_number`の比較の仕方が分かりません。
+`let guess = String::new()` と書いた時、Rustは `guess` が文字列である筈だと推論出来るのでわざわざ型を書かなくてもよいのです。
+`secret_number` には、は1から100までの数字を持っている数値型、32bit数の `i32` 、あるいは符号なし32bit数の `u32` 、あるいは64bit不動小数点数 `f64` あるいはそれ以外、様々な型がありえます。
+これまで、それは問題ではありませんでしたので、Rustは `i32` をデフォルトとしてました。
+しかしながらここで、 `guess` と `secret_number` の比較の仕方が分かりません。
 これらは同じ型である必要があります。
-究極には入力として読み取った`String`を比較のために実数の型にしたいです。
+究極には入力として読み取った `String` を比較のために実数の型にしたいです。
 それは3行追加すれば出来ます。
 新しいプログラムです。
 
@@ -916,13 +916,13 @@ fn main() {
 <!-- to an `u32`. Shadowing lets us re-use the `guess` name, rather than forcing us -->
 <!-- to come up with two unique names like `guess_str` and `guess`, or something -->
 <!-- else. -->
-ちょっと待って下さい、既に`guess`を定義してありますよね?
-してあります、が、Rustでは以前の`guess`の定義を新しいもので「隠す」ことが出来ます(訳注: このように隠すことをシャドーイングといいます)。
-まさにこのように、最初`String`であった`guess`を`u32`に変換したい、というような状況でよく使われます。
-シャドーイングのおかげで`guess_str`と`guess`のように別々の名前を考える必要はなくなり、`guess`の名前を再利用出来ます。
+ちょっと待って下さい、既に `guess` を定義してありますよね?
+してあります、が、Rustでは以前の `guess` の定義を新しいもので「隠す」ことが出来ます(訳注: このように隠すことをシャドーイングといいます)。
+まさにこのように、最初 `String` であった `guess` を `u32` に変換したい、というような状況でよく使われます。
+シャドーイングのおかげで `guess_str` と `guess` のように別々の名前を考える必要はなくなり、 `guess` の名前を再利用出来ます。
 
 <!-- We bind `guess` to an expression that looks like something we wrote earlier: -->
-`guess`を先に書いたような値に束縛します。
+`guess` を先に書いたような値に束縛します。
 
 ```rust,ignore
 guess.trim().parse()
@@ -940,17 +940,17 @@ guess.trim().parse()
 <!-- `guess` tells Rust we’re going to annotate its type. `u32` is an unsigned, -->
 <!-- thirty-two bit integer. Rust has [a number of built-in number types][number], -->
 <!-- but we’ve chosen `u32`. It’s a good default choice for a small positive number. -->
-ここでは、`guess`は古い`guess`、入力を保持している`String`の`guess`です。
-`String`の`trim()`メソッドは文字列の最初と最後にある空白を取り除きます。
-`read_line()`を満たすには「リターン」キーを押す必要があるのでこれは重要です。
-つまり、`5`と入力してリターンを押したら、`guess`は`5\n`のようになっています。
-`\n`「は改行」、エンターキーを表しています。`trim()`で`5`だけを残してこれを取り除けます。
-[文字列の`parse()`メソッド][parse]は文字列を何かの数値へとパースします。
+ここでは、 `guess` は古い `guess` 、入力を保持している `String` の `guess` です。
+`String` の `trim()` メソッドは文字列の最初と最後にある空白を取り除きます。
+`read_line()` を満たすには「リターン」キーを押す必要があるのでこれは重要です。
+つまり、 `5` と入力してリターンを押したら、 `guess` は `5\n` のようになっています。
+`\n` 「は改行」、エンターキーを表しています。 `trim()` で `5` だけを残してこれを取り除けます。
+[文字列の `parse()` メソッド][parse]は文字列を何かの数値へとパースします。
 様々な数値をパース出来るので、Rustに正確にどの型の数値が欲しいのかを伝える必要があります。
-なので、`let guess: u32`なのです。
-`guess`の後のコロン(`:`)は型注釈を付けようとしていることをRustに伝えます。
-`u32`は符号なし32bit整数です。
-Rustには[様々なビルトインの数値型][number]がありますが、今回は`u32`を選びました。
+なので、 `let guess: u32` なのです。
+`guess` の後のコロン(`:`)は型注釈を付けようとしていることをRustに伝えます。
+`u32` は符号なし32bit整数です。
+Rustには[様々なビルトインの数値型][number]がありますが、今回は `u32` を選びました。
 小さな正整数にはちょうどいいデフォルトの選択肢です。
 
 [parse]: ../std/primitive.str.html#method.parse
@@ -960,9 +960,9 @@ Rustには[様々なビルトインの数値型][number]がありますが、今
 <!-- our string contained `A👍%`? There’d be no way to convert that to a number. As -->
 <!-- such, we’ll do the same thing we did with `read_line()`: use the `expect()` -->
 <!-- method to crash if there’s an error. -->
-`read_line()`と同じように、`parse()`の呼び出しでもエラーが起き得ます。
-文字列に`A %`が含まれていたらどうなるでしょう?それは数値には変換出来ません。
-なので、`read_line()`と同じように`expect()`を使ってエラーがあったらクラッシュするようにします。
+`read_line()` と同じように、 `parse()` の呼び出しでもエラーが起き得ます。
+文字列に `A %` が含まれていたらどうなるでしょう?それは数値には変換出来ません。
+なので、 `read_line()` と同じように `expect()` を使ってエラーがあったらクラッシュするようにします。
 
 <!-- Let’s try our program out! -->
 プログラムを試してみましょう。
@@ -994,7 +994,7 @@ Too big!
 #ループ
 
 <!-- The `loop` keyword gives us an infinite loop. Let’s add that in: -->
-`loop`キーワードで無限ループが出来ます。入れてみましょう。
+`loop` キーワードで無限ループが出来ます。入れてみましょう。
 
 ```rust,ignore
 extern crate rand;
@@ -1036,7 +1036,7 @@ fn main() {
 <!-- our discussion about `parse()`? If we give a non-number answer, we’ll `panic!` -->
 <!-- and quit. Observe: -->
 そして試してみましょう。でも待って下さい、無限ループを追加しませんでした? そうです。
-`parse()`に関する議論を覚えてますか?数字でない答えを入力すると`panic!`して終了するのでした。
+`parse()` に関する議論を覚えてますか?数字でない答えを入力すると `panic!` して終了するのでした。
 やってみましょう。
 
 ```bash
@@ -1064,7 +1064,7 @@ thread '<main>' panicked at 'Please type a number!'
 
 <!-- Ha! `quit` actually quits. As does any other non-number input. Well, this is -->
 <!-- suboptimal to say the least. First, let’s actually quit when you win the game: -->
-おっ!`quit`で確かに終了しました。他の数字でないものでも同じことです。
+おっ! `quit` で確かに終了しました。他の数字でないものでも同じことです。
 でもこれは控え目に言っても最適とは言えません。
 まず、ゲームに勝ったら本当に終了するようにしましょう。
 
@@ -1112,8 +1112,8 @@ fn main() {
 <!-- thing in `main()`. We have just one more tweak to make: when someone inputs a -->
 <!-- non-number, we don’t want to quit, we just want to ignore it. We can do that -->
 <!-- like this: -->
-`You win!`の後に`break`を加えることで、ゲームに勝った時にループを抜けます。
-ループを抜けることは同時に、それが`main()`の最後の要素なので、プログラムが終了することも意味します。
+`You win!` の後に `break` を加えることで、ゲームに勝った時にループを抜けます。
+ループを抜けることは同時に、それが `main()` の最後の要素なので、プログラムが終了することも意味します。
 もう1つ調整をします。数値でない入力をした時に、終了したくはありません、無視したいです。
 それはこのように出来ます。
 
@@ -1182,11 +1182,11 @@ let guess: u32 = match guess.trim().parse() {
 「‘actually handle the returned value'. The returned value by `parse()`...」だったんだと思って訳しました
 -->
 これが「エラーならクラッシュ」から「実際に返値のエラーをハンドルする」への一般的な移行の仕方です。
-`parse()`の返す値は`Ordering`と同じような`enum`ですが、今回はそれぞれのバリアントにデータが関連付いています。
-`Ok`は成功で、`Err`は失敗です。それぞれには追加の情報もあります。パースに成功した整数、あるいはエラーの種類です。
-このケースでは、`Ok(num)`に対して`match`していて、それで`Ok`に内包された値を`num`という名前に設定しており、右側でそのまま返しています。
-`Err`の場合、エラーの種類は気にしにないので、名前ではなく`_`を使います。
-これはエラーを無視していて、`continue`で`loop`の次の繰り返しに進みます。
+`parse()` の返す値は `Ordering` と同じような `enum` ですが、今回はそれぞれのバリアントにデータが関連付いています。
+`Ok` は成功で、 `Err` は失敗です。それぞれには追加の情報もあります。パースに成功した整数、あるいはエラーの種類です。
+このケースでは、 `Ok(num)` に対して `match` していて、それで `Ok` に内包された値を `num` という名前に設定しており、右側でそのまま返しています。
+`Err` の場合、エラーの種類は気にしにないので、名前ではなく `_` を使います。
+これはエラーを無視していて、 `continue` で `loop` の次の繰り返しに進みます。
 
 <!-- Now we should be good! Let’s try: -->
 これで良いはずです。試しましょう!
@@ -1271,5 +1271,5 @@ fn main() {
 <!-- functions, using external crates, and more. Our next project will show off -->
 <!-- even more. -->
 この最初のプロジェクトで色々なものを見せました。
-`let`、`match`、メソッド、関連関数、外部クレートの使い方、などなど。
+`let` 、 `match` 、メソッド、関連関数、外部クレートの使い方、などなど。
 次のプロジェクトではさらに色々見せます。
diff --git a/1.6/ja/book/primitive-types.md b/1.6/ja/book/primitive-types.md
index b4591922..fd90ca3b 100644
--- a/1.6/ja/book/primitive-types.md
+++ b/1.6/ja/book/primitive-types.md
@@ -23,7 +23,7 @@ let y: bool = false;
 ```
 
 <!-- A common use of booleans is in [`if` conditionals][if]. --> 
-ブーリアンの一般的な使い方は、 [`if`条件][if] の中で用いるものです。
+ブーリアンの一般的な使い方は、 [`if` 条件][if] の中で用いるものです。
 
 [if]: if.html
 
diff --git a/1.6/ja/book/structs.md b/1.6/ja/book/structs.md
index d18b9570..45ca8727 100644
--- a/1.6/ja/book/structs.md
+++ b/1.6/ja/book/structs.md
@@ -4,7 +4,7 @@
 <!-- `struct`s are a way of creating more complex data types. For example, if we were
 doing calculations involving coordinates in 2D space, we would need both an `x`
 and a `y` value: -->
-`struct`はより複雑なデータ型を作る方法の1つです。例えば、もし私たちが2次元空間の座標に関する計算を行っているとして、`x`と`y`、両方の値が必要になるでしょう。
+`struct` はより複雑なデータ型を作る方法の1つです。例えば、もし私たちが2次元空間の座標に関する計算を行っているとして、 `x` と `y` 、両方の値が必要になるでしょう。
 
 ```rust
 let origin_x = 0;
@@ -12,7 +12,7 @@ let origin_y = 0;
 ```
 
 <!-- A `struct` lets us combine these two into a single, unified datatype: -->
-`struct`でこれら2つを1つのデータ型にまとめることができます。
+`struct` でこれら2つを1つのデータ型にまとめることができます。
 
 ```rust
 struct Point {
@@ -30,20 +30,20 @@ fn main() {
 <!-- There’s a lot going on here, so let’s break it down. We declare a `struct` with
 the `struct` keyword, and then with a name. By convention, `struct`s begin with
 a capital letter and are camel cased: `PointInSpace`, not `Point_In_Space`. -->
-ここで多くの情報が出てきましたから、順番に見ていきましょう。まず、`struct`キーワードを使って構造体とその名前を宣言しています。慣習により、構造体は初めが大文字のキャメルケースで記述しています。`PointInSpace`であり、`Point_In_Space`ではありません。
+ここで多くの情報が出てきましたから、順番に見ていきましょう。まず、 `struct` キーワードを使って構造体とその名前を宣言しています。慣習により、構造体は初めが大文字のキャメルケースで記述しています。 `PointInSpace` であり、 `Point_In_Space` ではありません。
 
 <!-- We can create an instance of our `struct` via `let`, as usual, but we use a `key:
 value` style syntax to set each field. The order doesn’t need to be the same as
 in the original declaration. -->
-いつものように、`let`で`struct`のインスタンスを作ることができますが、ここでは`key: value`スタイルの構文でそれぞれのフィールドに値をセットしています。順序は元の宣言と同じである必要はありません。
+いつものように、 `let` で `struct` のインスタンスを作ることができますが、ここでは `key: value` スタイルの構文でそれぞれのフィールドに値をセットしています。順序は元の宣言と同じである必要はありません。
 
 <!-- Finally, because fields have names, we can access the field through dot
 notation: `origin.x`. -->
-最後に、作成された構造体のフィールドは名前を持つため、`origin.x`というようにドット表記でアクセスできます。
+最後に、作成された構造体のフィールドは名前を持つため、 `origin.x` というようにドット表記でアクセスできます。
 
 <!-- The values in `struct`s are immutable by default, like other bindings in Rust.
 Use `mut` to make them mutable -->
-Rustの他の束縛のように、`struct`が持つ値はイミュータブルがデフォルトです。`mut`を使うと値をミュータブルにできます。
+Rustの他の束縛のように、 `struct` が持つ値はイミュータブルがデフォルトです。 `mut` を使うと値をミュータブルにできます。
 
 ```rust
 struct Point {
@@ -61,7 +61,7 @@ fn main() {
 ```
 
 <!-- This will print `The point is at (5, 0)`. -->
-これは`The point is at (5, 0)`と出力されます。
+これは `The point is at (5, 0)` と出力されます。
 
 <!-- Rust does not support field mutability at the language level, so you cannot
 write something like this: -->
@@ -103,7 +103,7 @@ fn main() {
 
 <!-- A `struct` can include `..` to indicate that you want to use a copy of some
 other `struct` for some of the values. For example: -->
-`struct`の初期化時には、値の一部を他の構造体からコピーしたいことを示す`..`を含めることができます。例えば、
+`struct` の初期化時には、値の一部を他の構造体からコピーしたいことを示す `..` を含めることができます。例えば、
 
 ```rust
 struct Point3d {
@@ -137,7 +137,7 @@ let point = Point3d { z: 1, x: 2, .. origin };
 <!-- Rust has another data type that’s like a hybrid between a [tuple][tuple] and a
 `struct`, called a ‘tuple struct’. Tuple structs have a name, but
 their fields don’t:-->
-Rustには「タプル構造体」と呼ばれる、[タプル][tuple]と`struct`のハイブリットのようなデータ型があります。タプル構造体自体には名前がありますが、そのフィールドには名前がありません。
+Rustには「タプル構造体」と呼ばれる、[タプル][tuple]と `struct` のハイブリットのようなデータ型があります。タプル構造体自体には名前がありますが、そのフィールドには名前がありません。
 
 ```rust
 struct Color(i32, i32, i32);
@@ -158,7 +158,7 @@ let origin = Point(0, 0, 0);
 
 <!-- It is almost always better to use a `struct` than a tuple struct. We would write
 `Color` and `Point` like this instead: -->
-ほとんどの場合タプル構造体よりも`struct`を使ったほうが良いです。`Color`や`Point`はこのようにも書けます。
+ほとんどの場合タプル構造体よりも `struct` を使ったほうが良いです。 `Color` や `Point` はこのようにも書けます。
 
 ```rust
 struct Color {
@@ -176,7 +176,7 @@ struct Point {
 
 <!-- Now, we have actual names, rather than positions. Good names are important,
 and with a `struct`, we have actual names. -->
-今、私たちはフィールドの位置ではなく実際のフィールドの名前を持っています。良い名前は重要で、`struct`を使うということは、実際に名前を持っているということです。
+今、私たちはフィールドの位置ではなく実際のフィールドの名前を持っています。良い名前は重要で、 `struct` を使うということは、実際に名前を持っているということです。
 
 > 訳注: 原文を元に噛み砕くと、「タプルはフィールドの並びによって区別され、構造体はフィールドの名前によって区別されます。これはタプルと構造体の最たる違いであり、構造体を持つことは名前を付けられたデータの集まりを持つことに等しいため、構造体における名前付けは重要です。」といった所でしょうか。
 
@@ -198,13 +198,13 @@ println!("length is {} inches", integer_length);
 <!-- As you can see here, you can extract the inner integer type through a
 destructuring `let`, just as with regular tuples. In this case, the
 `let Inches(integer_length)` assigns `10` to `integer_length`. -->
-上記の通り、`let`を使って分解することで、標準のタプルと同じように内部の整数型を取り出すことができます。
-このケースでは`let Inches(integer_length)`が`integer_length`へ`10`を束縛します。
+上記の通り、 `let` を使って分解することで、標準のタプルと同じように内部の整数型を取り出すことができます。
+このケースでは `let Inches(integer_length)` が `integer_length` へ `10` を束縛します。
 
 # Unit-like 構造体
 
 <!-- You can define a `struct` with no members at all: -->
-あなたは全くメンバを持たない`struct`を定義できます。
+あなたは全くメンバを持たない `struct` を定義できます。
 
 ```rust
 struct Electron;
@@ -215,7 +215,7 @@ let x = Electron;
 <!-- Such a `struct` is called ‘unit-like’ because it resembles the empty
 tuple, `()`, sometimes called ‘unit’. Like a tuple struct, it defines a
 new type. -->
-空のタプルである`()`は時々`unit`と呼ばれ、それに似ていることからこのような構造体を`unit-like`と呼んでいます。タプル構造体のように、これは新しい型を定義します。
+空のタプルである `()` は時々 `unit` と呼ばれ、それに似ていることからこのような構造体を `unit-like` と呼んでいます。タプル構造体のように、これは新しい型を定義します。
 
 <!-- This is rarely useful on its own (although sometimes it can serve as a
 marker type), but in combination with other features, it can become
@@ -223,6 +223,6 @@ useful. For instance, a library may ask you to create a structure that
 implements a certain [trait][trait] to handle events. If you don’t have
 any data you need to store in the structure, you can just create a
 unit-like `struct`. -->
-これは単体でもごくまれに役立ちます(もっとも、時々型をマーク代わりとして役立てる程度です)が、他の機能と組み合わせることにより便利になります。例えば、ライブラリはあなたにイベントを処理できる特定の[トレイト][trait]が実装されたストラクチャの作成を要求するかもしれません。もしそのストラクチャの中に保存すべき値が何もなければ、あなたはダミーのデータを作成する必要はなく、ただunit-likeな`struct`を作るだけで良いのです。
+これは単体でもごくまれに役立ちます(もっとも、時々型をマーク代わりとして役立てる程度です)が、他の機能と組み合わせることにより便利になります。例えば、ライブラリはあなたにイベントを処理できる特定の[トレイト][trait]が実装されたストラクチャの作成を要求するかもしれません。もしそのストラクチャの中に保存すべき値が何もなければ、あなたはダミーのデータを作成する必要はなく、ただunit-likeな `struct` を作るだけで良いのです。
 
 [trait]: traits.html