当传递给 function 中的泛型闭包时，泛型结构的寿命不够长

Question

我正在尝试编写一个简单的实用程序 function （用于测试），它包装给定的闭包并公开一些与数据库相关的对象。 它看起来像这样：

pub fn with_repository<'a, R, F>(f: F)
where
  R: Repository<'a>,
  F: FnOnce(R, &DbConnection),
{
  let connection = DbConnection::new();
  let repository = R::new(&connection);
  f(repository, &connection);
}

以下是我打算如何使用它：

with_repository::<SomeRepository, _>(|_repository, _connection| {
  println!("Doing stuff with repository or the connection..");
});

现在这给了我著名的错误E0597 - borrowed value does not live long enough ：

error[E0597]: `connection` does not live long enough
  --> src/utils/test.rs:50:27
   |
44 | pub fn with_repository<'a, R, F>(f: F)
   |                        -- lifetime `'a` defined here
...
50 |   let repository = R::new(&connection);
   |                    -------^^^^^^^^^^^-
   |                    |      |
   |                    |      borrowed value does not live long enough
   |                    argument requires that `connection` is borrowed for `'a`
51 |   f(repository, &connection);
52 | }
   | - `connection` dropped here while still borrowed

我真的很想了解是什么导致了这里的问题。 是否因为f理论上可以将repository的所有权传递给另一个 scope？ 这是有道理的，但是我尝试将闭包更改为&R ，但没有任何改变。 我也尝试了很多不同的方法来注释生命周期，但现在我只是猜测。

这是一个带有“工作”示例的操场链接： link

编辑 1 ： 好的，在发布问题后我想到了另一种可能的解决方案并且它起作用了：

pub fn with_repository<R, F>(f: F)
where
  for<'a> R: Repository<'a>,
  F: FnOnce(R, &DbConnection),
{
  let connection = DbConnection::new();
  let repository = R::new(&connection);
  f(repository, &connection);
}

但是，我仍然希望能够解释为什么它首先不起作用 - 在 function 签名和for子句中指定生命周期之间有什么区别？

编辑2 ：结果它毕竟不起作用。 它现在给出了这个神秘的错误（有关更多详细信息，请参见操场）：

error: implementation of `Repository` is not general enough
  --> src/main.rs:28:5
   |
3  | / trait Repository<'a> {
4  | |     fn new(connection: &'a DbConnection) -> Self;
5  | | }
   | |_- trait `Repository` defined here
...
28 |       with_repository::<UserRepository, _>(|_repository, _connection| {
   |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ implementation of `Repository` is not general enough
   |
   = note: `Repository<'0>` would have to be implemented for the type `UserRepository<'_>`, for any lifetime `'0`...
   = note: ...but `Repository<'1>` is actually implemented for the type `UserRepository<'1>`, for some specific lifetime `'1`

Answer 1

这是不可能的。 通用参数由调用者选择。 这个 function 签名：

fn with_repository<'a, R, F>(f: F)
where
    R: Repository<'a>,
    F: FnOnce(R, &DbConnection),
{
    let connection = DbConnection {};
    let repository = R::new(&connection);
    f(repository, &connection);
}

将允许用户像这样调用您的 function：

with_repository<'static, UserRepository<'static>, _>(|repo, conn| {});

这将需要 function 产生一个&'static DbConnection这是不可能的。 即使您将'a从 function 签名移动到特征绑定：

fn with_repository<R, F>(f: F)
where
    R: for<'a> Repository<'a>,
    F: FnOnce(R, &DbConnection),
{
    let connection = DbConnection {};
    let repository = R::new(&connection);
    f(repository, &connection);
}

用户仍然可以像这样调用您的 function：

with_repository<UserRepository<'static>, _>(|repo, conn| {});

所以潜在的问题仍然存在（即使编译器错误已经改变）。

我们可以解决这个问题的唯一方法是要么完全摆脱引用，要么从 function 外部传递引用（而不是从函数内部构造它们）。 由于前者对于您的用例是不可能的，因此只剩下后者：

fn with_repository<'a, R, F>(connection: &'a DbConnection, f: F)
where
    R: Repository<'a>,
    F: FnOnce(R, &DbConnection),
{
    let repository = R::new(connection);
    f(repository, connection);
}

然后你可以像这样从单元测试中调用它：

fn some_test() {
    let connection = DbConnection;
    with_repo::<UserRepository, _>(&connection, |repository, connection| {
        // work with repository & connection here
    });
}

虽然这只是这样做的一个毫无意义的冗长版本，但它更干净、更简洁：

fn some_test() {
    let connection = DbConnection;
    let repository = UserRepository::new(&connection);
    // work with repository & connection here
}

如果在您的真实代码中构建connection很费力，我会将其抽象为自己的 function 以便测试开始时的样板保持精简：

fn get_test_connection() -> DbConnection {
    // construct and return connection here
}

fn some_test() {
    let connection = get_test_connection();
    let repository = UserRepository::new(&connection);
    // work with repository & connection here
}