Merge pull request #72 from ojob/main

Rust Patterns, ch01: ensure doctests are verifiable

Author: atulkhare4096

rust-patterns-book/src/ch01-generics-the-full-picture.md

@@ -40,12 +40,14 @@ fn max_of_str<'a>(a: &'a str, b: &'a str) -> &'a str { if a >= b { a } else { b
 
 **Comparison with C++**: Rust generics work like C++ templates but with one crucial difference — **bounds checking happens at definition, not instantiation**. In C++, a template compiles only when used with a specific type, leading to cryptic error messages deep in library code. In Rust, `T: PartialOrd` is checked when you define the function, so errors are caught early and messages are clear.
 
-```rust
+```rust,compile_fail
 // Rust: error at definition site — "T doesn't implement Display"
 fn broken<T>(val: T) {
     println!("{val}"); // ❌ Error: T doesn't implement Display
 }
+```
 
+```rust
 // Fix: add the bound
 fn fixed<T: std::fmt::Display>(val: T) {
     println!("{val}"); // ✅
@@ -56,7 +58,7 @@ fn fixed<T: std::fmt::Display>(val: T) {
 
 Monomorphization has a cost — binary size. Each unique instantiation duplicates the function body:
 
-```rust
+```rust,ignore
 // This innocent function...
 fn serialize<T: serde::Serialize>(value: &T) -> Vec<u8> {
     serde_json::to_vec(value).unwrap()
@@ -67,7 +69,7 @@ fn serialize<T: serde::Serialize>(value: &T) -> Vec<u8> {
 
 **Mitigation strategies**:
 
-```rust
+```rust,ignore
 // 1. Extract the non-generic core ("outline" pattern)
 fn serialize<T: serde::Serialize>(value: &T) -> Result<Vec<u8>, serde_json::Error> {
     // Generic part: only the serialization call
@@ -102,7 +104,7 @@ Three ways to handle "different types, same interface" in Rust:
 | **Enum** | Match arm | Compile time | ❌ (closed set) | Zero — no vtable |
 | **Trait object** (`dyn Trait`) | Dynamic (vtable) | Runtime | ✅ (open set) | Vtable pointer + indirect call |
 
-```rust
+```rust,ignore
 // --- GENERICS: Open set, zero cost, compile-time ---
 fn process<H: Handler>(handler: H, request: Request) -> Response {
     handler.handle(request) // Monomorphized — one copy per H
@@ -349,6 +351,10 @@ impl<K: Eq + Hash + Clone, V> Cache<K, V> {
     }
 
     fn insert(&mut self, key: K, value: V) {
+        if self.capacity == 0 {
+            // no capacity!
+            return;
+        }
         if self.map.contains_key(&key) {
             self.map.insert(key, value);
             return;
@@ -372,6 +378,7 @@ impl<K: Eq + Hash + Clone, V> Cache<K, V> {
 }
 
 fn main() {
+    // Test of a basic cache
     let mut cache = Cache::new(3);
     cache.insert("a", 1);
     cache.insert("b", 2);
@@ -381,6 +388,14 @@ fn main() {
     cache.insert("d", 4); // Evicts "a"
     assert_eq!(cache.get(&"a"), None);
     assert_eq!(cache.get(&"d"), Some(&4));
+
+    // Left to the reader: what type should `capacity` attribute be,
+    // to ensure that such a useless cache cannot be defined?
+    let mut empty_cache = Cache::new(0);
+    empty_cache.insert("0", 0);
+    assert_eq!(empty_cache.get(&"0"), None);
+    assert_eq!(empty_cache.len(), 0);
+
     println!("Cache works! len = {}", cache.len());
 }
 ```