#[derive(Clone)]
struct NotQuiteStatic<'not_quite_static>(&'not_quite_static u32);

struct IteratorWithRef<'creates_iterator, 'not_quite_static>
where
    'not_quite_static: 'creates_iterator,
{
    reference: &'creates_iterator CreatesIteratorImpl<'not_quite_static>,
    underlying: std::vec::IntoIter<NotQuiteStatic<'not_quite_static>>,
}
impl<'creates_iterator, 'not_quite_static> Iterator
    for IteratorWithRef<'creates_iterator, 'not_quite_static>
where
    'not_quite_static: 'creates_iterator,
{
    type Item = NotQuiteStatic<'not_quite_static>;

    fn next(&mut self) -> Option<Self::Item> {
        self.underlying.next()
    }
}


trait CreatesIterator<'creates_iterator, 'not_quite_static>
where
    'not_quite_static: 'creates_iterator,
    Self::Eventual: Iterator + 'creates_iterator,
    <Self::Eventual as Iterator>::Item: 'not_quite_static,
{
    type Eventual;
    fn iterate(&'creates_iterator self) -> Self::Eventual;
}

struct CreatesIteratorImpl<'not_quite_static>(
    Vec<NotQuiteStatic<'not_quite_static>>
);

impl<'creates_iterator, 'not_quite_static> CreatesIterator<'creates_iterator,
                                                           'not_quite_static>
    for CreatesIteratorImpl<'not_quite_static>
where
    'not_quite_static: 'creates_iterator,
{
    type Eventual = Box<dyn Iterator<Item = NotQuiteStatic<'not_quite_static>>
                        + 'creates_iterator>;
    fn iterate(&'creates_iterator self) -> Self::Eventual {
        Box::new(
            IteratorWithRef {
                reference: self,
                underlying: self.0.clone().into_iter(),
            }
        )
            as Self::Eventual
    }
}

type LongTraitObjType<'creates_iterator, 'not_quite_static: 'creates_iterator> =
    Box<
        dyn CreatesIterator<
            'creates_iterator,
            'not_quite_static,
            Eventual =
                Box<
                    dyn Iterator<Item = NotQuiteStatic<'not_quite_static>>
                    + 'creates_iterator
                >
        >
        + 'not_quite_static
    >;

fn main() {
    let not_quite_static = 1;

    // Works: concrete implementation:
    {
        let creates_iterator_impl =
            Box::new(
                CreatesIteratorImpl(
                    vec![
                        NotQuiteStatic(&not_quite_static)
                    ]
                )
            );
        let _ = creates_iterator_impl.iterate().count();
    }

    // Doesn't work: same as above, but cast to a trait object.
    {
        let creates_iterator_dyn: LongTraitObjType =
            Box::new(
                CreatesIteratorImpl(
                    vec![
                        NotQuiteStatic(&not_quite_static)
                    ]
                )
            );
        let _ = creates_iterator_dyn.iterate().count();
    }

}