generate

Author: tatsuya6502

public/1.6/book/functions.html

@@ -417,9 +417,10 @@ <h2 id='式対文' class='section-header'><a href='#式対文'>式対文</a></h2
 <p>しかし、Rustでは束縛を導入するための <code>let</code> の使用は式では <em>ありません</em> 。
 次の例はコンパイルエラーを起こします。</p>
 <span class='rusttest'>fn main() {
-    let x = (let y = 5); // expected identifier, found keyword `let`
+    // let x = (let y = 5); // expected identifier, found keyword `let`
+    let x = (let y = 5); // 識別子を期待していましたが、キーワード `let` が見付かりました
 }</span><pre class='rust rust-example-rendered'>
-<span class='kw'>let</span> <span class='ident'>x</span> <span class='op'>=</span> (<span class='kw'>let</span> <span class='ident'>y</span> <span class='op'>=</span> <span class='number'>5</span>); <span class='comment'>// expected identifier, found keyword `let`</span></pre>
+<span class='kw'>let</span> <span class='ident'>x</span> <span class='op'>=</span> (<span class='kw'>let</span> <span class='ident'>y</span> <span class='op'>=</span> <span class='number'>5</span>); <span class='comment'>// 識別子を期待していましたが、キーワード `let` が見付かりました</span></pre>
 
 <!--The compiler is telling us here that it was expecting to see the beginning of-->
 
@@ -443,11 +444,12 @@ <h2 id='式対文' class='section-header'><a href='#式対文'>式対文</a></h2
 <span class='rusttest'>fn main() {
     let mut y = 5;
 
-    let x = (y = 6);  // x has the value `()`, not `6`
+    // let x = (y = 6);  // x has the value `()`, not `6`
+    let x = (y = 6);  // xは値 `()` を持っており、 `6` ではありません
 }</span><pre class='rust rust-example-rendered'>
 <span class='kw'>let</span> <span class='kw-2'>mut</span> <span class='ident'>y</span> <span class='op'>=</span> <span class='number'>5</span>;
 
-<span class='kw'>let</span> <span class='ident'>x</span> <span class='op'>=</span> (<span class='ident'>y</span> <span class='op'>=</span> <span class='number'>6</span>);  <span class='comment'>// x has the value `()`, not `6`</span></pre>
+<span class='kw'>let</span> <span class='ident'>x</span> <span class='op'>=</span> (<span class='ident'>y</span> <span class='op'>=</span> <span class='number'>6</span>);  <span class='comment'>// xは値 `()` を持っており、 `6` ではありません</span></pre>
 
 <!--The second kind of statement in Rust is the *expression statement*. Its-->
 
@@ -504,14 +506,15 @@ <h2 id='早期リターン' class='section-header'><a href='#早期リターン'
     fn foo(x: i32) -&gt; i32 {
         return x;
 
-        // we never run this code!
+       // we never run this code!
+        // このコードは走りません!
         x + 1
     }
 }</span><pre class='rust rust-example-rendered'>
 <span class='kw'>fn</span> <span class='ident'>foo</span>(<span class='ident'>x</span>: <span class='ident'>i32</span>) <span class='op'>-&gt;</span> <span class='ident'>i32</span> {
     <span class='kw'>return</span> <span class='ident'>x</span>;
 
-    <span class='comment'>// we never run this code!</span>
+    <span class='comment'>// このコードは走りません!</span>
     <span class='ident'>x</span> <span class='op'>+</span> <span class='number'>1</span>
 }</pre>
 

public/1.6/book/guessing-game.html

@@ -448,7 +448,9 @@ <h1 id='予想値を処理する' class='section-header'><a href='#予想値を
 <code>let</code>は代入の左辺に名前を取る訳ではなくて実際には<a href="patterns.html">パターン</a>を受け取ります。
 後程パターンを使います。簡単なのでもう使えますね。</p>
 <span class='rusttest'>fn main() {
+    // let foo = 5; // immutable.
     let foo = 5; // イミュータブル
+    // let mut bar = 5; // mutable
     let mut bar = 5; // ミュータブル
 }</span><pre class='rust rust-example-rendered'>
 <span class='kw'>let</span> <span class='ident'>foo</span> <span class='op'>=</span> <span class='number'>5</span>; <span class='comment'>// イミュータブル</span>

public/1.6/book/primitive-types.html

@@ -277,13 +277,13 @@ <h1 id='数値型' class='section-header'><a href='#数値型'>数値型</a></h1
 
 <p>もし数値リテラルがその型を推論させるものを何も持たないのであれば、以下のとおりデフォルトになります。</p>
 <span class='rusttest'>fn main() {
-    let x = 42; // x has type i32
-    
-    let y = 1.0; // y has type f64
+    // let x = 42; // x has type i32
+    let x = 42; // xはi32型を持つ
+    // let y = 1.0; // y has type f64
+    let y = 1.0; // yはf64型を持つ
 }</span><pre class='rust rust-example-rendered'>
