如何定义适配器特征，其中某些实现需要 &self 的生命周期？

Question

I'm writing a set of benchmarks for different key-value stores, and would like to have a single adapter trait that I can use in all the benchmarks, and then implement it for each key-value store.

This worked well for two of them. However, the third required me to add a lifetime on my trait, and after fighting the borrow checker for an entire day, I still can't seem to get it right.

I've distilled it down to this minimal repro: https://play.rust-lang.org/?version=stable&mode=debug&edition=2018&gist=54fec74cb70c63c03f25ec7a9dfc7e60

What I don't understand is why the borrow on txn lives longer than the scope of benchmark() . It seems to me that it should live for only that one line.

How can I define the AdapterTransaction trait to resolve this, that still allows implementations to choose their own return type?

edit

added that I need to be able to use the AdapterTransaction implementations with a factory trait

Answer 1

The main problem in your first playground is the lifetime on &self being the same as the generic lifetime on the trait.

pub trait AdapterTransaction<'a, T: AsRef<[u8]>> {
    fn get(&'a self, key: &[u8]) -> Option<T>;
}

Because they are the same, it requires the borrow of the underlying type to live at least as long as the type itself. This isn't true because even though the type is owned, the borrow would only last for the duration of the function call. In benchmark<'a,...>() , the lifetime 'a is picked by the caller, and there is no way a borrow within that function can be long enough. There would have been a quick fix to remove the 'a parameter on benchmark and replace it with a higher ranked trait bound ( playground ).

fn benchmark<U: AsRef<[u8]>, T: for<'a> AdapterTransaction<'a, U>>(txn: T)

In this example, 'a isn't chosen by the caller anymore, so the compiler is free to use a valid lifetime for the call.

As for the 2nd part of your question, traits can define associated types which can change depending on the implementation. You could have a trait that has an associated Output , which can change for each implemented type. There is a big difference with doing a generic param vs an associated type since in the former case, you are allowed to implement multiple generic variants of a trait for the same type. (This is how From<T> works, for example).

pub trait AdapterTransaction<'a> {
    type Output;

    fn get(&'a self, key: &[u8]) -> Option<Self::Output>;
}

impl<'a> AdapterTransaction<'a> for AdapterImpl {
    type Output = &'a [u8];
    
    fn get(&'a self, key: &[u8]) -> Option<Self::Output> {
        Some(self.txn.get(&key))
    }
}

fn benchmark<T>(txn: T)
 where
    for<'a> T: AdapterTransaction<'a>,
{
    let _ = txn.get(&[]).unwrap();
}

Edit: Some of my initial assumptions weren't exact, it's not necessary to implement on &'a Type if the trait lifetime is used in a non-conflicting way.