使用带生命周期参数的 trait 作为泛型约束的问题

问题背景 #

我尝试通过Context trait的不同实现，让Cell以不同方式访问所属的World，现有可编译代码如下：

struct Cell {    
    value: i32,    
} 
    
impl Cell {    
    fn evolve<'a>(&self, ctx: impl Context<'a>) -> Cell {    
        Cell {    
            value: self.value + ctx.get_rate()    
        }    
    }    
}    
    
struct World {    
    cell: Cell,    
    magic: i32,    
}    
    
impl World {    
    fn evolve_cell<'a, C: Context<'a>>(&'a self) -> Cell {    
        let ctx = C::new(self);        
        self.cell.evolve(ctx)        
    }    
        
    fn update(&mut self) {    
        self.cell = self.evolve_cell::<MagicContext>();    
    }    
}        
         
trait Context<'a> {    
    fn new(world: &'a World) -> Self;    
    fn get_rate(&self) -> i32;    
}    
     
struct MagicContext<'a> {    
    world: &'a World,        
}                            
                             
impl<'a> Context<'a> for MagicContext<'a> {                      
    fn new(world: &'a World) -> Self {    
        MagicContext {    
            world    
        }    
    }        
              
    fn get_rate(&self) -> i32 {    
        self.world.magic    
    }    
}        
         
fn main() {    
    let mut world = World {    
        cell: Cell { value: 2 },    
        magic: 3,    
    };    
          
    world.update();    
    println!("{}", world.cell.value);    
}

我希望不在World::update中硬编码MagicContext，而是在main调用时指定具体的Context实现，比如：

impl World {    
    // ...
    fn update<C: Context>(&mut self) {    
        self.cell = self.evolve_cell::<C>();    
    }
}

// ...
fn main() {
    // ...
    world.update::<MagicContext>();
    // ...
}

但引入生命周期参数fn update<'a, C: Context<'a>>(&'a mut self)会导致编译错误：

error[E0506]: cannot assign to `self.cell` because it is borrowed
  --> lifetime.rs:25:9
   |
24 |     fn update<'a, C: Context<'a>>(&'a mut self) {
   |               -- lifetime `'a` defined here
25 |         self.cell = self.evolve_cell::<C>();
   |         ^^^^^^^^^^^^-----------------------
   |         |           |
   |         |           borrow of `self.cell` occurs here
   |         |           argument requires that `*self` is borrowed for `'a`
   |         assignment to borrowed `self.cell` occurs here

使用高阶 trait 边界fn update<C: for<'a> Context<'a>>(&mut self)也报错：

error: implementation of `Context` is not general enough
  --> lifetime.rs:56:11
   |
56 |     world.update::<MagicContext>();
   |           ^^^^^^ implementation of `Context` is not general enough
   |
   = note: `Context<'0>` would have to be implemented for the type `MagicContext<'_>`, for any lifetime `'0`...
   = note: ...but `Context<'1>` is actually implemented for the type `MagicContext<'1>`, for some specific lifetime `'1`

我想完全去掉Context的生命周期参数，但不知道如何在无生命周期的情况下实现new函数，请问该如何解决？

解决方案：重构Context trait，移除生命周期依赖 #

核心思路是让Context不再持有World的引用，而是在需要访问World时通过方法参数传递引用，这样就能彻底消除生命周期参数，同时支持在调用时动态选择实现。

重构后的完整代码 #

struct Cell {
    value: i32,
}

impl Cell {
    // 调整evolve方法，新增&World参数供Context使用
    fn evolve(&self, ctx: impl Context, world: &World) -> Cell {
        Cell {
            value: self.value + ctx.get_rate(world),
        }
    }
}

struct World {
    cell: Cell,
    magic: i32,
}

impl World {
    // 接收Context实例，不再通过关联类型创建
    fn evolve_cell<C: Context>(&self, ctx: C) -> Cell {
        self.cell.evolve(ctx, self)
    }

    // 泛型方法，接收任意Context实现，调用时指定
    fn update<C: Context>(&mut self, ctx: C) {
        self.cell = self.evolve_cell(ctx);
    }
}

// 移除生命周期参数，get_rate方法接收&World参数
trait Context {
    fn get_rate(&self, world: &World) -> i32;
}

// MagicContext不再持有引用，变为无状态类型
struct MagicContext;

impl Context for MagicContext {
    fn get_rate(&self, world: &World) -> i32 {
        world.magic
    }
}

fn main() {
    let mut world = World {
        cell: Cell { value: 2 },
        magic: 3,
    };

    // 调用时直接传递Context实例，明确指定实现
    world.update(MagicContext);
    println!("{}", world.cell.value);
}

关键改动说明 #

• 移除Context的生命周期与new方法：不再让Context持有World的引用，而是将&World作为get_rate的参数传递，彻底消除生命周期依赖。
• 调整evolve与evolve_cell方法：让Cell::evolve接收&World参数，World::evolve_cell直接接收Context实例，避免通过关联类型创建上下文时引入的生命周期绑定。
• 调用时传递Context实例：在main中通过传递MagicContext实例来指定具体实现，替代原有的泛型参数指定方式，代码更直观且符合Rust的所有权规则。

替代方案：保留Context持有引用的设计（局限性较大） #

如果一定要让Context持有World的引用，可以通过无生命周期的包装类型配合HRTB实现，但该方案存在局限性（无法在Context中持有有效引用），仅适用于不需要持久化引用的场景：

struct Cell {
    value: i32,
}

impl Cell {
    fn evolve<'a>(&self, ctx: impl Context<'a>) -> Cell {
        Cell {
            value: self.value + ctx.get_rate(),
        }
    }
}

struct World {
    cell: Cell,
    magic: i32,
}

impl World {
    fn evolve_cell<'a, C: Context<'a>>(&'a self, ctx: C) -> Cell {
        self.cell.evolve(ctx)
    }

    // 使用HRTB要求C对任意生命周期都实现Context<'a>
    fn update<C: for<'a> Context<'a>>(&mut self) {
        let ctx = {
            let world: &World = &self;
            C::new(world)
        };
        self.cell = self.evolve_cell(ctx);
    }
}

trait Context<'a> {
    fn new(world: &'a World) -> Self;
    fn get_rate(&self) -> i32;
}

// 定义无生命周期的包装类型，实现HRTB的Context
struct AnyMagicContext;

impl<'a> Context<'a> for AnyMagicContext {
    fn new(world: &'a World) -> Self {
        AnyMagicContext
    }

    fn get_rate(&self) -> i32 {
        // 无法直接访问world，仅适用于无状态场景
        unimplemented!()
    }
}

内容的提问来源于stack exchange，提问作者lemmington