dyn-iter

This tiny crate should help you simplify your code when you need to wrap Iterator as trait-object.

Imagine for example a trait like the following.

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Color {
    Red,
    Green,
    Blue,
    White,
    Black,
}
trait Colors<'a> {
	type ColorsIter = Iterator<Item = Color>;
	fn colors(&'a self) -> Self::ColorsIter;
}

As an implementor, you have a struct Flag that looks like this.

struct Flag {
	primary_colors: HashSet<Color>,
	secondary_colors: HashSet<Color>,
}

you might implement a fn colors() that look like this

fn colors(&'a self) -> Self::ColorsIter {
	self.primary_colors
		.iter()
		.chain(&self.secondary_colors)
		.filter(|color| **color != Color::Black)
		.copied()
}

With the above implementation, defining the associated type ColorsIter might be difficult. DynIter should simplify your life because you can just write the following implementation.

trait Colors<'a> {
	type ColorsIter = DynIter<'a, Color>;
	fn colors(&'a self) -> Self::ColorsIter {
		DynIter::new(
			self.primary_colors
				.iter()
				.chain(&self.secondary_colors)
				.filter(|color| **color != Color::Black)
				.copied()
		)
	}
}

Behind the scene, DynIter<'iter, V> is only providing a wrapper around a Box<dyn Iterator<Item = V> + 'iter>.

For more details about why this crate exists, read this blog post.