Filter adapter for LendingIterator requires Polonius

[jackh726]

Currently, you can't write a safe filter adapter for a LendingIterator with GATs without polonius.

#![feature(generic_associated_types)]

trait LendingIterator {
    type Item<'a> where Self: 'a;
    fn next(&mut self) -> Option<Self::Item<'_>>;

    fn filter<P>(self, predicate: P) -> Filter<Self, P>
    where
        Self: Sized,
        P: FnMut(&Self::Item<'_>) -> bool,
    {
        Filter {
            iter: self,
            predicate,
        }
    }
}

pub struct Filter<I, P> {
    iter: I,
    predicate: P,
}
impl<I: LendingIterator, P> LendingIterator for Filter<I, P>
where
    P: FnMut(&I::Item<'_>) -> bool,
{
    type Item<'a> where Self: 'a = I::Item<'a>;

    fn next(&mut self) -> Option<I::Item<'_>> {
        while let Some(item) = self.iter.next() {
            if (self.predicate)(&item) {
                return Some(item);
            }
        }
        return None;
    }
}

fn main() {}

Playground
Minimal Iterator equivalent

[jackh726]

For reference, here's a version of next for Filter that uses unsafe to compile. (There might be a different way to do this, but this works):

    fn next<'a>(&'a mut self) -> Option<I::Item<'a>> {
        while let Some(mut item) = self.iter.next() {
            if (self.predicate)(&item) {
                // SAFETY: We turn a lifetime of "`'x`" where `'a <: 'x` into a `'a`.
                // This is safe since we immediately return this item.
                // This workaround isn't needed under Polonius.
                let item = unsafe {
                    let ptr = &mut item as *mut Self::Item<'_>;
                    let ptr = std::mem::transmute::<*mut Self::Item<'_>, *mut Self::Item<'a>>(ptr);
                    let res = ptr.read();
                    core::mem::forget(item);
                    res
                };
                return Some(item);
            }
        }
        return None;
    }

[jackh726]

GATs issue triage: not blocking. This needs some work with Polonius, I think. But not backwards-incompatible.

[nikomatsakis]

Fascinating. This is indeed problem case #3. Usually the workaround is to convert from let x = common; if condition(x) { return x; } to

let temp = {
    let x = common;
    condition(x)
};
if temp {
    let x = common;
    return x;
}

But, in this case, we can only execute next once. Very interesting!