05: discussion on generics + lifetimes + traits

Author: wprzytula

Cargo.toml

@@ -41,6 +41,18 @@ path = "content/lessons/03_data_types/result.rs"
 name = "05_basic_traits"
 path = "content/lessons/05_types_reasoning/basic_trait.rs"
 [[bin]]
+name = "05_basic_trait_display"
+path = "content/lessons/05_types_reasoning/basic_trait_display.rs"
+[[bin]]
+name = "05_trait_associated_types"
+path = "content/lessons/05_types_reasoning/trait_associated_type.rs"
+[[bin]]
+name = "05_trait_generic_types"
+path = "content/lessons/05_types_reasoning/trait_generic_type.rs"
+[[bin]]
+name = "05_impl_trait"
+path = "content/lessons/05_types_reasoning/impl_trait.rs"
+[[bin]]
 name = "05_generic_largest"
 path = "content/lessons/05_types_reasoning/generic_largest.rs"
 [[bin]]

content/lessons/05_types_reasoning/basic_trait_display.rs

@@ -0,0 +1,36 @@
+#![allow(dead_code)]
+
+use std::fmt::Display;
+
+struct NewsArticle {
+    headline: String,
+    location: String,
+    author: String,
+    content: String,
+}
+
+impl Display for NewsArticle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}, by {} ({})", self.headline, self.author, self.location)
+    }
+}
+
+struct Tweet {
+    username: String,
+    content: String,
+}
+
+impl Display for Tweet {    
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}: {}", self.username, self.content)
+    }
+}
+
+fn main() {
+    let tweet = Tweet {
+        username: String::from("horse_ebooks"),
+        content: String::from("of course, as you probably already know, people"),
+    };
+
+    println!("1 new tweet: {}", tweet);
+}

content/lessons/05_types_reasoning/impl_trait.rs

@@ -0,0 +1,65 @@
+#![allow(dead_code)]
+
+use std::fmt::Display;
+
+trait Summary {
+    fn summarize(&self) -> impl Display;
+}
+
+struct NewsArticle {
+    headline: String,
+    location: String,
+    author: String,
+    content: String,
+}
+
+impl Display for NewsArticle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "{}, by {} ({})", self.headline, self.author, self.location)?;
+        f.write_str(&self.content)
+    }
+}
+
+struct NewsArticleSummarizer<'a>(&'a NewsArticle);
+
+impl Display for NewsArticleSummarizer<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let article = self.0;
+        write!(f, "{}, by {} ({})", article.headline, article.author, article.location)
+    }
+}
+
+impl Summary for NewsArticle {
+    fn summarize(&self) -> impl Display {
+        NewsArticleSummarizer(self)
+    }
+}
+
+struct Tweet {
+    username: String,
+    content: String,
+}
+
+impl Summary for Tweet {
+    fn summarize(&self) -> impl Display {
+        struct TweetSummarizer<'a>(&'a Tweet);
+
+        impl Display for TweetSummarizer<'_> {
+            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                let tweet = self.0;
+                write!(f, "{}: {}", tweet.username, tweet.content)
+            }
+        }
+
+        TweetSummarizer(self)
+    }
+}
+
+fn main() {
+    let tweet = Tweet {
+        username: String::from("horse_ebooks"),
+        content: String::from("of course, as you probably already know, people"),
+    };
+
+    println!("1 new tweet: {}", tweet.summarize());
+}

content/lessons/05_types_reasoning/index.md

@@ -1,6 +1,6 @@
 +++
 title = "Reasoning About Types"
-date = 2024-10-23
+date = 2024-10-24
 weight = 1
 [extra]   
 lesson_date = 2024-10-24
