[WIP] 5.10. Borrow and AsRef

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)
@@ -48,7 +48,7 @@
     * [条件付きコンパイル](conditional-compilation.md)
     * [ドキュメント](documentation.md)
     * [イテレータ](iterators.md)
-    * [並行](concurrency.md)
+    * [並行性](concurrency.md)
     * [エラーハンドリング](error-handling.md)
     * [保証を選ぶ](choosing-your-guarantees.md)
     * [FFI](ffi.md)

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` 向けにリコンパイルする必要はあるかもしれません。

1.6/ja/book/borrow-and-asref.md

@@ -1,17 +1,22 @@
-% Borrow and AsRef
+% BorrowとAsRef
+<!-- % Borrow and AsRef -->
 
-The [`Borrow`][borrow] and [`AsRef`][asref] traits are very similar, but
-different. Here’s a quick refresher on what these two traits mean.
+<!-- The [`Borrow`][borrow] and [`AsRef`][asref] traits are very similar, but -->
+<!-- different. Here’s a quick refresher on what these two traits mean. -->
+[`Borrow`][borrow] トレイトと [`AsRef`][asref] トレイトはとてもよく似ていますが違うものです。ここでは2つのトレイトの意味を簡単に説明します。
 
 [borrow]: ../std/borrow/trait.Borrow.html
 [asref]: ../std/convert/trait.AsRef.html
 
+<!-- # Borrow -->
 # Borrow
 
-The `Borrow` trait is used when you’re writing a datastructure, and you want to
-use either an owned or borrowed type as synonymous for some purpose.
+<!-- The `Borrow` trait is used when you’re writing a datastructure, and you want to -->
+<!-- use either an owned or borrowed type as synonymous for some purpose. -->
+`Borrow` トレイトはデータ構造を書いていて、所有型と借用型を同等に扱いたいときに使います。
 
-For example, [`HashMap`][hashmap] has a [`get` method][get] which uses `Borrow`:
+<!-- For example, [`HashMap`][hashmap] has a [`get` method][get] which uses `Borrow`: -->
+例えば、 [`HashMap`][hashmap] には `Borrow` を使った [`get` メソッド][get] があります。
 
 ```rust,ignore
 fn get<Q: ?Sized>(&self, k: &Q) -> Option<&V>
@@ -22,17 +27,19 @@ fn get<Q: ?Sized>(&self, k: &Q) -> Option<&V>
 [hashmap]: ../std/collections/struct.HashMap.html
 [get]: ../std/collections/struct.HashMap.html#method.get
 
-This signature is pretty complicated. The `K` parameter is what we’re interested
-in here. It refers to a parameter of the `HashMap` itself:
+<!-- This signature is pretty complicated. The `K` parameter is what we’re interested -->
+<!-- in here. It refers to a parameter of the `HashMap` itself: -->
+このシグネチャは少し複雑です。`K` パラメータに注目してください。これは以下のように `HashMap` 自身のパラメータになっています。
 
 ```rust,ignore
 struct HashMap<K, V, S = RandomState> {
 ```
 
-The `K` parameter is the type of _key_ the `HashMap` uses. So, looking at
-the signature of `get()` again, we can use `get()` when the key implements
-`Borrow<Q>`. That way, we can make a `HashMap` which uses `String` keys,
-but use `&str`s when we’re searching:
+<!-- The `K` parameter is the type of _key_ the `HashMap` uses. So, looking at -->
+<!-- the signature of `get()` again, we can use `get()` when the key implements -->
+<!-- `Borrow<Q>`. That way, we can make a `HashMap` which uses `String` keys, -->
+<!-- but use `&str`s when we’re searching: -->
+`K` パラメータは `HashMap` の「キー」を表す型です。ここで再び `get()` のシグネチャを見ると、キーが `Borrow<Q>` を実装しているときに `get()` を使えることが分かります。そのため、以下のように `String` をキーとした `HashMap` を検索するときに `&str` を使うことができます。
 
 ```rust
 use std::collections::HashMap;
@@ -43,13 +50,15 @@ map.insert("Foo".to_string(), 42);
 assert_eq!(map.get("Foo"), Some(&42));
 ```
 
