Traits，通过返回 `Self::Item` 的 trait 方法返回对拥有字段的引用

Question

Returning a reference to an owned field is allowed in other scenarios. For instance, the code below compiles fine.

struct Charlie<T> {
    delta: T,
}

impl<T> Charlie<T> {
    fn delta(&self) -> &T
    {
        &self.delta
    }
}

I'd like to return a reference to an owned field from a trait method in similar fashion. Assume that Alpha is a trait in the standard library, so I can't modify it.

Is there a way to implement this?

trait Alpha {
    type Item;
    fn bravo(&mut self) -> Self::Item;
}

impl<T> Alpha for Charlie<T> {
    type Item = &T;
    
    fn bravo(&mut self) -> Self::Item
    {
        &self.delta
    }
}

The above doesn't compile and the error messages don't seem to apply. If I try following the error message suggestions, things just get complicated and I run into a series of errors with suggestions that also don't pan out.

   Compiling playground v0.0.1 (/playground)
error[E0106]: missing lifetime specifier
  --> src/main.rs:22:17
   |
22 |     type Item = &T;
   |                 ^ expected named lifetime parameter
   |
help: consider introducing a named lifetime parameter
   |
22 |     type Item<'a> = &'a T;
   |              ^^^^   ^^^

I've tried the above suggestion and went so far as to declare 'a on Charlie 's struct and add a PhantomData field, and thoroughly peppered the rest of my sources with 'a s. And the compiler continues whining and complaining and nagging throughout the whole process.

I managed to find this post on StackOverflow , but the solutions there seem to all require modifying the trait.

I'm thinking what I'm trying to do may not be possible. But I don't really understand why not.

The Alpha trait method that I was struggling with is actually

    type Item = Take<&I>;
    fn next(&mut self) -> Option<Self::Item> { ... }

I was trying to return another wrapped iterator type, where I is the wrapped iterator. The Iterator trait itself doesn't define any lifetimes I can leverage.

I do know a way to implement around this limitation using the smart pointer classes to encapsulate the field I want to share in Charlie . Then make that my Item type. I was just hoping for something with less overhead.

Answer 1

The contract for that trait unfortunately doesn't allow it.

trait Alpha {
  type Item;
  fn bravo(&mut self) -> Self::Item;
}

This says that, if Self is an Alpha , then "there exists some single Self::Item which I can get from any &mut self with any lifetime". You want "there exists a class of Self::Item whose lifetimes relate to &mut self in a nontrivial way".

The easiest way to get around this is to make bravo take self by value.

trait Alpha {
  type Item;
  fn bravo(self) -> Self::Item;
}

Now, the contract says "there's some way to get a Self::Item from a self ", which is much simpler. We can implement it as

impl<'a, T> Alpha for Charlie<&'a mut T> {
  type Item = &'a T;
    
  fn bravo(self) -> Self::Item {
    &self.delta
  }
}