#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

#419 in Rust patterns

Download history 178/week @ 2023-11-27 276/week @ 2023-12-04 214/week @ 2023-12-11 126/week @ 2023-12-18 105/week @ 2023-12-25 115/week @ 2024-01-01 297/week @ 2024-01-08 258/week @ 2024-01-15 320/week @ 2024-01-22 258/week @ 2024-01-29 276/week @ 2024-02-05 192/week @ 2024-02-12 336/week @ 2024-02-19 242/week @ 2024-02-26 198/week @ 2024-03-04 113/week @ 2024-03-11

910 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