Rust泛型生命周期问题：回调库中无法从闭包返回闭包

问题描述 #

我是Rust新手，正在将一个Kotlin回调事件库改写为Rust版本。在实现闭包返回闭包的逻辑时，注册回调的on_event函数和调用器函数均因泛型生命周期问题报错，已在多个论坛求助但未解决。

原始代码 #

lib.rs #

mod event;

#[cfg(test)]
mod tests {
    use crate::event::*;
    fn test(mut x: i32,y: i32, entries: &[&dyn Fn(i32)]) -> i32 {
        for entry in entries {
            x *= 3;
            (entry)(x);
        }
        x * y
    }
    fn invoker<'a>(entries: &'a [&'a dyn Fn(i32)]) -> impl Fn(i32) -> i32 + 'a {
        move |y|test(1,y,&entries)
    }
    #[test]
    fn it_works() {
        let mut event_test = EventKey::new(invoker);
        let test = &|x: i32| {
            println!("Hello {}", x);
        };
        event_test.on_event(test);
        event_test.on_event(test);
        event_test.on_event(test);
        let result = event_test.invoke()(10);
        assert_eq!(result, 270);
    }
}

event.rs #

/// Event file
/// I - invoker type
/// R - additional return type
/// C - Callback arguments
/// Please know that this applies to everything in this file

pub struct EventKey<I, C> {
    invoker: I,
    callbacks: Vec<C>
}

impl<I,C,R> EventKey<I,C>
where I: Fn (&[C]) -> R
{
    pub fn new(invoker: I) -> EventKey<I, C> {
        EventKey {
            invoker,
            callbacks: Vec::new()
        }
    }

    pub fn on_event(&mut self, callback: C) {
        self.callbacks.push(callback);
    }

    pub fn invoke(&self) -> R {
        (self.invoker)(&self.callbacks)
    }
}

错误信息 #

未添加生命周期时 #

error[E0700]: hidden type for `impl Fn(i32) -> i32` captures lifetime that does not appear in bounds
  --> src/lib.rs:14:9
   |
13 |     fn invoker(entries: &[&dyn Fn(i32)]) -> impl Fn(i32) -> i32 {
   |                         --------------- hidden type `[closure@src/lib.rs:14:9: 14:17]` captures the anonymous lifetime defined here
14 |         move |y|test(1,y,&entries)
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
help: to declare that `impl Fn(i32) -> i32` captures `'_`, you can introduce a named lifetime parameter `'a`
   |
13 |     fn invoker<'a>(entries: &'a [&'a dyn Fn(i32)]) -> impl Fn(i32) -> i32 + 'a  {
   |               ++++           ++   ++                                      ++++

添加生命周期后 #

error[E0599]: the method `on_event` exists for struct `EventKey<for<'a> fn(&'a [&'a (dyn Fn(i32) + 'a)]) -> impl Fn(i32) -> i32 + 'a {invoker}, &dyn Fn(i32)>`, but its trait bounds were not satisfied
  --> src/lib.rs:22:20
   |
22 |         event_test.on_event(test);
   |                    ^^^^^^^^ method cannot be called due to unsatisfied trait bounds
   |
  ::: src/event.rs:7:1
   |
7  | pub struct EventKey<I, C> {
   | ------------------------- method `on_event` not found for this struct
   |
note: the following trait bounds were not satisfied:
      `<for<'a> fn(&'a [&'a (dyn Fn(i32) + 'a)]) -> impl Fn(i32) -> i32 + 'a {invoker} as FnOnce<(&[&dyn Fn(i32)],)>>::Output = _`
      `for<'a> fn(&'a [&'a (dyn Fn(i32) + 'a)]) -> impl Fn(i32) -> i32 + 'a {invoker}: Fn<(&[&dyn Fn(i32)],)>`
  --> src/event.rs:13:10
   |
12 | impl<I,C,R> EventKey<I,C>
   |             -------------
13 | where I: Fn (&[C]) -> R
   |          ^^^^^^^^^^^^^^
   |          |            |
   |          |            unsatisfied trait bound introduced here
   |          unsatisfied trait bound introduced here
   = note: the following trait bounds were not satisfied:
           `for<'a> fn(&'a [&'a (dyn Fn(i32) + 'a)]) -> impl Fn(i32) -> i32 + 'a {invoker}: FnMut<(&[&dyn Fn(i32)],)>`
           which is required by `for<'a> fn(&'a [&'a (dyn Fn(i32) + 'a)]) -> impl Fn(i32) -> i32 + 'a {invoker}: Fn<(&[&dyn Fn(i32)],)>`
           `for<'a> fn(&'a [&'a (dyn Fn(i32) + 'a)]) -> impl Fn(i32) -> i32 + 'a {invoker}: FnOnce<(&[&dyn Fn(i32)],)>`
           which is required by `for<'a> fn(&'a [&'a (dyn Fn(i32) + 'a)]) -> impl Fn(i32) -> i32 + 'a {invoker}: Fn<(&[&dyn Fn(i32)],)>`

错误原因分析 #

1. 未加生命周期的错误：闭包捕获了函数参数的匿名生命周期，Rust要求必须显式声明闭包捕获的生命周期，否则无法推断闭包的生命周期边界。
2. 添加生命周期后的错误：invoker函数的签名过度约束了生命周期——要求切片的生命周期与切片内每个元素的生命周期完全一致（&'a [&'a dyn Fn(i32)]），但EventKey传递给invoker的&[C]中，C的生命周期可以独立于切片本身，导致类型不匹配，无法满足EventKey的泛型约束。

解决方案 #

方案1：调整生命周期约束（保留引用类型回调） #

修改invoker函数的生命周期约束，仅约束切片的生命周期，允许元素的生命周期更长，同时移除多余的引用传递：

修改后的lib.rs

mod event;

#[cfg(test)]
mod tests {
    use crate::event::*;
    fn test(mut x: i32, y: i32, entries: &[&dyn Fn(i32)]) -> i32 {
        for entry in entries {
            x *= 3;
            (entry)(x);
        }
        x * y
    }
    // 仅约束切片的生命周期，元素的生命周期无需与切片绑定
    fn invoker<'a>(entries: &'a [&dyn Fn(i32)]) -> impl Fn(i32) -> i32 + 'a {
        move |y| test(1, y, entries)  // entries已经是引用，无需再取地址
    }
    #[test]
    fn it_works() {
        let mut event_test = EventKey::new(invoker);
        // 确保闭包的生命周期长于EventKey
        let test = |x: i32| {
            println!("Hello {}", x);
        };
        event_test.on_event(&test);
        event_test.on_event(&test);
        event_test.on_event(&test);
        let result = event_test.invoke()(10);
        assert_eq!(result, 270);
    }
}

方案2：使用所有权类型存储回调（更简洁，符合Kotlin语义） #

直接用Box<dyn Fn(i32)>存储回调，避免复杂的引用生命周期管理，更贴近Kotlin中回调的所有权语义：

修改后的lib.rs

mod event;

#[cfg(test)]
mod tests {
    use crate::event::*;
    // 调整参数为Box类型的切片
    fn test(mut x: i32, y: i32, entries: &[Box<dyn Fn(i32)>]) -> i32 {
        for entry in entries {
            x *= 3;
            (entry)(x);
        }
        x * y
    }
    // 生命周期仅约束切片本身
    fn invoker<'a>(entries: &'a [Box<dyn Fn(i32)>]) -> impl Fn(i32) -> i32 + 'a {
        move |y| test(1, y, entries)
    }
    #[test]
    fn it_works() {
        let mut event_test = EventKey::new(invoker);
        // 使用Box封装闭包，转移所有权到EventKey
        let test = Box::new(|x: i32| {
            println!("Hello {}", x);
        });
        event_test.on_event(test);
        event_test.on_event(Box::new(|x| println!("Hello again {}", x)));
        event_test.on_event(Box::new(|x| println!("Hello third {}", x)));
        let result = event_test.invoke()(10);
        assert_eq!(result, 270);
    }
}

event.rs无需修改，因为它的泛型设计支持任意类型的回调C。

说明 #

方案2更推荐，因为Box<dyn Fn(...)>是Rust中存储动态回调的常用方式，无需处理复杂的引用生命周期，语义上也更接近Kotlin中回调对象的使用方式。

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