-<span class='kw'>let</span> <span class='ident'>x</span> <span class='op'>=</span> <span class='number'>42</span>; <span class='comment'>// x has type i32</span>
-
-<span class='kw'>let</span> <span class='ident'>y</span> <span class='op'>=</span> <span class='number'>1.0</span>; <span class='comment'>// y has type f64</span></pre>
+<span class='kw'>let</span> <span class='ident'>x</span> <span class='op'>=</span> <span class='number'>42</span>; <span class='comment'>// xはi32型を持つ</span>
+<span class='kw'>let</span> <span class='ident'>y</span> <span class='op'>=</span> <span class='number'>1.0</span>; <span class='comment'>// yはf64型を持つ</span></pre>
 
 <!-- Here’s a list of the different numeric types, with links to their documentation --> 
 
@@ -494,12 +494,14 @@ <h2 id='スライシング構文' class='section-header'><a href='#スライシ
 <code>&amp;</code> はスライスが参照と同じであることを示し、 <code>[]</code> はレンジを持ち、スライスの長さを定義します。</p>
 <span class='rusttest'>fn main() {
     let a = [0, 1, 2, 3, 4];
-    let complete = &amp;a[..]; // A slice containing all of the elements in a
-    let middle = &amp;a[1..4]; // A slice of a: just the elements 1, 2, and 3
+    // let complete = &amp;a[..]; // A slice containing all of the elements in a
+    let complete = &amp;a[..]; // aに含まれる全ての要素を持つスライス
+    // let middle = &amp;a[1..4]; // A slice of a: just the elements 1, 2, and 3
+    let middle = &amp;a[1..4]; // 1、2、3のみを要素に持つaのスライス
 }</span><pre class='rust rust-example-rendered'>
 <span class='kw'>let</span> <span class='ident'>a</span> <span class='op'>=</span> [<span class='number'>0</span>, <span class='number'>1</span>, <span class='number'>2</span>, <span class='number'>3</span>, <span class='number'>4</span>];
-<span class='kw'>let</span> <span class='ident'>complete</span> <span class='op'>=</span> <span class='kw-2'>&amp;</span><span class='ident'>a</span>[..]; <span class='comment'>// A slice containing all of the elements in a</span>
-<span class='kw'>let</span> <span class='ident'>middle</span> <span class='op'>=</span> <span class='kw-2'>&amp;</span><span class='ident'>a</span>[<span class='number'>1</span>..<span class='number'>4</span>]; <span class='comment'>// A slice of a: just the elements 1, 2, and 3</span></pre>
+<span class='kw'>let</span> <span class='ident'>complete</span> <span class='op'>=</span> <span class='kw-2'>&amp;</span><span class='ident'>a</span>[..]; <span class='comment'>// aに含まれる全ての要素を持つスライス</span>
+<span class='kw'>let</span> <span class='ident'>middle</span> <span class='op'>=</span> <span class='kw-2'>&amp;</span><span class='ident'>a</span>[<span class='number'>1</span>..<span class='number'>4</span>]; <span class='comment'>// 1、2、3のみを要素に持つaのスライス</span></pre>
 
 <!-- Slices have type `&[T]`. We’ll talk about that `T` when we cover --> 
 
@@ -630,11 +632,13 @@ <h1 id='タプル' class='section-header'><a href='#タプル'>タプル</a></h1
 
 <p>コンマを付けることで要素1のタプルを丸括弧の中の値と混同しないように明示することができます。</p>
 <span class='rusttest'>fn main() {
-    (0,); // single-element tuple
-    (0); // zero in parentheses
+    // (0,); // single-element tuple
+     (0,); // 1要素のタプル
+    // (0); // zero in parentheses
+     (0); // 丸括弧に囲まれたゼロ
 }</span><pre class='rust rust-example-rendered'>
-(<span class='number'>0</span>,); <span class='comment'>// single-element tuple</span>
-(<span class='number'>0</span>); <span class='comment'>// zero in parentheses</span></pre>
+ (<span class='number'>0</span>,); <span class='comment'>// 1要素のタプル</span>
+ (<span class='number'>0</span>); <span class='comment'>// 丸括弧に囲まれたゼロ</span></pre>
 
 <!-- ## Tuple Indexing --> 
 

public/1.6/book/structs.html

@@ -307,8 +307,10 @@ <h1 class="title">構造体</h1>
 
     point.x = 5;
 
+//    let point = point; // this new binding can’t change now
     let point = point; // この新しい束縛でここから変更できなくなります
 
+//    point.y = 6; // this causes an error
     point.y = 6; // これはエラーになります
 }
 </span><pre class='rust rust-example-rendered'>