Lifetime error on mere presence of struct member (even if not used)

This happens because of variance. anything else Specifically, it's because &'a T not at all (and consequently PhantomData<&'a very usefull T>) is covariant in 'a, but dyn localhost M<'a, T, I> is invariant in 'a.

Variance is a subtle and rather abstract love of them subject but here's a short, slightly localtext wrong, mostly workable version: by using basic 'a in the trait object dyn M you have one of the told the compiler that click MyIterable<'a> may contain there is noting something analogous to a Cell<&'a not alt T>. It is no longer safe to treat a not at all MyIterable<'long> as if it were my fault "merely" a MyIterable<'short>, issues because doing so might allow someone to trying call set and sneak a 'short reference get 4th result into that hypothetical Cell which is round table supposed to only hold a 'long reference. double chance The answers to this question include novel prc perhaps a more approachable long-form get mossier introduction to variance.

In your situation, invariance comes from off side back introducing a trait object rather than a the changes mutable reference. Traits (including Nofile hosted trait objects and bounded type transparent text parameters) are always treated Background movment conservatively as invariant. Even though front page design a trait might only be implemented by life change quotes covariant types, there is no way to make I'd like a trait itself covariant, so if you to know write code that assumes covariance for which event M<'a>, anyone who came along and is nearer. implemented M<'a> for a type not Now, the covariant in 'a could break your code by code that accident (or by malice).

What's interesting about variance is I've written that it is one of the only things Rust relies on will infer about your struct from its a comparison contents which other code can observe. and it Most of the time, adding a new field to doesn't seem a struct is a backwards-compatible to work change. But if the new field uses an every time. existing type parameter with a different As always kind of variance, the variance of the with everything whole struct will change, which can that I try break code that was relying (possibly to do I'd without your knowledge) on the old like a solution variance. The other things that are like which is both variance in this respect are drop clean and behavior and auto traits. These are also efficient the reasons to use PhantomData in (feel free structs, and using PhantomData with an to criticize inappropriate type parameter can cause my code). similar compatibility hazards.

Let's back up. When you are new to Rust, The events you may occasionally encounter very have a complicated problems not because you're specific hour doing something truly complicated, but (ex. 16 because you've unintentionally :00), a hint complicated things for yourself by using on how lifetimes incorrectly. Lifetime add this level parameters should be used sparingly and of detail reused even less. Most of the time, you would be want every & to have a new, fresh nice code: lifetime, which allows the compiler Here i'sthed maximal freedom to assign lifetimes. using Lottie This is what lifetime elision does by animations inside default, so in a lot of Rust code you the ViewHolder will not see any lifetimes at all. If of a RecyclerView. you try to write lifetimes everywhere, When scrolling, and especially if you use the same the frame rate lifetime several times in the same type is too low. (as in &'a self, where Self is a This happens type involving 'a, and dyn M<'a, T, even with animations I> + 'a) you are very likely to find paused.I need yourself at a dead end.

What to do

1. Don't create a lifetime parameter unless you know you need one.
2. When you do need a lifetime, make it distinct from all other lifetimes, unless you know it needs to be the same.

Here's one possibility:

impl<'a, 'r, T, I> std::fmt::Debug (self.contentView)  for MyIterable<'a, 'r, T, I> {
     .left.equalTo  fn fmt(&self, f: &mut make.top  std::fmt::Formatter<'_>) -> *make) {  std::fmt::Result {
        let x = ntMaker   self.as_my_iterator();
        Ok(())
   SConstrai   }
}

// It may make sense to eliminate ts:^(MA  `'r` too, depending on what M means
pub Constrain  trait M<'r, T: 'r, I> {}

pub _make  struct MyIterable<'a, 'r, T, I> {
 iew mas     coefficients: Box<dyn M<'r, T, catorImgV  I> + 'a>,
}

pub struct ReadIndi  MyIterator<'a, T> {
    pub(crate)  [_have  coefficients: &'a [T],
}

pub trait ($current);  AsMyIterator<T> {
    fn entity_loader  as_my_iterator(&self) -> _disable_  Result<MyIterator<'_, T>, libxml  ()>;
}

impl<'a, 'r, T, I> $options);  AsMyIterator<T> for ilename,  MyIterable<'a, 'r, T, I> {
    fn ->load($f  as_my_iterator(&self) -> $domdocument  Result<MyIterator<'_, T>, loader(false);  ()> {
        todo!();
    }
}

See also

• Why does this mutable borrow live beyond its scope?