deploy: c9b89df

Author: AndyGauge

about.html

@@ -207,8 +207,9 @@ <h2 id="how-to-use-the-recipes"><a class="header" href="#how-to-use-the-recipes"
 <pre><pre class="playground"><code class="language-rust edition2018">use rand::Rng;
 
 fn main() {
-    let mut rng = rand::thread_rng();
-    println!("Random f64: {}", rng.gen::&lt;f64&gt;());
+    let mut rng = rand::rng();
+    let random_number: u32 = rng.random();
+    println!("Random number: {}", random_number);
 }</code></pre></pre>
 <p>To work with it locally we can run the following commands to create
 a new cargo project, and change to that directory:</p>
@@ -231,13 +232,14 @@ <h2 id="how-to-use-the-recipes"><a class="header" href="#how-to-use-the-recipes"
 should read after deciding which crate suites your purpose.</p>
 <h2 id="a-note-about-error-handling"><a class="header" href="#a-note-about-error-handling">A note about error handling</a></h2>
 <p>Rust has <a href="https://doc.rust-lang.org/std/error/trait.Error.html"><code>std::error::Trait</code></a> which is implemented to handle exceptions.
-Handling multiple types of these traits can be simplified using <a href="https://docs.rs/anyhow/latest/anyhow/"><code>anyhow</code></a>
-or specified with an <code>enum</code> which macros exist to make this easier within
-<a href="https://docs.rs/thiserror/latest/thiserror/"><code>thiserror</code></a> for library authors.</p>
-<p>Error chain has been shown in this book for historical reasons before Rust
-<code>std</code> and crates represented macro use as a preference.  For more background
-on error handling in Rust, read <a href="https://doc.rust-lang.org/book/ch09-00-error-handling.html">this page of the Rust book</a>
-and <a href="https://brson.github.io/2016/11/30/starting-with-error-chain">this blog post</a>.</p>
+This cookbook uses <a href="https://docs.rs/anyhow/latest/anyhow/"><code>anyhow</code></a> for simplified error handling in examples,
+which provides easy error propagation and context. For library authors,
+<a href="https://docs.rs/thiserror/latest/thiserror/"><code>thiserror</code></a> provides a more structured approach using derive macros
+to create custom error types.</p>
+<p>This cookbook previously used the <code>error-chain</code> crate, but has been updated
+to use <code>anyhow</code> as it's now the preferred approach for application-level
+error handling. For more background on error handling in Rust, read
+<a href="https://doc.rust-lang.org/book/ch09-00-error-handling.html">this page of the Rust book</a> and <a href="https://brson.github.io/2016/11/30/starting-with-error-chain">this blog post</a>.</p>
 <h2 id="a-note-about-crate-representation"><a class="header" href="#a-note-about-crate-representation">A note about crate representation</a></h2>
 <p>This cookbook is intended eventually to provide expansive coverage of
 the Rust crate ecosystem, but today is limited in scope while we get

algorithms/randomness.html

@@ -163,42 +163,37 @@ <h1 id="generate-random-values"><a class="header" href="#generate-random-values"
 <h2 id="generate-random-numbers"><a class="header" href="#generate-random-numbers">Generate random numbers</a></h2>
 <p><a href="https://docs.rs/rand/"><img src="https://badge-cache.kominick.com/crates/v/rand.svg?label=rand" alt="rand-badge" /></a> <a href="https://crates.io/categories/science"><img src="https://badge-cache.kominick.com/badge/science--x.svg?style=social" alt="cat-science-badge" /></a></p>
 <p>Generates random numbers with help of random-number
