Translate coercions.md (#33)

Author: toku-sa-n

src/SUMMARY.md

@@ -21,7 +21,7 @@
 	* [PhantomData](phantom-data.md)
 	* [Splitting Borrows](borrow-splitting.md)
 * [型変換](conversions.md)
-	* [Coercions](coercions.md)
+	* [型強制](coercions.md)
 	* [The Dot Operator](dot-operator.md)
 	* [Casts](casts.md)
 	* [Transmutes](transmutes.md)

src/coercions.md

@@ -1,14 +1,34 @@
+<!--
 # Coercions
+-->
 
+# 型強制
+
+<!--
 Types can implicitly be coerced to change in certain contexts. These changes are
 generally just *weakening* of types, largely focused around pointers and
 lifetimes. They mostly exist to make Rust "just work" in more cases, and are
 largely harmless.
+-->
+
+特定の状況では、暗黙に型変換を強制することが出来ます。これらの変換は、一般には
+単に型を*弱く*していて、主にポインタやライフタイム周りに着目されます。
+これらはほとんどが、より多くのケースで Rust が "単に動く" ようにするために存在し、
+そして大部分において、ほとんど害はありません。
 
+<!--
 Here's all the kinds of coercion:
+-->
+
+これらは全ての種類の型強制です:
 
+<!--
 Coercion is allowed between the following types:
+-->
 
+型強制は以下の型の間で認められています:
+
+<!--
 * Transitivity: `T_1` to `T_3` where `T_1` coerces to `T_2` and `T_2` coerces to
   `T_3`
 * Pointer Weakening:
@@ -18,11 +38,28 @@ Coercion is allowed between the following types:
     * `&mut T` to `*mut T`
 * Unsizing: `T` to `U` if `T` implements `CoerceUnsized<U>`
 * Deref coercion: Expression `&x` of type `&T` to `&*x` of type `&U` if `T` derefs to `U` (i.e. `T: Deref<Target=U>`)
+-->
+
+* 推移性: `T_1` から `T_3` 但し `T_1` が `T_2` に型強制可能で、 `T_2` が `T_3` に型強制可能な場合
+* ポインタの弱化:
+    * `&mut T` から `&T`
+    * `*mut T` から `*const T`
+    * `&T` から `*const T`
+    * `&mut T` から `*mut T`
+* アンサイジング: `T` から `U` 但し `T` が `CoerceUnsized<U>` を実装している場合
+* 参照外しの型強制: 型 `&T` の式 `&x` から型 `&U` の式 `&'x` 但し `T` が `U` に参照外しされる場合 (例: `T: Deref<Target=U>`)
 
+<!--
 `CoerceUnsized<Pointer<U>> for Pointer<T> where T: Unsize<U>` is implemented
 for all pointer types (including smart pointers like Box and Rc). Unsize is
 only implemented automatically, and enables the following transformations:
+-->
+
+`CoerceUnsized<Pointer<U>> for Pointer<T> where T: Unsize<U>` は
+全てのポインタ型 (Box や Rc のようなスマートポインタを含む) で実装されています。
+アンサイズは自動的にのみ実装され、以下の変換を有効にします。
 
+<!--
 * `[T; n]` => `[T]`
 * `T` => `Trait` where `T: Trait`
 * `Foo<..., T, ...>` => `Foo<..., U, ...>` where:
@@ -31,25 +68,58 @@ only implemented automatically, and enables the following transformations:
     * Only the last field of `Foo` has type involving `T`
     * `T` is not part of the type of any other fields
     * `Bar<T>: Unsize<Bar<U>>`, if the last field of `Foo` has type `Bar<T>`
+-->
 
+* `[T; n]` => `[T]`
+* `T` => `Trait` 但し `T: Trait`
+* `Foo<..., T, ...>` => `Foo<..., U, ...>` 但し
+    * `T: Unsize<U>`
+    * `Foo` は構造体
+    * `Foo` の最後のフィールドだけが `T` を含む型である
+    * `T` は他のフィールドの一部となっていない
+    * `Bar<T>: Unsize<Bar<U>>` 但し `Foo` の最後のフィールドが `Bar<T>` の型である場合
+
+<!--
 Coercions occur at a *coercion site*. Any location that is explicitly typed
 will cause a coercion to its type. If inference is necessary, the coercion will
 not be performed. Exhaustively, the coercion sites for an expression `e` to
 type `U` are:
+-->
 
+型強制は、*型強制サイト*で起こります。明確に型が指定されている全ての場所で、
+その型への型強制が発生します。もし推論が必要ならば、型強制は行われません。
+余すことなく言えば、式 `e` に対する型 `U` への型強制サイトは以下の通りです。
+
+<!--
 * let statements, statics, and consts: `let x: U = e`
 * Arguments to functions: `takes_a_U(e)`
 * Any expression that will be returned: `fn foo() -> U { e }`
 * Struct literals: `Foo { some_u: e }`
 * Array literals: `let x: [U; 10] = [e, ..]`
 * Tuple literals: `let x: (U, ..) = (e, ..)`
 * The last expression in a block: `let x: U = { ..; e }`
+-->
+
+* let 文、 static、 const: `let x: U = e`
+* 関数に対する引数: `takes_a_U(e)`
+* 返される全ての式: `fn foo() -> U { e }`
+* 構造体リテラル: `Foo { some_u: e }`
+* 配列リテラル: `let x: [U; 10] = [e, ..]`
+* タプルリテラル: `let x: (U, ..) = (e, ..)`
+* ブロックの最後の式: `let x: U = { ..; e }`
 
+<!--
 Note that we do not perform coercions when matching traits (except for
 receivers, see below). If there is an impl for some type `U` and `T` coerces to
 `U`, that does not constitute an implementation for `T`. For example, the
 following will not type check, even though it is OK to coerce `t` to `&T` and
 there is an impl for `&T`:
+-->
+
+トレイトをマッチさせる場合、型強制が行われないことに注意してください (レシーバは例外です、
+以下を見てください) 。もしある型 `U` に対する impl が存在し、 `T` が `U` に型強制される場合、 `T` に対しては
+実装が構成されません。例えば、以下の例では `t` が `&T` に型強制されても問題なく、 `&T` に対する impl が存在するにも関わらず、
+型チェックに通りません。
 
 ```rust,ignore
 trait Trait {}
@@ -67,6 +137,7 @@ fn main() {
 
 ```text
 <anon>:10:5: 10:8 error: the trait bound `&mut i32 : Trait` is not satisfied [E0277]
+(エラー: トレイト境界 `&mut i32: Trait` が満たされていません)
 <anon>:10     foo(t);
               ^~~
 ```