ci: generate pages at 97d6e0c [ci skip]

Author: bn-e

docs/conversion/string.html

@@ -181,7 +181,7 @@ <h2 id="stringへの型変換"><a class="header" href="#stringへの型変換">S
 -->
 <h2 id="stringの解析"><a class="header" href="#stringの解析">Stringの解析</a></h2>
 <!--
-One of the more common types to convert a string into is a number. The idiomatic
+One of the more common types to convert a string into a number. The idiomatic
 approach to this is to use the [`parse`] function and either to arrange for
 type inference or to specify the type to parse using the 'turbofish' syntax.
 Both alternatives are shown in the following example.

docs/crates/lib.html

@@ -153,6 +153,7 @@ <h1 id="ライブラリ"><a class="header" href="#ライブラリ">ライブラ
 Let's create a library, and then see how to link it to another crate.
 -->
 <p>ではライブラリを作成し、それを別のクレートにリンクする方法を見ていきましょう。</p>
+<p>In <code>rary.rs</code>:</p>
 <pre><code class="language-rust ignore">pub fn public_function() {
     println!(&quot;called rary's `public_function()`&quot;);
 }

docs/error/multiple_error_types/reenter_question_mark.html

@@ -155,7 +155,7 @@ <h1 id="の他の活用法"><a class="header" href="#の他の活用法"><code>?
 error:
 -->
 <p>以前の例では<code>parse</code>の呼び出しに対するその場での対応として、エラーをライブラリのエラーからboxされたエラーへと<code>map</code>していました。</p>
-<pre><code class="language-rust ignore">.and_then(|s| s.parse::&lt;i32&gt;()
+<pre><code class="language-rust ignore">.and_then(|s| s.parse::&lt;i32&gt;())
     .map_err(|e| e.into())</code></pre>
 <!--
 Since this is a simple and common operation, it would be convenient if it

docs/error/option_unwrap/and_then.html

@@ -159,11 +159,11 @@ <h1 id="combinators-and_then"><a class="header" href="#combinators-and_then">Com
 -->
 <p><code>and_then()</code>は引数として与えられた関数にラップされた値を渡しますが、その値が<code>None</code>だった場合は<code>None</code>を返します。</p>
 <!--
-In the following example, `cookable_v2()` results in an `Option<Food>`. 
+In the following example, `cookable_v3()` results in an `Option<Food>`. 
 Using `map()` instead of `and_then()` would have given an 
 `Option<Option<Food>>`, which is an invalid type for `eat()`.
 -->
-<p>以下の例では<code>cookable_v2()</code>は<code>Option&lt;Food&gt;</code>を返すため、<code>and_then()</code>ではなく<code>map()</code>を使用すると最終的に<code>Option&lt;Option&lt;Food&gt;&gt;</code>になります。これは<code>eat()</code>には不適切な型です。</p>
+<p>以下の例では<code>cookable_v3()</code>は<code>Option&lt;Food&gt;</code>を返すため、<code>and_then()</code>ではなく<code>map()</code>を使用すると最終的に<code>Option&lt;Option&lt;Food&gt;&gt;</code>になります。これは<code>eat()</code>には不適切な型です。</p>
 <pre><pre class="playground"><code class="language-rust editable edition2021">#![allow(dead_code)]
 
 #[derive(Debug)] enum Food { CordonBleu, Steak, Sushi }
@@ -194,21 +194,24 @@ <h1 id="combinators-and_then"><a class="header" href="#combinators-and_then">Com
 fn cookable_v1(food: Food) -&gt; Option&lt;Food&gt; {
     match have_recipe(food) {
         None       =&gt; None,
-        Some(food) =&gt; match have_ingredients(food) {
-            None       =&gt; None,
-            Some(food) =&gt; Some(food),
-        },
+        Some(food) =&gt; have_ingredients(food),
     }
 }
 
 // This can conveniently be rewritten more compactly with `and_then()`:
 // `and_then()`を用いることで、同じことをよりコンパクトに表現できる。
-fn cookable_v2(food: Food) -&gt; Option&lt;Food&gt; {
+fn cookable_v3(food: Food) -&gt; Option&lt;Food&gt; {
     have_recipe(food).and_then(have_ingredients)
 }
 
+// Otherwise we'd need to `flatten()` an `Option&lt;Option&lt;Food&gt;&gt;`
+// to get an `Option&lt;Food&gt;`:
+fn cookable_v2(food: Food) -&gt; Option&lt;Food&gt; {
+    have_recipe(food).map(have_ingredients).flatten()
+}
+
 fn eat(food: Food, day: Day) {
-    match cookable_v2(food) {
+    match cookable_v3(food) {
         Some(food) =&gt; println!(&quot;Yay! On {:?} we get to eat {:?}.&quot;, day, food),
         None       =&gt; println!(&quot;Oh no. We don't get to eat on {:?}?&quot;, day),
     }
@@ -226,9 +229,8 @@ <h1 id="combinators-and_then"><a class="header" href="#combinators-and_then">Com
 -->
 <h3 id="参照"><a class="header" href="#参照">参照</a></h3>
 <!--
-[closures][closures], [`Option`][option], and [`Option::and_then()`][and_then]
 -->
-<p><a href="../../fn/closures.html">closures</a>, <a href="https://doc.rust-lang.org/std/option/enum.Option.html"><code>Option</code></a>, <a href="https://doc.rust-lang.org/std/option/enum.Option.html#method.and_then"><code>Option::and_then()</code></a></p>
+<p><a href="../../fn/closures.html">closures</a>, <a href="https://doc.rust-lang.org/std/option/enum.Option.html"><code>Option</code></a>, <a href="https://doc.rust-lang.org/std/option/enum.Option.html#method.and_then"><code>Option::and_then()</code></a>, and <a href="https://doc.rust-lang.org/std/option/enum.Option.html#method.flatten"><code>Option::flatten()</code></a></p>
 
                     </main>
 

docs/error/result/result_map.html

@@ -212,10 +212,10 @@ <h1 id="resultのmap"><a class="header" href="#resultのmap"><code>Result</code>
 
 // As with `Option`, we can use combinators such as `map()`.
 // This function is otherwise identical to the one above and reads:
-// Modify n if the value is valid, otherwise pass on the error.
+// Multiply if both values can be parsed from str, otherwise pass on the error.
 // `Option`と同様、`map()`などのコンビネータを使うことができます。
 // この関数は`map()`を使っている点以外は上記の関数と同じで、
-// 値が有効ならnを変更し、無効であればエラーをそのまま見送ります。
+// 両方の値がstrからパース可能であればそれらを乗算し、無効であればエラーをそのまま見送ります。
 fn multiply(first_number_str: &amp;str, second_number_str: &amp;str) -&gt; Result&lt;i32, ParseIntError&gt; {
     first_number_str.parse::&lt;i32&gt;().and_then(|first_number| {
         second_number_str.parse::&lt;i32&gt;().map(|second_number| first_number * second_number)

docs/flow_control/let_else.html

@@ -148,13 +148,13 @@ <h1 class="menu-title">Rust By Example 日本語版</h1>
                         <h1 id="let-else"><a class="header" href="#let-else">let-else</a></h1>
 <blockquote>
 <p>🛈 stable since: rust 1.65</p>
+<p>🛈 you can target specific edition by compiling like this
+<code>rustc --edition=2021 main.rs</code></p>
 </blockquote>
 <p>With <code>let</code>-<code>else</code>, a refutable pattern can match and bind variables
 in the surrounding scope like a normal <code>let</code>, or else diverge (e.g. <code>break</code>,
 <code>return</code>, <code>panic!</code>) when the pattern doesn't match.</p>
-<pre><pre class="playground"><code class="language-rust edition2021"><span class="boring">#![allow(unused)]
-</span><span class="boring">fn main() {
-</span>use std::str::FromStr;
+<pre><pre class="playground"><code class="language-rust edition2021">use std::str::FromStr;
 
 fn get_count_item(s: &amp;str) -&gt; (u64, &amp;str) {
     let mut it = s.split(' ');
@@ -167,8 +167,9 @@ <h1 id="let-else"><a class="header" href="#let-else">let-else</a></h1>
     (count, item)
 }
 
-assert_eq!(get_count_item(&quot;3 chairs&quot;), (3, &quot;chairs&quot;));
-<span class="boring">}</span></code></pre></pre>
+fn main() {
+    assert_eq!(get_count_item(&quot;3 chairs&quot;), (3, &quot;chairs&quot;));
+}</code></pre></pre>
 <p>The scope of name bindings is the main thing that makes this different from
 <code>match</code> or <code>if let</code>-<code>else</code> expressions. You could previously approximate these
 patterns with an unfortunate bit of repetition and an outer <code>let</code>:</p>

docs/flow_control/match/destructuring/destructure_structures.html

@@ -179,6 +179,12 @@ <h1 id="構造体"><a class="header" href="#構造体">構造体</a></h1>
         // `x`に言及していないため、以下はエラーになる。
         //Foo { y } =&gt; println!(&quot;y = {}&quot;, y),
     }
+
+    let faa = Foo { x: (1, 2), y: 3 };
+
+    // You do not need a match block to destructure structs:
+    let Foo { x : x0, y: y0 } = faa;
+    println!(&quot;Outside: x0 = {x0:?}, y0 = {y0}&quot;);
 }</code></pre></pre>
 <!--
 ### See also:

docs/flow_control/match/guard.html

@@ -153,7 +153,8 @@ <h1 id="ガード"><a class="header" href="#ガード">ガード</a></h1>
 A `match` *guard* can be added to filter the arm.
 -->
 <p><code>match</code>内の条件文をフィルタリングするために、 <em>ガード(<code>guard</code>)</em> を使用することができます。</p>
-<pre><pre class="playground"><code class="language-rust editable edition2021">enum Temperature {
+<pre><pre class="playground"><code class="language-rust editable edition2021">#[allow(dead_code)]
+enum Temperature {
     Celsius(i32),
     Fahrenheit(i32),
 }

docs/generics/bounds.html

@@ -218,10 +218,10 @@ <h1 id="ジェネリック境界"><a class="header" href="#ジェネリック境
     let _triangle = Triangle  { length: 3.0, height: 4.0 };
 
     print_debug(&amp;rectangle);
-    println!(&quot;Area: {}&quot;, rectangle.area());
+    println!(&quot;Area: {}&quot;, area(&amp;rectangle));
 
     //print_debug(&amp;_triangle);
-    //println!(&quot;Area: {}&quot;, _triangle.area());
+    //println!(&quot;Area: {}&quot;, area(&amp;_triangle));
     // ^ TODO: Try uncommenting these.
     // | Error: Does not implement either `Debug` or `HasArea`. 
     // ^ TODO: これらの行をアンコメントしてみましょう。

docs/hello/comment.html

@@ -179,7 +179,7 @@ <h1 id="コメント"><a class="header" href="#コメント">コメント</a></h
 <pre><pre class="playground"><code class="language-rust editable edition2021">fn main() {
     // This is an example of a line comment.
     // There are two slashes at the beginning of the line.
-    // And nothing written inside these will be read by the compiler.
+    // And nothing written after these will be read by the compiler.
     // こちらはラインコメントです
     // 一番左にスラッシュが2つある行と、何も書かれていない行は
     // どちらもコンパイラによって無視されます。試しに実行してみてください