Assigning proper lifetimes to associated types - rust

Question

I am designing code that should be generic over a trait Atom, that contains many associated types that logically belong together. In the simplified example below, which concerns representing a mathematical expression, there is one variant that gives a 'view' of a Pow and an owned version of a Pow. In actuality, there will be many more variants, such as Var and OwnedVar, Function and OwnedFunction, etc.
Since some traits deal with borrowed data, I added lifetimes and this makes the code below not compile:
pub trait Atom {
// imagine more variants here
type P<'a>: Pow<'a, R = Self>;
type OP: OwnedPow<R = Self>;
}
pub trait Pow<'a> {
type R: Atom;
fn get_base(&self) -> AtomView<Self::R>;
}
pub trait OwnedPow {
type R: Atom;
fn to_view<'a>(&'a self) -> AtomView<Self::R>;
}
pub enum AtomView<'a, R: Atom> {
Pow(R::P<'a>),
}
impl<'a, R: Atom> AtomView<'a, R> {
#[allow(unconditional_recursion, irrefutable_let_patterns)]
fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
if let AtomView::Pow(p2) = other {
let b = p2.get_base();
Some(self.partial_cmp(&b).unwrap())
} else {
None
}
}
}
// concrete implementations
struct Rep;
impl Atom for Rep {
type P<'a> = PowD<'a>;
type OP = OwnedPowD;
}
struct PowD<'a> {
data: &'a [u8],
}
impl<'a> Pow<'a> for PowD<'a> {
type R = Rep;
fn get_base(&self) -> AtomView<Self::R> {
AtomView::Pow(PowD {
data: &self.data[1..],
})
}
}
struct OwnedPowD {
data: Vec<u8>,
}
impl OwnedPow for OwnedPowD {
type R = Rep;
fn to_view<'a>(&'a self) -> AtomView<Rep> {
AtomView::Pow(PowD { data: &self.data })
}
}
fn test<A: OwnedPow>(a: A) {
let _vv = a.to_view();
}
fn main() {
let v = OwnedPowD {
data: vec![1, 2, 3],
};
test(v);
}
This code does not compile:
error[E0621]: explicit lifetime required in the type of `other`
--> src/main.rs:25:21
|
23 | fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
| ----- help: add explicit lifetime `'a` to the type of `other`: `&'a AtomView<'a, R>`
24 | if let AtomView::Pow(p2) = other {
25 | let b = p2.get_base();
| ^^^^^^^^^^^^^ lifetime `'a` required
Of course, giving other the lifetime a is a problem, since other is a locally created variable and thus following the help will not fix the problem. I fail to see why &b seems to have the lifetime &'a b.
The code can be tested on the playground.
I tried fixing this code by dropping many lifetimes in the associated types and traits, but then it seems I need to give Rep a lifetime, and then this Rep<'a> will make its way into OwnedPowD that should have no lifetime (since the data is owned). This attempt can be tried here.
Does anyone know how to assign proper lifetimes?

Answer 1

AtomView has a lifetime argument, which should connect all of the borrowing dependencies together. But you are never specifying it!
pub enum AtomView<'a, R: Atom> {
Pow(R::P<'a>),
}
I was able to make your code compile by changing the trait methods to constrain this lifetime in the "obvious" way in each case:
pub trait Pow<'a> {
type R: Atom;
fn get_base(&self) -> AtomView<'a, Self::R>;
}
pub trait OwnedPow {
type R: Atom;
fn to_view(&self) -> AtomView<'_, Self::R>;
}
And updating the implementations to match:
impl<'a> Pow<'a> for PowD<'a> {
type R = Rep;
fn get_base(&self) -> AtomView<'a, Self::R> {
// just for testing
AtomView::Pow(PowD {
data: &self.data[1..],
})
}
}
impl OwnedPow for OwnedPowD {
type R = Rep;
fn to_view(&self) -> AtomView<'_, Rep> {
AtomView::Pow(PowD { data: &self.data })
}
}