07: use new examples

Author: wprzytula

content/lessons/07_smart_pointers/index.md

@@ -20,7 +20,7 @@ The `Deref` trait allows us to overload the dereference (`*`) operator.
 
 Apart from enabling access to the underlying value, implementing the `Deref` trait enables Rust to perform _deref coercion_ on the pointer - trying to remove as many levels of indirection as it can. What it means in practice is that we will be able to use it with any code working on plain references.
 
-{{ include_code_sample(path="lessons/old/2021L/10_smart_pointers/deref_coercion.rs", language="rust") }}
+{{ include_code_sample(path="lessons/07_smart_pointers/deref_coercion.rs", language="rust") }}
 
 In general, there are three possible coercions that Rust can perform:
 
@@ -36,23 +36,29 @@ While the first two coercions are straightforward, the third one is possible bec
 
 The `Box<T>` type is the most basic out of Rust's smart pointers, equivalent to C++'s `std::unique_ptr<T>`. It's a simple wrapper that makes sure the underlying memory gets allocated and freed properly.
 
-{{ include_code_sample(path="lessons/old/2021L/10_smart_pointers/box.rs", language="rust") }}
+{{ include_code_sample(path="lessons/07_smart_pointers/box.rs", language="rust") }}
 
 # Reference counting
 
 The `Rc<T>` type is the equivalent of `std::shared_ptr<T>` from C++. There is one caveat to this though - because we're creating multiple references to the same object, those references have to be immutable in accordance with the ownership rules.
 
-{{ include_code_sample(path="lessons/old/2021L/10_smart_pointers/ref_count.rs", language="rust") }}
+{{ include_code_sample(path="lessons/07_smart_pointers/ref_count.rs", language="rust") }}
 
 Rust also provides a non-owning pointer in the form of `Weak<T>` (equivalent to `std::weak_ptr<T>`) that can be obtained from an instance of `Rc<T>`.
 
-{{ include_code_sample(path="lessons/old/2021L/10_smart_pointers/weak_ref.rs", language="rust") }}
+{{ include_code_sample(path="lessons/07_smart_pointers/weak_ref.rs", language="rust") }}
 
 # Mutating the immutable
 
 Good examples and explanation of the interior mutability pattern and runtime borrow checking can be found in the [book](https://doc.rust-lang.org/book/ch15-05-interior-mutability.html).
 
-Alongisde the `RefCell<T>` type described above, there is an analogous [`Cell<T>`](https://doc.rust-lang.org/std/cell/struct.Cell.html) type that operates on values instead of references.
+Alongside the `RefCell<T>` type described above, there is an analogous [`Cell<T>`](https://doc.rust-lang.org/std/cell/struct.Cell.html) type that operates on values instead of references.
+
+# Convenient handling of `dyn` objects
+
+In previous labs you learned about dynamic dispatch and its strengths. The largest drawback you noticed is most likely that they are _unsized_ (`!Sized`, where `!` being syntax signifying lack of trait implementation).
+
+When storing an object on a heap, however, we can use it as a `dyn` object seamlessly.
 
 # Obligatory reading