为Box<dyn Fn(&R)->R>实现Ring trait时的生命周期问题

我是Rust新手，尝试为接收实现Ring trait的类型引用并返回该类型的函数实现Ring trait。

Ring trait定义 #

trait Ring {
    fn plus(&self, other: &Self) -> Self;
    fn times(&self, other: &Self) -> Self;
    fn negate(&self) -> Self;
}

我的实现代码 #

impl <R: Ring> Ring for Box<dyn Fn(&R) -> R> {
    //(f+g)(a) = f(a) + g(a)
    fn plus(&self, other: &Self) -> Self {
        Box::new(move |x: &R| -> R {self(x).plus(&other(x))})
    }
    //(fg)(a) = f(g(a))
    fn times(&self, other: &Self) -> Self {
        Box::new(move |x: &R| -> R {self(&other(x))})
    }
    //(-f)(a) = -(f(a))
    fn negate(&self) -> Self {
        Box::new(move |a: &R| -> R {self(a).negate()})
    }
}

注：此处使用Box<dyn Fn(&R) -> R>而非更简洁的impl Fn(&R) -> R，因为编译器禁止在此处使用impl Trait。

错误信息 #

error: lifetime may not live long enough
  --> src/main.rs:73:9
   |
72 |     fn plus(&self, other: &Self) -> Self {
   |             - let's call the lifetime of this reference `'1`
73 |         Box::new(move |x: &R| -> R {self(x).plus(&other(x))})
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ returning this value requires that `'1` must outlive `'static`

已尝试的解决方法 #

• 为方法添加泛型生命周期注解，但Ring trait不再识别这些方法；修改Ring trait添加注解时出现生命周期名称遮蔽错误。
• 使用Box<dyn Fn(&R) -> R + 'static>并将self标注为static，导致生命周期不匹配。
• 在实现块外重写plus、times和negate方法，可正常运行无编译错误。

请问如何确保&self的生命周期满足需求？

解决方案 #

问题核心是：你创建的闭包捕获了&self和&other这两个带临时生命周期的引用，但Box<dyn Fn(&R) -> R>默认要求闭包生命周期为'static，编译器因此要求&self的生命周期必须长于'static，这显然无法满足。

解决思路是放弃捕获临时引用，改为获取函数对象的所有权副本，具体有两种可行方案：

方案1：用Arc共享函数（推荐） #

改用Arc<dyn Fn(&R) -> R>作为实现Ring的类型，Arc可以安全克隆并共享所有权，闭包捕获Arc的副本而非临时引用，完全规避生命周期问题：

use std::sync::Arc;

impl <R: Ring> Ring for Arc<dyn Fn(&R) -> R> {
    // (f+g)(a) = f(a) + g(a)
    fn plus(&self, other: &Self) -> Self {
        let f = self.clone();
        let g = other.clone();
        Arc::new(move |x: &R| -> R { f(x).plus(&g(x)) })
    }

    // (fg)(a) = f(g(a))
    fn times(&self, other: &Self) -> Self {
        let f = self.clone();
        let g = other.clone();
        Arc::new(move |x: &R| -> R { f(&g(x)) })
    }

    // (-f)(a) = -(f(a))
    fn negate(&self) -> Self {
        let f = self.clone();
        Arc::new(move |a: &R| -> R { f(a).negate() })
    }
}

Arc的克隆是轻量操作，闭包持有的是所有权副本，无需担心生命周期约束。

方案2：为Box<dyn Fn(&R) -> R>实现Clone（需unsafe代码） #

如果坚持用Box，需要为动态Fn trait手动实现Clone，从而克隆整个函数对象：

use std::clone::Clone;

// 为动态Fn trait实现Clone（unsafe代码，需确保函数对象可安全克隆）
impl<R: Ring> Clone for Box<dyn Fn(&R) -> R> {
    fn clone(&self) -> Self {
        let boxed_ptr = self.as_ref() as *const dyn Fn(&R) -> R;
        unsafe { Box::from_raw(boxed_ptr as *mut dyn Fn(&R) -> R) }
    }
}

impl <R: Ring> Ring for Box<dyn Fn(&R) -> R> {
    fn plus(&self, other: &Self) -> Self {
        let f = self.clone();
        let g = other.clone();
        Box::new(move |x: &R| -> R { f(x).plus(&g(x)) })
    }

    fn times(&self, other: &Self) -> Self {
        let f = self.clone();
        let g = other.clone();
        Box::new(move |x: &R| -> R { f(&g(x)) })
    }

    fn negate(&self) -> Self {
        let f = self.clone();
        Box::new(move |a: &R| -> R { f(a).negate() })
    }
}

注意：此方案使用unsafe代码，克隆动态 trait 对象需手动处理指针，存在风险，非必要不推荐。

之前尝试失败的原因 #

• 修改trait方法添加生命周期注解不可行：trait定义的方法签名必须与实现完全匹配，无法通过修改trait来适配临时引用的生命周期。
• 强制'static约束冲突：方法接收的&self是临时引用，生命周期不可能达到'static，必然出现匹配错误。

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