#iterator #dynamic #trait-object #traits #dyn #debugging #wrap

dyn-iter

Wrapper around Box<dyn Iterator<Item = V> + 'iter> to simplify your code

4 releases (2 stable)

1.0.1 May 23, 2023
1.0.0 May 22, 2023
0.2.0 Sep 28, 2020
0.1.0 Sep 22, 2020

#438 in Rust patterns

Download history 137/week @ 2023-12-15 95/week @ 2023-12-22 80/week @ 2023-12-29 247/week @ 2024-01-05 326/week @ 2024-01-12 294/week @ 2024-01-19 278/week @ 2024-01-26 253/week @ 2024-02-02 201/week @ 2024-02-09 281/week @ 2024-02-16 302/week @ 2024-02-23 199/week @ 2024-03-01 272/week @ 2024-03-08 331/week @ 2024-03-15 355/week @ 2024-03-22 335/week @ 2024-03-29

1,326 downloads per month
Used in cargo-sonar

MIT license

16KB
124 lines

dyn-iter

continuous-integration-badge code-coverage-badge crates.io-badge license-badge documentation-badge

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> + 'a;
    fn colors(&'a self) -> Self::ColorsIter;
}

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

# use std::collections::HashSet;
# #[derive(Debug, Clone, Copy, PartialEq, Eq)]
# enum Color {
#     Red,
#     Green,
#     Blue,
#     White,
#     Black,
# }
struct Flag {
    pub primary_colors: HashSet<Color>,
    pub secondary_colors: HashSet<Color>,
}

you might implement Colors that look like this

# use std::collections::HashSet;
# use dyn_iter::{DynIter, IntoDynIterator as _};
# #[derive(Debug, Clone, Copy, PartialEq, Eq)]
# enum Color {
#     Red,
#     Green,
#     Blue,
#     White,
#     Black,
# }
# struct Flag {
#     pub primary_colors: HashSet<Color>,
#     pub secondary_colors: HashSet<Color>,
# }
# trait Colors<'a> {
#     type ColorsIter: Iterator<Item = Color> + 'a;
#     fn colors(&'a self) -> Self::ColorsIter;
# }
impl<'a> Colors<'a> for Flag {
    type ColorsIter = ???;
    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.

# use std::collections::HashSet;
# use dyn_iter::{DynIter, IntoDynIterator as _};
# #[derive(Debug, Clone, Copy, PartialEq, Eq)]
# enum Color {
#     Red,
#     Green,
#     Blue,
#     White,
#     Black,
# }
# struct Flag {
#     pub primary_colors: HashSet<Color>,
#     pub secondary_colors: HashSet<Color>,
# }
# trait Colors<'a> {
#     type ColorsIter: Iterator<Item = Color> + 'a;
#     fn colors(&'a self) -> Self::ColorsIter;
# }
impl<'a> Colors<'a> for Flag {
    type ColorsIter = DynIter<'a, Color>;
    fn colors(&'a self) -> Self::ColorsIter {
        self.primary_colors
            .iter()
            .chain(&self.secondary_colors)
            .filter(|color| **color != Color::Black)
            .copied()
            .into_dyn_iter()
    }
}

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.

No runtime deps