-generator <a href="https://docs.rs/rand/*/rand/trait.Rng.html"><code>rand::Rng</code></a> obtained via <a href="https://docs.rs/rand/*/rand/trait.Rng.html"><code>rand::rng</code></a>. Each thread has an
+generator <a href="https://docs.rs/rand/0.9/rand/trait.Rng.html"><code>rand::Rng</code></a> obtained via <a href="https://docs.rs/rand/0.9/rand/trait.Rng.html"><code>rand::rng</code></a>. Each thread has an
 initialized generator. Integers are uniformly distributed over the range of the
 type, and floating point numbers are uniformly distributed from 0 up to but not
 including 1.</p>
 <pre><pre class="playground"><code class="language-rust edition2018">use rand::Rng;
 
 fn main() {
-    let mut rng = rand::rng();
-
-    let n1: u8 = rng.random();
-    let n2: u16 = rng.random();
-    println!("Random u8: {}", n1);
-    println!("Random u16: {}", n2);
-    println!("Random u32: {}", rng.random::&lt;u32&gt;());
-    println!("Random i32: {}", rng.random::&lt;i32&gt;());
-    println!("Random float: {}", rng.random::&lt;f64&gt;());
+    let mut rng = rand::thread_rng();
+    let random_number: u32 = rng.gen();
+    println!("Random number: {}", random_number);
 }</code></pre></pre>
 <h2 id="generate-random-numbers-within-a-range"><a class="header" href="#generate-random-numbers-within-a-range">Generate random numbers within a range</a></h2>
 <p><a href="https://docs.rs/rand/"><img src="https://badge-cache.kominick.com/crates/v/rand.svg?label=rand" alt="rand-badge" /></a> <a href="https://crates.io/categories/science"><img src="https://badge-cache.kominick.com/badge/science--x.svg?style=social" alt="cat-science-badge" /></a></p>
-<p>Generates a random value within half-open <code>[0, 10)</code> range (not including <code>10</code>) with <a href="https://doc.rust-lang.org/rand/*/rand/trait.Rng.html#method.random_range"><code>Rng::random_range</code></a>.</p>
+<p>Generates a random value within half-open <code>[0, 10)</code> range (not including <code>10</code>) with [<code>Rng::gen_range</code>].</p>
 <pre><pre class="playground"><code class="language-rust edition2018">use rand::Rng;
 
 fn main() {
     let mut rng = rand::rng();
-    println!("Integer: {}", rng.random_range(0..10));
-    println!("Float: {}", rng.random_range(0.0..10.0));
+    println!("Integer: {}", rng.gen_range(0..10));
+    println!("Float: {}", rng.gen_range(0.0..10.0));
 }</code></pre></pre>
-<p><a href="https://docs.rs/rand/*/rand/distributions/uniform/struct.Uniform.html"><code>Uniform</code></a> can obtain values with <a href="https://en.wikipedia.org/wiki/Uniform_distribution_(continuous)">uniform distribution</a>.
+<p>[<code>Uniform</code>] can obtain values with <a href="https://en.wikipedia.org/wiki/Uniform_distribution_(continuous)">uniform distribution</a>.
 This has the same effect, but may be faster when repeatedly generating numbers
 in the same range.</p>
