Return and consume an iterator of mutable references from a closure - iterator

Question

Are there any examples of functions that consume a closure that returns an Iterator<Item = &mut T>?
I've wanted to write a couple Rust functions that iterated over the contents of a collection several times, and possibly backwards. IntoIterator alone does not suffice because it consumes its argument by value preventing multiple iterations. Iterators can frequently cloned, but iterators of mutable references.
If we really only need iteration over the collections's exact elements, then we might use that &mut C: IntoIterator for all Rust collection types C. Accepting RFC 2289 syntax, this could look like:
fn batch_normalization<II: ?Sized>(v: &mut II)
where
for<'a> &'a mut II: IntoIterator<Item = &'a mut Self, IntoIter: DoubleEndedIterator + ExactSizeIterator>,
but the current form runs into a compiler bug. Also, this would not permit users to specify a "view" of the collection contents using iterator adapters, like map.
Intuitively, we should borrow the collection using a closure that rebuilds our iterator when called:
fn batch_normalization<F>(f: F)
where
F: FnMut() -> impl Iterator<Item = &mut Self> + DoubleEndedIterator + ExactSizeIterator
We cannot write that yet because (a) issues around impl Trait in traits have not yet been resolved, and (b) our &mut Self needs a lifetime, so we might write say:
fn batch_normalization<I, F: FnMut() -> I>(f: F)
where
I: Iterator<Item = BorrowMut<Self>> + DoubleEndedIterator + ExactSizeIterator
I've tried various formulations like this but none quite work, mostly because the Item outlives the iterator.
We should fix this the way &'a mut C: IntoIterator<Item = &'a mut T> does by explicitly tying the item's lifetime to the lifetime of &mut self in the FnMut. In pseudocode:
fn batch_normalization<I, F: FnMut() -> I>(f: F)
where
I: for<'a: F::Output> Iterator<Item = &'a mut Self> + DoubleEndedIterator + ExactSizeIterator
How should one actually return an Iterator<Item = &mut T> from a closure passed as an argument? Should one always use some fn pointer mess instead of a closure? Roughly:
fn batch_normalization<'a, I, V: ?Sized>(v: &mut V, f: fn(&'a mut V) -> I)
where
I: Iterator<Item = &'a mut Self> + DoubleEndedIterator + ExactSizeIterator
{
for x in f() { }
// ...
for x in f().rev() { }
}

Answer 1

There is no way to do precisely this with closures because the Fn* traits do not support binding a return type to the lifetime of their self argument. Right now, the Fn* traits read
pub trait FnOnce<Args> {
type Output;
extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
}
pub trait FnMut<Args>: FnOnce<Args> {
extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
}
pub trait Fn<Args>: FnMut<Args> {
extern "rust-call" fn call(&self, args: Args) -> Self::Output;
}
but this would require these traits read like
pub trait FnOnce<Args> {
type Output<'fn>;
extern "rust-call" fn call_once(self, args: Args) -> Self::Output<'static>;
}
pub trait FnMut<Args>: FnOnce<Args> {
extern "rust-call" fn call_mut<'fn>(&'fn mut self, args: Args) -> Self::Output<'fn>;
}
pub trait Fn<Args>: FnMut<Args> {
extern "rust-call" fn call<'fn>(&'fn self, args: Args) -> Self::Output<'fn>;
}
These are unstable interfaces so they could perhaps eventually be changes through the RFC process, maybe with some special 'fn liftime syntax like FnMut() -> impl Iterator<Item = &'fn mut Self>, or maybe even with a parametrized the type parameter Args as Args<'fn>. Rust internals is the proper forum for this question.