使用 Add trait 时简化 Rust extension trait lifetimes

Question

I need an extension trait for everything that implements AsRef<[T]> . A method of this trait takes a reference to T and based on some math with it returns a sub-slice of the original array.

Sample code can look like:

trait Sample<T> {
    fn sample(&self, element: &T, k: usize) -> &[T];
}

impl<'a, A, T> Sample<T> for A
where
    A: AsRef<[T]>,
    &'a T: Add<Output = T>,
    T: 'a,
{
    fn sample(&self, element: &T, k: usize) -> &[T] {
        let array = self.as_ref();
        let doubled = element + element;
        &array[0..0]
    }
}

It does not compile, though.

error: lifetime may not live long enough
  --> src/arrays/sample.rs:15:23
   |
7  | impl<'a, A, T> Sample<T> for A
   |      -- lifetime `'a` defined here
...
13 |     fn sample(&self, element: &T, k: usize) -> &[T] {
   |                               - let's call the lifetime of this reference `'1`
14 |         let array = self.as_ref();
15 |         let doubled = element + element;
   |                       ^^^^^^^^^^^^^^^^^ requires that `'1` must outlive `'a`

I don't really understand why element lifetime must be bigger than 'a .

Anyways, after a while I made it work, but it does not feel right.

use core::ops::Add;

trait KClosestExt<'t, T> {
    fn find_k_closest(&'t self, element: &'t T, k: usize) -> &[T];
}

impl<'a, 't, A, T> KClosestExt<'t, T> for A
where
    A: AsRef<[T]>,
    &'a T: Add<Output = T>,
    T: 'a + 't + PartialOrd,
    't: 'a,
{
    fn find_k_closest(&'t self, element: &'t T, k: usize) -> &[T] {
        let array = self.as_ref();
        if k > array.len() {
            return array;
        }

        let doubled = element + element;
        let left = binary_search(0, array.len() - k, |mid| doubled > &array[mid + k] + &array[mid]);
        &array[left..left + k]
    }
}

According to what I need, is it possible to simplify lifetime management for this example?

Answer 1

Your lifetime issues stem from the bound &'a T: Add<Output = T> . This says that &T implements Add but only when the lifetime is exactly &'a T . What you most likely want is for<'a> &'a T: Add<Output = T> which specifies that &T implements Add for any lifetime that you choose. (1)

With this change, you sample code compiles without needing to specify any more lifetimes. playground .

trait Sample<T> {
    fn sample(&self, element: &T, k: usize) -> &[T];
}

impl<A, T> Sample<T> for A
where
    A: AsRef<[T]>,
    for<'a> &'a T: std::ops::Add<Output = T>,
{
    fn sample(&self, element: &T, k: usize) -> &[T] {
        let array = self.as_ref();
        let doubled = element + element;
        &array[0..0]
    }
}

---

(1) Strictly speaking, this is a more restrictive bound but I struggle to see a situation where the first one is fulfilled but not the second one.