rc1 solution

exercises/19_smart_pointers/rc1.rs

@@ -1,15 +1,12 @@
 // In this exercise, we want to express the concept of multiple owners via the
-// Rc<T> type. This is a model of our solar system - there is a Sun type and
+// `Rc<T>` type. This is a model of our solar system - there is a `Sun` type and
-// multiple Planets. The Planets take ownership of the sun, indicating that they
+// multiple `Planet`s. The planets take ownership of the sun, indicating that
-// revolve around the sun.
+// they revolve around the sun.
-//
-// Make this code compile by using the proper Rc primitives to express that the
-// sun has multiple owners.
 
 use std::rc::Rc;
 
 #[derive(Debug)]
-struct Sun {}
+struct Sun;
 
 #[derive(Debug)]
 enum Planet {
@@ -25,7 +22,7 @@ enum Planet {
 
 impl Planet {
     fn details(&self) {
-        println!("Hi from {:?}!", self)
+        println!("Hi from {self:?}!");
     }
 }
 
@@ -39,7 +36,7 @@ mod tests {
 
     #[test]
     fn rc1() {
-        let sun = Rc::new(Sun {});
+        let sun = Rc::new(Sun);
         println!("reference count = {}", Rc::strong_count(&sun)); // 1 reference
 
         let mercury = Planet::Mercury(Rc::clone(&sun));
@@ -63,17 +60,17 @@ mod tests {
         jupiter.details();
 
         // TODO
-        let saturn = Planet::Saturn(Rc::new(Sun {}));
+        let saturn = Planet::Saturn(Rc::new(Sun));
         println!("reference count = {}", Rc::strong_count(&sun)); // 7 references
         saturn.details();
 
         // TODO
-        let uranus = Planet::Uranus(Rc::new(Sun {}));
+        let uranus = Planet::Uranus(Rc::new(Sun));
         println!("reference count = {}", Rc::strong_count(&sun)); // 8 references
         uranus.details();
 
         // TODO
-        let neptune = Planet::Neptune(Rc::new(Sun {}));
+        let neptune = Planet::Neptune(Rc::new(Sun));
         println!("reference count = {}", Rc::strong_count(&sun)); // 9 references
         neptune.details();
 

rustlings-macros/info.toml

@@ -993,11 +993,11 @@ of the `Sun`.
 After using `drop()` to move the `Planet`s out of scope individually, the
 reference count goes down.
 
-In the end the `Sun` only has one reference again, to itself.
+In the end, the `Sun` only has one reference again, to itself.
 
 See more at: https://doc.rust-lang.org/book/ch15-04-rc.html
 
-* Unfortunately Pluto is no longer considered a planet :("""
+Unfortunately, Pluto is no longer considered a planet :("""
 
 [[exercises]]
 name = "arc1"

solutions/19_smart_pointers/rc1.rs

@@ -1 +1,104 @@
-// Solutions will be available before the stable release. Thank you for testing the beta version 🥰
+// In this exercise, we want to express the concept of multiple owners via the
+// `Rc<T>` type. This is a model of our solar system - there is a `Sun` type and
+// multiple `Planet`s. The planets take ownership of the sun, indicating that
+// they revolve around the sun.
+
+use std::rc::Rc;
+
+#[derive(Debug)]
+struct Sun;
+
+#[derive(Debug)]
+enum Planet {
+    Mercury(Rc<Sun>),
+    Venus(Rc<Sun>),
+    Earth(Rc<Sun>),
+    Mars(Rc<Sun>),
+    Jupiter(Rc<Sun>),
+    Saturn(Rc<Sun>),
+    Uranus(Rc<Sun>),
+    Neptune(Rc<Sun>),
+}
+
+impl Planet {
+    fn details(&self) {
+        println!("Hi from {self:?}!");
+    }
+}
+
+fn main() {
+    // You can optionally experiment here.
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn rc1() {
+        let sun = Rc::new(Sun);
+        println!("reference count = {}", Rc::strong_count(&sun)); // 1 reference
+
+        let mercury = Planet::Mercury(Rc::clone(&sun));
+        println!("reference count = {}", Rc::strong_count(&sun)); // 2 references
+        mercury.details();
+
+        let venus = Planet::Venus(Rc::clone(&sun));
+        println!("reference count = {}", Rc::strong_count(&sun)); // 3 references
+        venus.details();
+
+        let earth = Planet::Earth(Rc::clone(&sun));
+        println!("reference count = {}", Rc::strong_count(&sun)); // 4 references
+        earth.details();
+
+        let mars = Planet::Mars(Rc::clone(&sun));
+        println!("reference count = {}", Rc::strong_count(&sun)); // 5 references
+        mars.details();
+
+        let jupiter = Planet::Jupiter(Rc::clone(&sun));
+        println!("reference count = {}", Rc::strong_count(&sun)); // 6 references
+        jupiter.details();
+
+        let saturn = Planet::Saturn(Rc::clone(&sun));
+        println!("reference count = {}", Rc::strong_count(&sun)); // 7 references
+        saturn.details();
+
+        // TODO
+        let uranus = Planet::Uranus(Rc::clone(&sun));
+        println!("reference count = {}", Rc::strong_count(&sun)); // 8 references
+        uranus.details();
+
+        // TODO
+        let neptune = Planet::Neptune(Rc::clone(&sun));
+        println!("reference count = {}", Rc::strong_count(&sun)); // 9 references
+        neptune.details();
+
+        assert_eq!(Rc::strong_count(&sun), 9);
+
+        drop(neptune);
+        println!("reference count = {}", Rc::strong_count(&sun)); // 8 references
+
+        drop(uranus);
+        println!("reference count = {}", Rc::strong_count(&sun)); // 7 references
+
+        drop(saturn);
+        println!("reference count = {}", Rc::strong_count(&sun)); // 6 references
+
+        drop(jupiter);
+        println!("reference count = {}", Rc::strong_count(&sun)); // 5 references
+
+        drop(mars);
+        println!("reference count = {}", Rc::strong_count(&sun)); // 4 references
+
+        drop(earth);
+        println!("reference count = {}", Rc::strong_count(&sun)); // 3 references
+
+        drop(venus);
+        println!("reference count = {}", Rc::strong_count(&sun)); // 2 references
+
+        drop(mercury);
+        println!("reference count = {}", Rc::strong_count(&sun)); // 1 reference
+
+        assert_eq!(Rc::strong_count(&sun), 1);
+    }
+}