-This is because the standard library has `impl Borrow<str> for String`.
+<!-- This is because the standard library has `impl Borrow<str> for String`. -->
+これは標準ライブラリが `impl Borrow<str> for String` を提供しているためです。
 
-For most types, when you want to take an owned or borrowed type, a `&T` is
-enough. But one area where `Borrow` is effective is when there’s more than one
-kind of borrowed value. This is especially true of references and slices: you
-can have both an `&T` or a `&mut T`. If we wanted to accept both of these types,
-`Borrow` is up for it:
+<!-- For most types, when you want to take an owned or borrowed type, a `&T` is -->
+<!-- enough. But one area where `Borrow` is effective is when there’s more than one -->
+<!-- kind of borrowed value. This is especially true of references and slices: you -->
+<!-- can have both an `&T` or a `&mut T`. If we wanted to accept both of these types, -->
+<!-- `Borrow` is up for it: -->
+所有型か借用型のどちらかを取りたい場合、たいていは `&T` で十分ですが、借用された値が複数種類ある場合 `Borrow` が役に立ちます。特に参照とスライスは `&T` と `&mut T` のいずれも取りうるため、そのどちらも受け入れたい場合は `Borrow` がよいでしょう。
 
 ```rust
 use std::borrow::Borrow;
@@ -65,12 +74,15 @@ foo(&i);
 foo(&mut i);
 ```
 
-This will print out `a is borrowed: 5` twice.
+<!-- This will print out `a is borrowed: 5` twice. -->
+上のコードは `a is borrowed: 5` を二度出力します。
 
+<!-- # AsRef -->
 # AsRef
 
-The `AsRef` trait is a conversion trait. It’s used for converting some value to
-a reference in generic code. Like this:
+<!-- The `AsRef` trait is a conversion trait. It’s used for converting some value to -->
+<!-- a reference in generic code. Like this: -->
+`AsRef` トレイトは変換用のトレイトです。ジェネリックなコードにおいて、値を参照に変換したい場合に使います。
 
 ```rust
 let s = "Hello".to_string();
@@ -80,14 +92,18 @@ fn foo<T: AsRef<str>>(s: T) {
 }
 ```
 
-# Which should I use?
+<!-- # Which should I use? -->
+# どちらを使うべきか
 
-We can see how they’re kind of the same: they both deal with owned and borrowed
-versions of some type. However, they’re a bit different.
+<!-- We can see how they’re kind of the same: they both deal with owned and borrowed -->
+<!-- versions of some type. However, they’re a bit different. -->
+ここまでで見てきた通り、2つのトレイトは、どちらもある型の所有型バージョンと借用型バージョンの両方を扱う、という意味で同じような種類のものですが、少し違います。
 
-Choose `Borrow` when you want to abstract over different kinds of borrowing, or
-when you’re building a datastructure that treats owned and borrowed values in
-equivalent ways, such as hashing and comparison.
+<!-- Choose `Borrow` when you want to abstract over different kinds of borrowing, or -->
+<!-- when you’re building a datastructure that treats owned and borrowed values in -->
+<!-- equivalent ways, such as hashing and comparison. -->
+いくつかの異なる種類の借用を抽象化したい場合や、ハッシュ化や比較のために所有型と借用型を同等に扱いたいデータ構造を作る場合は `Borrow` を使ってください。
 
-Choose `AsRef` when you want to convert something to a reference directly, and
-you’re writing generic code.
+<!-- Choose `AsRef` when you want to convert something to a reference directly, and -->
+<!-- you’re writing generic code. -->
+ジェネリックなコードで値を参照に直接変換したい場合は `AsRef` を使ってください。