handling lifetypes in iterator extension - rust

Question

I'm attempting to extend Iterator with a group_by_count method:
use itertools::Itertools;
trait ExtIterator<T>
where
T: Sized,
{
fn group_by_count(self) -> Box<dyn Iterator<Item = (T, usize)>>
where
T: Sized;
}
impl<T: 'static, I: 'static> ExtIterator<T> for I
where
I: Iterator<Item = T> + Sized,
T: Clone + Eq + PartialEq + Sized,
{
fn group_by_count(self) -> Box<dyn Iterator<Item = (T, usize)>>
where
Self: Sized,
{
Box::new(
self.group_by(|i| i.clone())
.into_iter()
.map(|(key, group)| (key, group.count())),
)
}
}
I'm getting:
error[E0515]: cannot return value referencing temporary value
--> src/ext/iterator.rs:21:9
|
21 | / Box::new(
22 | | self.group_by(|i| i.clone())
| | ---------------------------- temporary value created here
23 | | .into_iter()
24 | | .map(|(key, group)| (key, group.count())),
25 | | )
| |_________^ returns a value referencing data owned by the current function
|
= help: use `.collect()` to allocate the iterator
It doesn't feel right to call collect here, and clippy suggests the collect should be removed if I do. But I can't puzzle out how to avoid creating a temporary value.

Answer 1

You cannot do that without a custom iterator adapter.
But it's easy to create a new GroupByCount iterator, and then, relying on the fact that multiple calls to into_iter() on GroupBy change the underlying iterator, implement its next() method:
pub struct GroupByCount<I: Iterator> {
// This `fn(&K) -> K` could be `Box<dyn FnMut(&K) -> K`, but
// this adds one usize to the struct's size, and the function
// captures nothing.
inner: itertools::structs::GroupBy<I::Item, I, fn(&I::Item) -> I::Item>,
}
impl<I> Iterator for GroupByCount<I>
where
I: Iterator,
I::Item: PartialEq,
{
type Item = (I::Item, usize);
fn next(&mut self) -> Option<Self::Item> {
self.inner
.into_iter()
.next()
.map(|(key, group)| (key, group.count()))
}
}
pub trait IteratorExt: Iterator {
fn group_by_count(self) -> GroupByCount<Self>
where
Self: Sized;
}
impl<I> IteratorExt for I
where
I: Iterator,
I::Item: Clone + PartialEq,
{
fn group_by_count(self) -> GroupByCount<Self>
where
Self: Sized,
{
GroupByCount {
inner: self.group_by(|i| i.clone()),
}
}
}
Playground.
Other improvements I've made:
Remove redundant Sized bounds.
Remove the now-redundant 'static bounds.
Remove the Eq bound, as it is unnecessary.
Get rid of the type parameter T and instead explicitly use I::Item.
Rename ExtIterator to IteratorExt, as per RFC 445, Extension Trait Conventions.