rust-lifetime-complex

Advanced lifetime expert covering HRTB, GAT, 'static bounds, trait object constraints, type system conflicts, and lifetime elision edge cases.triggers: - lifetime - HRTB - GAT - higher-ranked - 'static - trait object - one type is more general - lifetime conflict--- # Advanced Lifetime and Type System Expert ## Core Question **Why won't this type conversion compile?** The type system's boundaries are often surprising.

Jump to install

Repository: huiali/rust-skills
Last source activity: February 9, 2026 at 07:17
Detected SKILL.md language: English
Stars: 44
Forks: 7

Install options

The review-first prompt is selected by default. You can switch to a direct command or download a local copy.

Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.

A direct command skips the review prompt. Inspect the source before running it.

npx skills add https://github.com/huiali/rust-skills --skill rust-lifetime-complex

The command stays on one line. Scroll horizontally to inspect it before copying.

Prefer a local copy? Download the files currently available to SkillsMP.

Review the source files

Read SKILL.md and any companion files shown by SkillsMP before deciding whether to install.

File Explorer

4 files

SKILL.md

Source instructions · Read-only preview

Back to search Back to installation

// Problem: GAT makes trait non-object-safe

// ❌ Can't use dyn with GAT
trait Repository {
    type Row<'a>: RowView<'a>;  // GAT
    fn query<'a>(&'a self) -> Vec<Self::Row<'a>>;
}
// let repo: Box<dyn Repository> = ...;  // Error!

// ✅ Solution: Layered architecture
trait InternalRepo {
    type Row<'a>: RowView<'a>;  // GAT for internal use
    fn query_borrowed<'a>(&'a self) -> Vec<Self::Row<'a>>;
}

trait PublicRepo: Send + Sync {
    fn query(&self) -> Vec<RowDto>;  // Owned data
}

// Adapter converts borrowed -> owned
impl<T: InternalRepo> PublicRepo for T {
    fn query(&self) -> Vec<RowDto> {
        self.query_borrowed()
            .into_iter()
            .map(|row| row.to_dto())
            .collect()
    }
}

// Problem: 'static requirement conflicts with borrowing

// ❌ Can't borrow when 'static required
async fn bad_resolver(&self, ctx: &Context) -> Result<&Data> {
    // Error: lifetime 'a not 'static
}

// ✅ Solution: Return owned data
async fn good_resolver(&self, ctx: &Context) -> Result<DataDto> {
    let borrowed = self.repo.query().await?;
    Ok(borrowed.to_owned_dto())
}

// Alternative: Use Arc for shared ownership
async fn shared_resolver(&self) -> Result<Arc<Data>> {
    Ok(Arc::clone(&self.cached_data))
}

// Problem: Compiler can't infer lifetime

// ❌ Ambiguous lifetime
struct Parser<'a> {
    input: &'a str,
}

impl<'a> Parser<'a> {
    fn parse(&self) -> Result<&str, Error> {
        // Which lifetime? 'a or 'self?
        // Compiler can't tell
    }
}

// ✅ Explicit lifetime annotation
impl<'a> Parser<'a> {
    fn parse<'b>(&'b self) -> Result<&'a str, Error> {
        // Returns data from input, not self
        Ok(&self.input[..10])
    }
}

// Problem: Holding references across await

// ❌ Can't hold borrow across await
async fn bad_async() {
    let data = get_data();
    let borrowed = &data.field;

    some_async_call().await;  // Error: data might move

    use_borrowed(borrowed);
}

// ✅ Solution 1: Clone before await
async fn good_async_clone() {
    let data = get_data();
    let owned = data.field.clone();

    some_async_call().await;  // OK

    use_owned(&owned);
}

// ✅ Solution 2: Drop borrow before await
async fn good_async_scope() {
    let data = get_data();
    let value = {
        let borrowed = &data.field;
        extract_value(borrowed)
    };  // borrow dropped

    some_async_call().await;  // OK
}

Pattern	Cause	Solution
HRTB → dyn	Concrete vs universal lifetime	Use generic functions
GAT → dyn	Variable-sized associated types	Layered design with owned DTOs
'static + borrow	Lifetime contradiction	Return owned data
Async + borrow	Future holds state across await	Clone or drop before await
Closure capture + Send	Lifetime issues	Use 'static or Arc

// Decision factors:
fn should_use_owned() -> bool {
    // ✅ Use owned if:
    // - Complex lifetime interactions
    // - API boundaries
    // - Async contexts
    // - Multi-threaded sharing

    // ✅ Keep borrowing if:
    // - Large data structures
    // - Hot path performance
    // - Simple lifetime relationships
    // - Internal implementation only

    true
}

Common errors:
  "one type is more general" → HRTB + dyn conflict
  "lifetime may not live long enough" → Borrow exceeds scope
  "cannot be made into object" → GAT or HRTB in trait
  "does not live long enough" → Early drop

Options:
  → Simplify: Remove abstraction
  → Split: Separate borrowed/owned layers
  → Clone: Accept allocation cost
  → Arc: Shared ownership
  → Redesign: Change data flow

Check:
  → Compiles without hacky workarounds
  → Reasonable complexity
  → Performance acceptable
  → Maintainable long-term

// Reduce to minimal reproduction
// Remove generics, traits, async one by one
// Find the core conflict

// Write out all lifetime parameters
// Makes relationships visible
fn explicit<'a, 'b>(x: &'a str, y: &'b str) -> &'a str {
    x
}

// Not all designs can compile
// Sometimes owned data is the answer
// Complexity has limits

# Check for lifetime errors
cargo check

# Expand to see generated code
cargo expand

# Verify no borrow checker issues
cargo clippy

rust-lifetime-complex

Install options

Review the source files

Solution Patterns

Pattern 1: HRTB (Higher-Ranked Trait Bounds)

Solution Patterns

Pattern 1: HRTB (Higher-Ranked Trait Bounds)

Pattern 2: GAT + Object Safety

Pattern 3: Static Bound Conflicts

Pattern 4: Lifetime Elision Edge Cases

Pattern 5: Async + Lifetime Conflicts

Common Conflict Patterns

When to Give Up Borrowing

Performance vs Maintainability

Rule of Thumb

Workflow

Step 1: Diagnose Error

Step 2: Choose Strategy

Step 3: Validate Solution

Debugging Techniques

Minimize

Explicit Lifetimes

Accept Reality

Review Checklist

Verification Commands

Related Skills

Localized Reference

rust-lifetime-complex

Source facts

Install options

Review the source files

More from this repository

More from this repository

Solution Patterns

Pattern 1: HRTB (Higher-Ranked Trait Bounds)

Solution Patterns

Pattern 1: HRTB (Higher-Ranked Trait Bounds)

Pattern 2: GAT + Object Safety

Pattern 3: Static Bound Conflicts

Pattern 4: Lifetime Elision Edge Cases

Pattern 5: Async + Lifetime Conflicts

Common Conflict Patterns

When to Give Up Borrowing

Performance vs Maintainability

Rule of Thumb

Workflow

Step 1: Diagnose Error

Step 2: Choose Strategy

Step 3: Validate Solution

Debugging Techniques

Minimize

Explicit Lifetimes

Accept Reality

Review Checklist

Verification Commands

Related Skills

Localized Reference