-<pre><pre class="playground"><code class="language-rust edition2018">
-use rand::distributions::{Distribution, Uniform};
+<pre><pre class="playground"><code class="language-rust edition2018">use rand::Rng;
+use rand_distr::{Distribution, Uniform};
 
 fn main() {
     let mut rng = rand::rng();
-    let die = Uniform::from(1..7);
+    let die = Uniform::new_inclusive(1, 6)
+        .expect("Failed to create uniform distribution: invalid range");
 
     loop {
         let throw = die.sample(&amp;mut rng);
@@ -214,81 +209,92 @@ <h2 id="generate-random-numbers-with-given-distribution"><a class="header" href=
 <a href="https://en.wikipedia.org/wiki/Uniform_distribution_(continuous)">uniform distribution</a>. The <a href="https://docs.rs/rand_distr/*/rand_distr/index.html"><code>rand_distr</code></a> crate provides
 other kinds of distributions. To use them, you instantiate
 a distribution, then sample from that distribution using
-<a href="https://docs.rs/rand/*/rand/distributions/trait.Distribution.html#tymethod.sample"><code>Distribution::sample</code></a> with help of a random-number
-generator <a href="https://docs.rs/rand/*/rand/trait.Rng.html"><code>rand::Rng</code></a>.</p>
+<a href="https://docs.rs/rand/0.9/rand/distr/trait.Distribution.html#tymethod.sample"><code>Distribution::sample</code></a> with help of a random-number
+generator <a href="https://docs.rs/rand/0.9/rand/trait.Rng.html"><code>rand::Rng</code></a>.</p>
 <p>The <a href="https://docs.rs/rand_distr/*/rand_distr/index.html">distributions available are documented here</a>.
 An example using the <a href="https://docs.rs/rand_distr/*/rand_distr/struct.Normal.html"><code>Normal</code></a> distribution is shown below.</p>
-<pre><code class="language-rust edition2018 ignore">use rand_distr::{Distribution, Normal, NormalError};
-use rand::rng;
+<pre><pre class="playground"><code class="language-rust edition2018">use rand::Rng;
+use rand_distr::{Distribution, LogNormal, Normal};
+
+fn main() {
+    let mut rng = rand::rng();
+    let normal = Normal::new(2.0, 3.0)
+        .expect("Failed to create normal distribution");
+    let log_normal = LogNormal::new(1.0, 0.5)
+        .expect("Failed to create log-normal distribution");
 
-fn main() -&gt; Result&lt;(), NormalError&gt; {
-    let mut rng = rng();
-    let normal = Normal::new(2.0, 3.0)?;
     let v = normal.sample(&amp;mut rng);
     println!("{} is from a N(2, 9) distribution", v);
-    Ok(())
-}</code></pre>
+    let v = log_normal.sample(&amp;mut rng);
+    println!("{} is from an ln N(1, 0.25) distribution", v);
+}</code></pre></pre>
 <h2 id="generate-random-values-of-a-custom-type"><a class="header" href="#generate-random-values-of-a-custom-type">Generate random values of a custom type</a></h2>
 <p><a href="https://docs.rs/rand/"><img src="https://badge-cache.kominick.com/crates/v/rand.svg?label=rand" alt="rand-badge" /></a> <a href="https://crates.io/categories/science"><img src="https://badge-cache.kominick.com/badge/science--x.svg?style=social" alt="cat-science-badge" /></a></p>
 <p>Randomly generates a tuple <code>(i32, bool, f64)</code> and variable of user defined type <code>Point</code>.
-Implements the <a href="https://docs.rs/rand/*/rand/distributions/trait.Distribution.html"><code>Distribution</code></a> trait on type Point for <a href="https://docs.rs/rand/*/rand/distributions/struct.Standard.html"><code>Standard</code></a> in order to allow random generation.</p>
+Implements the [<code>Distribution</code>] trait on type Point for [<code>Standard</code>] in order to allow random generation.</p>
 <pre><pre class="playground"><code class="language-rust edition2018">use rand::Rng;
-use rand::distributions::{Distribution, Standard};
 
 #[derive(Debug)]
 struct Point {
     x: i32,
     y: i32,
 }
 
-impl Distribution&lt;Point&gt; for Standard {
-    fn sample&lt;R: Rng + ?Sized&gt;(&amp;self, rng: &amp;mut R) -&gt; Point {
-        let (rand_x, rand_y) = rng.random();
+impl Point {
+    fn random&lt;R: Rng&gt;(rng: &amp;mut R) -&gt; Self {
         Point {
-            x: rand_x,
-            y: rand_y,
+            x: rng.random(),
+            y: rng.random(),
         }
     }
 }
 
 fn main() {
     let mut rng = rand::rng();
     let rand_tuple = rng.random::&lt;(i32, bool, f64)&gt;();
-    let rand_point: Point = rng.random();
+    let rand_point = Point::random(&amp;mut rng);
     println!("Random tuple: {:?}", rand_tuple);
     println!("Random Point: {:?}", rand_point);
 }</code></pre></pre>
 <h2 id="create-random-passwords-from-a-set-of-alphanumeric-characters"><a class="header" href="#create-random-passwords-from-a-set-of-alphanumeric-characters">Create random passwords from a set of alphanumeric characters</a></h2>
 <p><a href="https://docs.rs/rand/"><img src="https://badge-cache.kominick.com/crates/v/rand.svg?label=rand" alt="rand-badge" /></a> <a href="https://crates.io/categories/os"><img src="https://badge-cache.kominick.com/badge/OS--x.svg?style=social" alt="cat-os-badge" /></a></p>
-<p>Randomly generates a string of given length ASCII characters in the range <code>A-Z, a-z, 0-9</code>, with <a href="https://docs.rs/rand/*/rand/distributions/struct.Alphanumeric.html"><code>Alphanumeric</code></a> sample.</p>
-<pre><pre class="playground"><code class="language-rust edition2018">use rand::{rng, Rng};
-use rand::distributions::Alphanumeric;
+<p>Randomly generates a string of given length ASCII characters in the range <code>A-Z, a-z, 0-9</code>, with <a href="https://docs.rs/rand/0.9/rand/distr/struct.Alphanumeric.html"><code>Alphanumeric</code></a> sample.</p>
+<pre><pre class="playground"><code class="language-rust edition2018">use rand::Rng;
 
 fn main() {
-    let rand_string: String = rng()
-        .sample_iter(&amp;Alphanumeric)
-        .take(30)
-        .map(char::from)
+    const CHARSET: &amp;[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
+                            abcdefghijklmnopqrstuvwxyz\
+                            0123456789";
+    const PASSWORD_LEN: usize = 30;
+    let mut rng = rand::rng();
+
+    let password: String = (0..PASSWORD_LEN)
+        .map(|_| {
+            let idx = rng.random_range(0..CHARSET.len());
+            CHARSET[idx] as char
+        })
         .collect();
 
-    println!("{}", rand_string);
+    println!("{}", password);
 }</code></pre></pre>
 <h2 id="create-random-passwords-from-a-set-of-user-defined-characters"><a class="header" href="#create-random-passwords-from-a-set-of-user-defined-characters">Create random passwords from a set of user-defined characters</a></h2>
 <p><a href="https://docs.rs/rand/"><img src="https://badge-cache.kominick.com/crates/v/rand.svg?label=rand" alt="rand-badge" /></a> <a href="https://crates.io/categories/os"><img src="https://badge-cache.kominick.com/badge/OS--x.svg?style=social" alt="cat-os-badge" /></a></p>
 <p>Randomly generates a string of given length ASCII characters with custom
-user-defined bytestring, with <a href="https://docs.rs/rand/*/rand/trait.Rng.html#method.random_range"><code>random_range</code></a>.</p>
-<pre><pre class="playground"><code class="language-rust edition2018">fn main() {
-    use rand::Rng;
-    const CHARSET: &amp;[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
-                            abcdefghijklmnopqrstuvwxyz\
-                            0123456789)(*&amp;^%$#@!~";
-    const PASSWORD_LEN: usize = 30;
+user-defined bytestring, with <a href="https://docs.rs/rand/0.9/rand/trait.Rng.html#method.gen_range"><code>gen_range</code></a>.</p>
+<pre><pre class="playground"><code class="language-rust edition2018">use rand::Rng;
+
+const CHARSET: &amp;[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
+                        abcdefghijklmnopqrstuvwxyz\
+                        0123456789)(*&amp;^%$#@!~";
+const PASSWORD_LEN: usize = 30;
+
+fn main() {
     let mut rng = rand::rng();
 
     let password: String = (0..PASSWORD_LEN)
         .map(|_| {
-            let idx = rng.random_range(0..CHARSET.len());
-            CHARSET[idx] as char
+            let idx = rng.gen_range(0..CHARSET.len());
+            char::from(CHARSET[idx])
         })
         .collect();
 

compression/tar.html

@@ -166,8 +166,7 @@ <h2 id="decompress-a-tarball"><a class="header" href="#decompress-a-tarball">Dec
 extract (<a href="https://docs.rs/tar/*/tar/struct.Archive.html#method.unpack"><code>Archive::unpack</code></a>) all files from a compressed tarball
 named <code>archive.tar.gz</code> located in the current working directory
 to the same location.</p>
-<pre><pre class="playground"><code class="language-rust edition2018 no_run">
-use std::fs::File;
+<pre><pre class="playground"><code class="language-rust edition2018 no_run">use std::fs::File;
 use flate2::read::GzDecoder;
 use tar::Archive;
 
@@ -189,8 +188,7 @@ <h2 id="compress-a-directory-into-tarball"><a class="header" href="#compress-a-d
 under <code>backup/logs</code> path with <a href="https://docs.rs/tar/*/tar/struct.Builder.html#method.append_dir_all"><code>Builder::append_dir_all</code></a>.
 <a href="https://docs.rs/flate2/*/flate2/write/struct.GzEncoder.html"><code>GzEncoder</code></a> is responsible for transparently compressing the
 data prior to writing it into <code>archive.tar.gz</code>.</p>
-<pre><pre class="playground"><code class="language-rust edition2018 no_run">
-use std::fs::File;
+<pre><pre class="playground"><code class="language-rust edition2018 no_run">use std::fs::File;
 use flate2::Compression;
 use flate2::write::GzEncoder;
 
@@ -203,8 +201,7 @@ <h2 id="compress-a-directory-into-tarball"><a class="header" href="#compress-a-d
     Ok(())
 }</code></pre></pre>
 <p>To add the contents without renaming them, an empty string can be used as the first argument of <a href="https://docs.rs/tar/*/tar/struct.Builder.html#method.append_dir_all"><code>Builder::append_dir_all</code></a>:</p>
-<pre><pre class="playground"><code class="language-rust edition2018 no_run">
-use std::fs::File;
+<pre><pre class="playground"><code class="language-rust edition2018 no_run">use std::fs::File;
 use flate2::Compression;
 use flate2::write::GzEncoder;
 
@@ -223,20 +220,13 @@ <h2 id="decompress-a-tarball-while-removing-a-prefix-from-the-paths"><a class="h
 <p>Iterate over the <a href="https://docs.rs/tar/*/tar/struct.Archive.html#method.entries"><code>Archive::entries</code></a>.  Use <a href="https://doc.rust-lang.org/std/path/struct.Path.html#method.strip_prefix"><code>Path::strip_prefix</code></a> to remove
 the specified path prefix (<code>bundle/logs</code>).  Finally, extract the <a href="https://docs.rs/tar/*/tar/struct.Entry.html"><code>tar::Entry</code></a>
 via <a href="https://docs.rs/tar/*/tar/struct.Entry.html#method.unpack"><code>Entry::unpack</code></a>.</p>
-<pre><pre class="playground"><code class="language-rust edition2018 no_run"><span class="boring">use error_chain::error_chain;
-</span>use std::fs::File;
+<pre><pre class="playground"><code class="language-rust edition2018 no_run">use anyhow::Result;
+use std::fs::File;
 use std::path::PathBuf;
 use flate2::read::GzDecoder;
 use tar::Archive;
-<span class="boring">
-</span><span class="boring">error_chain! {
-</span><span class="boring">  foreign_links {
-</span><span class="boring">    Io(std::io::Error);
-</span><span class="boring">    StripPrefixError(::std::path::StripPrefixError);
-</span><span class="boring">  }
-</span><span class="boring">}
-</span>
-fn main() -&gt; Result&lt;(), std::io::Error&gt; {
+
+fn main() -&gt; Result&lt;()&gt; {
     let file = File::open("archive.tar.gz")?;
     let mut archive = Archive::new(GzDecoder::new(file));
     let prefix = "bundle/logs";