M12 Lifecycle

Resource Lifecycle

Layer 2: Design Choices

Core Question

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?

Lifecycle Pattern → Implementation

Thinking Prompt

Before designing lifecycle:

1. What's the resource cost?

   • Cheap → create per use
   • Expensive → pool or cache
   • Global → lazy singleton

2. What's the scope?

   • Function-local → stack allocation
   • Request-scoped → passed or extracted
   • Application-wide → static or Arc

3. What about errors?

   • Cleanup must happen → Drop
   • Cleanup is optional → explicit close
   • Cleanup can fail → Result from close

Trace Up ↑

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)

Trace Down ↓

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

Quick Reference

Lifecycle Events

Pattern Templates

RAII Guard

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

use std::sync::OnceLock;
static CONFIG: OnceLock<Config> = OnceLock::new();
fn get_config() -> &'static Config {    CONFIG.get_or_init(|| {        Config::load().expect("config required")    })}

Common Errors

Anti-Patterns

Related Skills