m12-lifecycle

When should this resource be created, used, and cleaned up?

Before implementing lifecycle:

• What's the resource's scope?
• Who owns the cleanup responsibility?
• What happens on error?

---

| Pattern | When | Implementation |

|---------|------|----------------|

| RAII | Auto cleanup | Drop trait |

| Lazy init | Deferred creation | OnceLock, LazyLock |

| Pool | Reuse expensive resources | r2d2, deadpool |

| Guard | Scoped access | MutexGuard pattern |

| Scope | Transaction boundary | Custom struct + Drop |

---

Before designing lifecycle:

1. What's the resource cost?

- Cheap → create per use

- Expensive → pool or cache

- Global → lazy singleton

1. What's the scope?

- Function-local → stack allocation

- Request-scoped → passed or extracted

- Application-wide → static or Arc

1. What about errors?

- Cleanup must happen → Drop

- Cleanup is optional → explicit close

- Cleanup can fail → Result from close

---

To domain constraints (Layer 3):

```

"How should I manage database connections?"

↑ Ask: What's the connection cost?

↑ Check: domain-* (latency requirements)

↑ Check: Infrastructure (connection limits)

```

| Question | Trace To | Ask |

|----------|----------|-----|

| Connection pooling | domain-* | What's acceptable latency? |

| Resource limits | domain-* | What are infra constraints? |

| Transaction scope | domain-* | What must be atomic? |

---

To implementation (Layer 1):

```

"Need automatic cleanup"

↓ m02-resource: Implement Drop

↓ m01-ownership: Clear owner for cleanup

"Need lazy initialization"

↓ m03-mutability: OnceLock for thread-safe

↓ m07-concurrency: LazyLock for sync

"Need connection pool"

↓ m07-concurrency: Thread-safe pool

↓ m02-resource: Arc for sharing

```

---

| Pattern | Type | Use Case |

|---------|------|----------|

| RAII | Drop trait | Auto cleanup on scope exit |

| Lazy Init | OnceLock, LazyLock | Deferred initialization |

| Pool | r2d2, deadpool | Connection reuse |

| Guard | MutexGuard | Scoped lock release |

| Scope | Custom struct | Transaction boundaries |

| Event | Rust Mechanism |

|-------|----------------|

| Creation | new(), Default |

| Lazy Init | OnceLock::get_or_init |

| Usage | &self, &mut self |

| Cleanup | Drop::drop() |

RAII Guard

```rust

struct FileGuard {

path: PathBuf,

_handle: File,

}

impl Drop for FileGuard {

fn drop(&mut self) {

// Cleanup: remove temp file

let _ = std::fs::remove_file(&self.path);

}

}

```

Lazy Singleton

```rust

use std::sync::OnceLock;

static CONFIG: OnceLock = OnceLock::new();

fn get_config() -> &'static Config {

CONFIG.get_or_init(|| {

Config::load().expect("config required")

})

}

```

---

| Error | Cause | Fix |

|-------|-------|-----|

| Resource leak | Forgot Drop | Implement Drop or RAII wrapper |

| Double free | Manual memory | Let Rust handle |

| Use after drop | Dangling reference | Check lifetimes |

| E0509 move out of Drop | Moving owned field | Option::take() |

| Pool exhaustion | Not returned | Ensure Drop returns |

---

| Anti-Pattern | Why Bad | Better |

|--------------|---------|--------|

| Manual cleanup | Easy to forget | RAII/Drop |

| lazy_static! | External dep | std::sync::OnceLock |

| Global mutable state | Thread unsafety | OnceLock or proper sync |

| Forget to close | Resource leak | Drop impl |

---

| When | See |

|------|-----|

| Smart pointers | m02-resource |

| Thread-safe init | m07-concurrency |

| Domain scopes | m09-domain |

| Error in cleanup | m06-error-handling |