update original

Author: funkill

rust-by-example/src/error/option_unwrap/question_mark.md

@@ -28,6 +28,7 @@ struct Job {
 }
 
 #[derive(Clone, Copy)]
+#[allow(dead_code)]
 struct PhoneNumber {
     area_code: Option<u8>,
     number: u32,

rust-by-example/src/scope/lifetime/static_lifetime.md

@@ -73,16 +73,16 @@ live for the entire duration, but only from the leaking point onward.
 extern crate rand;
 use rand::Fill;
 
-fn random_vec() -> &'static [usize; 100] {
-    let mut rng = rand::thread_rng();
+fn random_vec() -> &'static [u64; 100] {
+    let mut rng = rand::rng();
     let mut boxed = Box::new([0; 100]);
-    boxed.try_fill(&mut rng).unwrap();
+    boxed.fill(&mut rng);
     Box::leak(boxed)
 }
 
 fn main() {
-    let first: &'static [usize; 100] = random_vec();
-    let second: &'static [usize; 100] = random_vec();
+    let first: &'static [u64; 100] = random_vec();
+    let second: &'static [u64; 100] = random_vec();
     assert_ne!(first, second)
 }
 ```

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

@@ -1,4 +1,4 @@
-# Clone
+# Clone and Copy
 
 When dealing with resources, the default behavior is to transfer them during
 assignments or function calls. However, sometimes we need to make a
@@ -7,19 +7,37 @@ copy of the resource as well.
 The [`Clone`][clone] trait helps us do exactly this. Most commonly, we can
 use the `.clone()` method defined by the `Clone` trait.
 
+## Copy: Implicit Cloning
+
+The [`Copy`][copy] trait allows a type to be duplicated simply by copying bits,
+with no additional logic required. When a type implements `Copy`, assignments
+and function calls will implicitly copy the value instead of moving it.
+
+**Important:** `Copy` requires `Clone` - any type that implements `Copy` must
+also implement `Clone`. This is because `Copy` is defined as a subtrait:
+`trait Copy: Clone {}`. The `Clone` implementation for `Copy` types simply
+copies the bits.
+
+Not all types can implement `Copy`. A type can only be `Copy` if:
+- All of its components are `Copy`
+- It doesn't manage external resources (like heap memory, file handles, etc.)
+
 ```rust,editable
 // A unit struct without resources
+// Note: Copy requires Clone, so we must derive both
 #[derive(Debug, Clone, Copy)]
 struct Unit;
 
 // A tuple struct with resources that implements the `Clone` trait
+// This CANNOT be Copy because Box<T> is not Copy
 #[derive(Clone, Debug)]
 struct Pair(Box<i32>, Box<i32>);
 
 fn main() {
     // Instantiate `Unit`
     let unit = Unit;
-    // Copy `Unit`, there are no resources to move
+    // Copy `Unit` - this is an implicit copy, not a move!
+    // Because Unit implements Copy, the value is duplicated automatically
     let copied_unit = unit;
 
     // Both `Unit`s can be used independently
@@ -31,6 +49,7 @@ fn main() {
     println!("original: {:?}", pair);
 
     // Move `pair` into `moved_pair`, moves resources
+    // Pair does not implement Copy, so this is a move
     let moved_pair = pair;
     println!("moved: {:?}", moved_pair);
 
@@ -39,6 +58,7 @@ fn main() {
     // TODO ^ Try uncommenting this line
 
     // Clone `moved_pair` into `cloned_pair` (resources are included)
+    // Unlike Copy, Clone is explicit - we must call .clone()
     let cloned_pair = moved_pair.clone();
     // Drop the moved original pair using std::mem::drop
     drop(moved_pair);
@@ -53,3 +73,4 @@ fn main() {
 ```
 
 [clone]: https://doc.rust-lang.org/std/clone/trait.Clone.html
+[copy]: https://doc.rust-lang.org/std/marker/trait.Copy.html

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

@@ -34,7 +34,48 @@ fn comp_sci_student_greeting(student: &dyn CompSciStudent) -> String {
     )
 }
 
-fn main() {}
+struct CSStudent {
+    name: String,
+    university: String,
+    fav_language: String,
+    git_username: String
+}
+
+impl Programmer for CSStudent {
+    fn fav_language(&self) -> String {
+        self.fav_language.clone()
+    }
+}
+
+impl Student for CSStudent {
+    fn university(&self) -> String {
+        self.university.clone()
+    }
+}
+
+impl Person for CSStudent {
+    fn name(&self) -> String {
+        self.name.clone()
+    }
+}
+
+impl CompSciStudent for CSStudent {
+    fn git_username(&self) -> String {
+        self.git_username.clone()
+    }
+}
+
+fn main() {
+    let student = CSStudent {
+        name: String::from("Alice"),
+        university: String::from("MIT"),
+        fav_language: String::from("Rust"),
+        git_username: String::from("alice_codes"),
+    };
+
+    let greeting = comp_sci_student_greeting(&student);
+    println!("{}", greeting);
+}
 ```
 
 ### See also: