generate

Author: KeenS

public/1.6/book/deref-coercions.html

@@ -4,7 +4,7 @@
     <meta charset="utf-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <meta name="generator" content="rustdoc">
-    <title>`Deref` coercions</title>
+    <title>`Deref` による型強制</title>
 
     <link rel="stylesheet" type="text/css" href="rustbook.css">
 
@@ -185,9 +185,15 @@
 <div id='page'>
 
 
-    <h1 class="title">`Deref` coercions</h1>
-    <p>The standard library provides a special trait, <a href="../std/ops/trait.Deref.html"><code>Deref</code></a>. It’s normally
-used to overload <code>*</code>, the dereference operator:</p>
+    <h1 class="title">`Deref` による型強制</h1>
+    <!-- % `Deref` coercions -->
+
+<!-- The standard library provides a special trait, [`Deref`][deref]. It’s normally -->
+
+<!-- used to overload `*`, the dereference operator: -->
+
+<p>標準ライブラリは特別なトレイト <a href="../std/ops/trait.Deref.html"><code>Dref</code></a> を提供します。
+<code>Deref</code> は通常、参照外し演算子 <code>*</code> をオーバーロードするために利用されます。</p>
 <span class='rusttest'>use std::ops::Deref;
 
 struct DerefExample&lt;T&gt; {
@@ -226,95 +232,146 @@ <h1 class="title">`Deref` coercions</h1>
     <span class='macro'>assert_eq</span><span class='macro'>!</span>(<span class='string'>&#39;a&#39;</span>, <span class='op'>*</span><span class='ident'>x</span>);
 }</pre>
 
-<p>This is useful for writing custom pointer types. However, there’s a language
-feature related to <code>Deref</code>: ‘deref coercions’. Here’s the rule: If you have a
-type <code>U</code>, and it implements <code>Deref&lt;Target=T&gt;</code>, values of <code>&amp;U</code> will
-automatically coerce to a <code>&amp;T</code>. Here’s an example:</p>
+<!-- This is useful for writing custom pointer types. However, there’s a language -->
+
+<!-- feature related to `Deref`: ‘deref coercions’. Here’s the rule: If you have a -->
+
+<!-- type `U`, and it implements `Deref<Target=T>`, values of `&U` will -->
+
+<!-- automatically coerce to a `&T`. Here’s an example: -->
+
+<p>このように、 <code>Deref</code> はカスタマイズしたポインタ型を定義するのに便利です。
+一方で、<code>Deref</code> に関連する機能がもう一つ有ります: 「derefによる型強制」です。
+これは、 <code>Deref&lt;Target=T&gt;</code> を実装している型 <code>U</code> があるときに、
+<code>&amp;U</code> が自動的に <code>&amp;T</code> に型強制されるというルールです。
+例えば:</p>
 <span class='rusttest'>fn main() {
     fn foo(s: &amp;str) {
-        // borrow a string for a second
+    //    // borrow a string for a second
+        // 一瞬だけ文字列を借用します
     }
 
-    // String implements Deref&lt;Target=str&gt;
+    // // String implements Deref&lt;Target=str&gt;
+    // String は Deref&lt;Target=str&gt; を実装しています
     let owned = &quot;Hello&quot;.to_string();
 
-    // therefore, this works:
+    // // therefore, this works:
+    // なので、以下のコードはきちんと動作します:
     foo(&amp;owned);
 }</span><pre class='rust rust-example-rendered'>
 <span class='kw'>fn</span> <span class='ident'>foo</span>(<span class='ident'>s</span>: <span class='kw-2'>&amp;</span><span class='ident'>str</span>) {
-    <span class='comment'>// borrow a string for a second</span>
+    <span class='comment'>// 一瞬だけ文字列を借用します</span>
 }
 
-<span class='comment'>// String implements Deref&lt;Target=str&gt;</span>
+<span class='comment'>// String は Deref&lt;Target=str&gt; を実装しています</span>
 <span class='kw'>let</span> <span class='ident'>owned</span> <span class='op'>=</span> <span class='string'>&quot;Hello&quot;</span>.<span class='ident'>to_string</span>();
 
-<span class='comment'>// therefore, this works:</span>
+<span class='comment'>// なので、以下のコードはきちんと動作します:</span>
 <span class='ident'>foo</span>(<span class='kw-2'>&amp;</span><span class='ident'>owned</span>);</pre>
 
-<p>Using an ampersand in front of a value takes a reference to it. So <code>owned</code> is a
-<code>String</code>, <code>&amp;owned</code> is an <code>&amp;String</code>, and since <code>impl Deref&lt;Target=str&gt; for String</code>, <code>&amp;String</code> will deref to <code>&amp;str</code>, which <code>foo()</code> takes.</p>
+<!-- Using an ampersand in front of a value takes a reference to it. So `owned` is a -->
 
-<p>That’s it. This rule is one of the only places in which Rust does an automatic
-conversion for you, but it adds a lot of flexibility. For example, the <code>Rc&lt;T&gt;</code>
-type implements <code>Deref&lt;Target=T&gt;</code>, so this works:</p>
+<!-- `String`, `&owned` is an `&String`, and since `impl Deref<Target=str> for -->
+
+<!-- String`, `&String` will deref to `&str`, which `foo()` takes. -->
+
+<p>値の前にアンパサンド(&amp;)をつけることによってその値への参照を取得することができます。
+なので、 <code>owned</code> は <code>String</code> であり、 <code>&amp;owned</code> は <code>&amp;String</code> であり、
+そして、 <code>String</code> が <code>Deref&lt;Target=str&gt;</code> を実装しているために、
+<code>&amp;String</code> は <code>foo()</code> が要求している <code>&amp;str</code> に型強制されます。</p>
+
+<!-- That’s it. This rule is one of the only places in which Rust does an automatic -->
+
+<!-- conversion for you, but it adds a lot of flexibility. For example, the `Rc<T>` -->
+
+<!-- type implements `Deref<Target=T>`, so this works: -->
+
+<p>以上です! このルールはRustが自動的に変換を行う唯一の箇所の一つです。
+これによって、多くの柔軟性が手にはいります。
+例えば <code>Rc&lt;T&gt;</code> は <code>Deref&lt;Target=T&gt;</code> を実装しているため、以下のコードは正しく動作します:</p>
 <span class='rusttest'>fn main() {
     use std::rc::Rc;
 
     fn foo(s: &amp;str) {
-        // borrow a string for a second
+    //    // borrow a string for a second
+          // 文字列を一瞬だけ借用します
     }
 
-    // String implements Deref&lt;Target=str&gt;
+    // // String implements Deref&lt;Target=str&gt;
+    // String は Deref&lt;Target=str&gt;を実装しています
     let owned = &quot;Hello&quot;.to_string();
     let counted = Rc::new(owned);
 
-    // therefore, this works:
+    // // therefore, this works:
+    // ゆえに、以下のコードは正しく動作します:
     foo(&amp;counted);
 }</span><pre class='rust rust-example-rendered'>
 <span class='kw'>use</span> <span class='ident'>std</span>::<span class='ident'>rc</span>::<span class='ident'>Rc</span>;
 
 <span class='kw'>fn</span> <span class='ident'>foo</span>(<span class='ident'>s</span>: <span class='kw-2'>&amp;</span><span class='ident'>str</span>) {
-    <span class='comment'>// borrow a string for a second</span>
+      <span class='comment'>// 文字列を一瞬だけ借用します</span>
 }
 
-<span class='comment'>// String implements Deref&lt;Target=str&gt;</span>
+<span class='comment'>// String は Deref&lt;Target=str&gt;を実装しています</span>
 <span class='kw'>let</span> <span class='ident'>owned</span> <span class='op'>=</span> <span class='string'>&quot;Hello&quot;</span>.<span class='ident'>to_string</span>();
 <span class='kw'>let</span> <span class='ident'>counted</span> <span class='op'>=</span> <span class='ident'>Rc</span>::<span class='ident'>new</span>(<span class='ident'>owned</span>);
 
-<span class='comment'>// therefore, this works:</span>
+<span class='comment'>// ゆえに、以下のコードは正しく動作します:</span>
 <span class='ident'>foo</span>(<span class='kw-2'>&amp;</span><span class='ident'>counted</span>);</pre>
 
-<p>All we’ve done is wrap our <code>String</code> in an <code>Rc&lt;T&gt;</code>. But we can now pass the
-<code>Rc&lt;String&gt;</code> around anywhere we’d have a <code>String</code>. The signature of <code>foo</code>
-didn’t change, but works just as well with either type. This example has two
-conversions: <code>Rc&lt;String&gt;</code> to <code>String</code> and then <code>String</code> to <code>&amp;str</code>. Rust will do
-this as many times as possible until the types match.</p>
+<!-- All we’ve done is wrap our `String` in an `Rc<T>`. But we can now pass the -->
+
+<!-- `Rc<String>` around anywhere we’d have a `String`. The signature of `foo` -->
 
-<p>Another very common implementation provided by the standard library is:</p>
+<!-- didn’t change, but works just as well with either type. This example has two -->
+
+<!-- conversions: `Rc<String>` to `String` and then `String` to `&str`. Rust will do -->
+
+<!-- this as many times as possible until the types match. -->
+
+<p>先ほどのコードとの変化は <code>String</code> を <code>Rc&lt;T&gt;</code> でラッピングした点ですが、
+依然 <code>Rc&lt;String&gt;</code> を <code>String</code> が必要なところに渡すことができます。
+<code>foo</code> のシグネチャは変化していませんが、どちらの型についても正しく動作します。
+この例は２つの変換を含んでいます: <code>Rc&lt;String&gt;</code> が <code>String</code> に変換され、次に <code>String</code> が <code>&amp;str</code> に変換されます。
+Rustはこのような変換を型がマッチするまで必要なだけ繰り返します。</p>
+
+<!-- Another very common implementation provided by the standard library is: -->
+
+<p>標準ライブラリに頻繁に見られるその他の実装は例えば以下の様なものが有ります:</p>
 <span class='rusttest'>fn main() {
     fn foo(s: &amp;[i32]) {
-        // borrow a slice for a second
+    //    // borrow a slice for a second
+         // スライスを一瞬だけ借用します
     }
 
-    // Vec&lt;T&gt; implements Deref&lt;Target=[T]&gt;
+    // // Vec&lt;T&gt; implements Deref&lt;Target=[T]&gt;
+    // Vec&lt;T&gt; は Deref&lt;Target=[T]&gt; を実装しています
     let owned = vec![1, 2, 3];
 
     foo(&amp;owned);
 }</span><pre class='rust rust-example-rendered'>
 <span class='kw'>fn</span> <span class='ident'>foo</span>(<span class='ident'>s</span>: <span class='kw-2'>&amp;</span>[<span class='ident'>i32</span>]) {
-    <span class='comment'>// borrow a slice for a second</span>
+     <span class='comment'>// スライスを一瞬だけ借用します</span>
 }
 
-<span class='comment'>// Vec&lt;T&gt; implements Deref&lt;Target=[T]&gt;</span>
+<span class='comment'>// Vec&lt;T&gt; は Deref&lt;Target=[T]&gt; を実装しています</span>
 <span class='kw'>let</span> <span class='ident'>owned</span> <span class='op'>=</span> <span class='macro'>vec</span><span class='macro'>!</span>[<span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>];
 
 <span class='ident'>foo</span>(<span class='kw-2'>&amp;</span><span class='ident'>owned</span>);</pre>
 
-<p>Vectors can <code>Deref</code> to a slice.</p>
+<!-- Vectors can `Deref` to a slice. -->
+
+<p>ベクタはスライスに <code>Deref</code> することができます。</p>
+
+<!-- ## Deref and method calls -->
 
-<h2 id='deref-and-method-calls' class='section-header'><a href='#deref-and-method-calls'>Deref and method calls</a></h2>
-<p><code>Deref</code> will also kick in when calling a method. Consider the following
-example.</p>
+<h2 id='derefとメソッド呼び出し' class='section-header'><a href='#derefとメソッド呼び出し'>Derefとメソッド呼び出し</a></h2>
+<!-- `Deref` will also kick in when calling a method. Consider the following -->
+
+<!-- example. -->
+
+<p><code>Deref</code> はメソッド呼び出し時にも自動的に呼びだされます。
+例えば以下の様なコードを見てみましょう:</p>
 <span class='rusttest'>fn main() {
     struct Foo;
 
@@ -336,8 +393,12 @@ <h2 id='deref-and-method-calls' class='section-header'><a href='#deref-and-metho
 
 <span class='ident'>f</span>.<span class='ident'>foo</span>();</pre>
 
-<p>Even though <code>f</code> is a <code>&amp;&amp;Foo</code> and <code>foo</code> takes <code>&amp;self</code>, this works. That’s
-because these things are the same:</p>
+<!-- Even though `f` is a `&&Foo` and `foo` takes `&self`, this works. That’s -->
+
+<!-- because these things are the same: -->
+
+<p><code>f</code> は <code>&amp;&amp;Foo</code> であり、 <code>foo</code> は <code>&amp;self</code> を引数に取るにも関わらずこのコードは動作します。
+これは、以下が全て等価なことによります:</p>
 <span class='rusttest'>fn main() {
     f.foo();
     (&amp;f).foo();
@@ -349,9 +410,15 @@ <h2 id='deref-and-method-calls' class='section-header'><a href='#deref-and-metho
 (<span class='op'>&amp;&amp;</span><span class='ident'>f</span>).<span class='ident'>foo</span>();
 (<span class='op'>&amp;&amp;</span><span class='op'>&amp;&amp;</span><span class='op'>&amp;&amp;</span><span class='op'>&amp;&amp;</span><span class='ident'>f</span>).<span class='ident'>foo</span>();</pre>
 
-<p>A value of type <code>&amp;&amp;&amp;&amp;&amp;&amp;&amp;&amp;&amp;&amp;&amp;&amp;&amp;&amp;&amp;&amp;Foo</code> can still have methods defined on <code>Foo</code>
-called, because the compiler will insert as many * operations as necessary to
-get it right. And since it’s inserting <code>*</code>s, that uses <code>Deref</code>.</p>
+<!-- A value of type `&&&&&&&&&&&&&&&&Foo` can still have methods defined on `Foo` -->
+
+<!-- called, because the compiler will insert as many * operations as necessary to -->
+
+<!-- get it right. And since it’s inserting `*`s, that uses `Deref`. -->
+
+<p><code>&amp;&amp;&amp;&amp;&amp;&amp;&amp;&amp;&amp;&amp;&amp;&amp;&amp;&amp;&amp;&amp;Foo</code> 型の値は <code>Foo</code> で定義されているメソッドを呼び出すことができます。
+これは、コンパイラが自動的に必要なだけ * 演算子を補うことによります。
+そして <code>*</code> が補われることによって <code>Deref</code> が利用される事になります。</p>
 
     <script type="text/javascript">
         window.playgroundUrl = "https://play.rust-lang.org";