update original

Author: funkill

rust-by-example/src/flow_control/for.md

@@ -80,7 +80,7 @@ fn main() {
   data is provided. Once the collection has been consumed it is no longer
   available for reuse as it has been 'moved' within the loop.
 
-```rust,editable,ignore,mdbook-runnable
+```rust,editable
 fn main() {
     let names = vec!["Bob", "Frank", "Ferris"];
 
@@ -91,8 +91,9 @@ fn main() {
         }
     }
 
-    println!("names: {:?}", names);
-    // FIXME ^ Comment out this line
+    // `names` has been 'moved' and can no longer be used.
+    // Try uncommenting the line below to see the compiler error:
+    // println!("names: {:?}", names);
 }
 ```
 

rust-by-example/src/fn/closures/closure_examples/iter_find.md

@@ -42,9 +42,12 @@ fn main() {
     let array1 = [1, 2, 3];
     let array2 = [4, 5, 6];
 
-    // `array1.iter()` yields `&i32`
+    // `array1.iter()` yields `&i32`, and `find` passes `&Item` to the
+    // predicate. Since `Item = &i32`, the closure argument has type `&&i32`.
     println!("Find 2 in array1: {:?}", array1.iter().find(|&&x| x == 2));
-    // `array2.into_iter()` yields `i32`
+    // `array2.into_iter()` yields `i32` (since Rust 2021 edition), and
+    // `find` passes `&Item` to the predicate. Since `Item = i32`, the
+    // closure argument has type `&i32`.
     println!("Find 2 in array2: {:?}", array2.into_iter().find(|&x| x == 2));
 }
 ```

rust-by-example/src/generics/new_types.md

@@ -3,51 +3,50 @@
 The `newtype` idiom gives compile time guarantees that the right type of value is supplied
 to a program.
 
-For example, an age verification function that checks age in years, *must* be given
-a value of type `Years`.
+For example, a function that measures distance in miles, *must* be given
+a value of type `Miles`.
 
 ```rust, editable
-struct Years(i64);
+struct Miles(f64);
 
-struct Days(i64);
+struct Kilometers(f64);
 
-impl Years {
-    pub fn to_days(&self) -> Days {
-        Days(self.0 * 365)
+impl Miles {
+    pub fn to_kilometers(&self) -> Kilometers {
+        Kilometers(self.0 * 1.609344)
     }
 }
 
-impl Days {
-    /// truncates partial years
-    pub fn to_years(&self) -> Years {
-        Years(self.0 / 365)
+impl Kilometers {
+    pub fn to_miles(&self) -> Miles {
+        Miles(self.0 / 1.609344)
     }
 }
 
-fn is_adult(age: &Years) -> bool {
-    age.0 >= 18
+fn is_a_marathon(distance: &Miles) -> bool {
+    distance.0 >= 26.2
 }
 
 fn main() {
-    let age = Years(25);
-    let age_days = age.to_days();
-    println!("Is an adult? {}", is_adult(&age));
-    println!("Is an adult? {}", is_adult(&age_days.to_years()));
-    // println!("Is an adult? {}", is_adult(&age_days));
+    let distance = Miles(30.0);
+    let distance_km = distance.to_kilometers();
+    println!("Is a marathon? {}", is_a_marathon(&distance));
+    println!("Is a marathon? {}", is_a_marathon(&distance_km.to_miles()));
+    // println!("Is a marathon? {}", is_a_marathon(&distance_km));
 }
 ```
 
-Uncomment the last print statement to observe that the type supplied must be `Years`.
+Uncomment the last print statement to observe that the type supplied must be `Miles`.
 
 To obtain the `newtype`'s value as the base type, you may use the tuple or destructuring syntax like so:
 
 ```rust, editable
-struct Years(i64);
+struct Miles(f64);
 
 fn main() {
-    let years = Years(42);
-    let years_as_primitive_1: i64 = years.0; // Tuple
-    let Years(years_as_primitive_2) = years; // Destructuring
+    let distance = Miles(42.0);
+    let distance_as_primitive_1: f64 = distance.0; // Tuple
+    let Miles(distance_as_primitive_2) = distance; // Destructuring
 }
 ```
 

rust-by-example/src/hello/print.md

@@ -87,7 +87,7 @@ for these types. To print text for custom types, more steps are required.
 Implementing the `fmt::Display` trait automatically implements the
 [`ToString`] trait which allows us to [convert] the type to [`String`][string].
 
-In *line 43*, `#[allow(dead_code)]` is an [attribute] which only applies to the module after it.
+In *line 43*, `#[allow(dead_code)]` is an [attribute] which only applies to the item after it.
 
 ### Activities
 

rust-by-example/src/hello/print/print_display.md

@@ -94,8 +94,9 @@ fn main() {
     println!("Display: {}", point);
     println!("Debug: {:?}", point);
 
-    // Error. Both `Debug` and `Display` were implemented, but `{:b}`
-    // requires `fmt::Binary` to be implemented. This will not work.
+    // The following line would not compile: both `Debug` and `Display`
+    // were implemented, but `{:b}` requires `fmt::Binary` to be
+    // implemented, which it hasn't been for `Point2D`.
     // println!("What does Point2D look like in binary: {:b}?", point);
 }
 ```

rust-by-example/src/hello/print/print_display/testcase_list.md

@@ -24,8 +24,7 @@ struct List(Vec<i32>);
 
 impl fmt::Display for List {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        // Extract the value using tuple indexing,
-        // and create a reference to `vec`.
+        // Create a reference to the Vec<i32> stored in the List struct.
         let vec = &self.0;
 
         write!(f, "[")?;

rust-by-example/src/trait/drop.md

@@ -76,15 +76,19 @@ impl TempFile {
 }
 
 // When TempFile is dropped:
-// 1. First, our drop implementation will remove the file's name from the filesystem.
-// 2. Then, File's drop will close the file, removing its underlying content from the disk.
+// 1. First, our custom drop implementation runs. The file is still open at this point,
+//    but we can remove it from the filesystem by path.
+// 2. Then, after our drop returns, Rust automatically drops each field,
+//    so File's drop runs and closes the file handle.
 impl Drop for TempFile {
     fn drop(&mut self) {
+        // Note: the File is still open here — field destructors run after this method.
         if let Err(e) = std::fs::remove_file(&self.path) {
             eprintln!("Failed to remove temporary file: {}", e);
         }
         println!("> Dropped temporary file: {:?}", self.path);
-        // File's drop is implicitly called here because it is a field of this struct.
+        // After this method returns, Rust will drop each field (including `file`),
+        // which closes the underlying file handle.
     }
 }