@@ -321,6 +321,39 @@ There exists one special lifetime called `'static`, which means that a reference
 let s: &'static str = "I have a static lifetime.";
 ```
 
+# Trait + lifetimes - a challenging tandem
+
+Let's go back to our `basic_trait.rs` example. The `Summary` trait was really wasteful: it always allocated the `String`s on heap, even though we only needed to display the formatted string, and we could do that without allocations. How? By using `Display` trait, of course.
+
+The simplest possible optimisation would be like this:
+
+{{ include_code_sample(path="lessons/05_types_reasoning/basic_trait_display.rs", language="rust") }}
+
+This eliminates the heap allocations, but there's another catch. What if `NewsArticle` already had another (non-summarizing) `Display` implementation? We would end up in a double-trait-implementation conflict, which is a compile-time error.
+
+We can solve the one-type-one-trait-impl problem by introducing another type just for summarizing. The first attempt could be to use generics in traits:
+
+{{ include_code_sample(path="lessons/05_types_reasoning/trait_generic_type.rs", language="rust") }}
+
+The problem here is that nothing hinders us from implement the trait (with various type parameters) for the same type, which leads to awkward ambiguity when calling the trait's methods (see `main` fn).
+
+The use of generic types in `Summary` trait makes it semantics like this:
+
+> Any type can be summarized with any type supporting it.
+
+When we want the trait to require exactly one possible generic implementation for a given type, we can leverage *associated types*. Example here:
+
+{{ include_code_sample(path="lessons/05_types_reasoning/trait_associated_type.rs", language="rust") }}
+
+The use of associated types in Summary trait makes it semantics like this:
+
+> Any type can be summarized with at most one specific type.
+
+Yet another approach (arguably, the cleanest one) would be to use the `impl trait` syntax in a trait (quite recently stabilized!).
+Example:
+
+{{ include_code_sample(path="lessons/05_types_reasoning/impl_trait.rs", language="rust") }}
+
 # Obligatory reading
 
 - [The Book, chapter 10](https://doc.rust-lang.org/book/ch10-00-generics.html)

content/lessons/05_types_reasoning/trait_associated_type.rs

@@ -0,0 +1,69 @@
+#![allow(dead_code)]
+
+use std::fmt::Display;
+
+trait Summary<'a> {
+    type Summarizer: Display;
+
+    fn summarize(&'a self) -> Self::Summarizer;
+}
+
+struct NewsArticle {
+    headline: String,
+    location: String,
+    author: String,
+    content: String,
+}
+
+impl Display for NewsArticle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "{}, by {} ({})", self.headline, self.author, self.location)?;
+        f.write_str(&self.content)
+    }
+}
+
+struct NewsArticleSummarizer<'a>(&'a NewsArticle);
+
+impl Display for NewsArticleSummarizer<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let article = self.0;
+        write!(f, "{}, by {} ({})", article.headline, article.author, article.location)
+    }
+}
+
+impl<'a> Summary<'a> for NewsArticle {
+    type Summarizer = NewsArticleSummarizer<'a>;
+    fn summarize(&'a self) -> Self::Summarizer {
+        NewsArticleSummarizer(self)
+    }
+}
+
+struct Tweet {
+    username: String,
+    content: String,
+}
+
+struct TweetSummarizer<'a>(&'a Tweet);
+
+impl Display for TweetSummarizer<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let tweet = self.0;
+        write!(f, "{}: {}", tweet.username, tweet.content)
+    }
+}
+
+impl<'a> Summary<'a> for Tweet {
+    type Summarizer = TweetSummarizer<'a>;
+    fn summarize(&'a self) -> Self::Summarizer {
+        TweetSummarizer(self)
+    }
+}
+
+fn main() {
+    let tweet = Tweet {
+        username: String::from("horse_ebooks"),
+        content: String::from("of course, as you probably already know, people"),
+    };
+
+    println!("1 new tweet: {}", tweet.summarize());
+}

content/lessons/05_types_reasoning/trait_generic_type.rs

@@ -0,0 +1,82 @@
+#![allow(dead_code)]
+
+use std::fmt::Display;
+
+trait Summary<'a, Summarizer: Display> {
+    fn summarize(&'a self) -> Summarizer;
+}
+
+struct NewsArticle {
+    headline: String,
+    location: String,
+    author: String,
+    content: String,
+}
+
+impl Display for NewsArticle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "{}, by {} ({})", self.headline, self.author, self.location)?;
+        f.write_str(&self.content)
+    }
+}
+
+struct NewsArticleSummarizer<'a>(&'a NewsArticle);
+
+impl Display for NewsArticleSummarizer<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let article = self.0;
+        write!(f, "{}, by {} ({})", article.headline, article.author, article.location)
+    }
+}
+
+impl<'a> Summary<'a, NewsArticleSummarizer<'a>> for NewsArticle {
+    fn summarize(&'a self) -> NewsArticleSummarizer<'a> {
+        NewsArticleSummarizer(self)
+    }
+}
+
+struct Tweet {
+    username: String,
+    content: String,
+}
+
+struct TweetSummarizer<'a>(&'a Tweet);
+
+impl Display for TweetSummarizer<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let tweet = self.0;
+        write!(f, "{}: {}", tweet.username, tweet.content)
+    }
+}
+
+impl<'a> Summary<'a, TweetSummarizer<'a>> for Tweet {
+    fn summarize(&'a self) -> TweetSummarizer<'a> {
+        TweetSummarizer(self)
+    }
+}
+
+impl<'a> Summary<'a, NewsArticleSummarizer<'a>> for Tweet {
+    fn summarize(&'a self) -> NewsArticleSummarizer<'a> {
+        unimplemented!("This is only to make code type-check and compile.");
+    }
+}
+
+fn main() {
+    let empty_article = NewsArticle {
+        headline: "".into(),
+        location: String::new(),
+        author: String::default(),
+        content: Default::default(),
+    };
+    println!("1 new article: {}", empty_article.summarize());
+
+    let tweet = Tweet {
+        username: String::from("horse_ebooks"),
+        content: String::from("of course, as you probably already know, people"),
+    };
+
+    // Compile error: `type annotations needed; multiple `impl`s satisfying `Tweet: Summary<'_, _>` found`
+    // println!("1 new tweet: {}", tweet.summarize()); 
+    println!("1 new tweet: {}", <Tweet as Summary<'_, TweetSummarizer>>::summarize(&tweet));
+    println!("1 new tweet: {}", <Tweet as Summary<'_, NewsArticleSummarizer>>::summarize(&tweet));
+}