fmt_iter/
lib.rs

1//! Print all items from an iterator.
2//!
3//! **Example:** Print all items from an array slice
4//!
5//! ```no_run
6//! use fmt_iter::FmtIter;
7//! println!("{}", FmtIter::from(&[0, 12, 345]));
8//! ```
9//!
10//! _Expected Output:_
11//!
12//! ```txt
13//! 012345
14//! ```
15//!
16//! **Example:** Repeat a certain character multiple times
17//!
18//! ```no_run
19//! use fmt_iter::repeat;
20//! println!("{}", repeat('x', 5));
21//! ```
22//!
23//! _Expected Output:_
24//!
25//! ```txt
26//! xxxxx
27//! ```
28
29#![no_std]
30use core::fmt::{Display, Error, Formatter};
31use derive_more::{AsMut, AsRef, Deref, DerefMut, From};
32use itertools::repeat_n;
33
34/// Wrap around an [`Iterator`] to print all items.
35///
36/// **Example:** From an [`Iterator`]
37///
38/// ```
39/// # use fmt_iter::FmtIter;
40/// let iter = [0, 1, 2, 3].iter();
41/// let fmt_iter = FmtIter::from(iter);
42/// assert_eq!(fmt_iter.to_string(), "0123");
43/// ```
44///
45/// **Example:** From an array slice
46///
47/// ```
48/// # use fmt_iter::FmtIter;
49/// let fmt_iter = FmtIter::from(&[0, 1, 2, 3] as &[_]);
50/// assert_eq!(fmt_iter.to_string(), "0123");
51/// ```
52///
53/// **Example:** From an array reference
54///
55/// ```
56/// # use fmt_iter::FmtIter;
57/// let fmt_iter = FmtIter::from(&[0, 1, 2, 3]);
58/// assert_eq!(fmt_iter.to_string(), "0123");
59/// ```
60#[derive(Debug, Clone, Copy, PartialEq, Eq, AsMut, AsRef, Deref, DerefMut, From)]
61pub struct FmtIter<Inner>(Inner)
62where
63    Inner: Iterator + Clone,
64    <Inner as Iterator>::Item: Display;
65
66impl<'a, Item> From<&'a [Item]> for FmtIter<core::slice::Iter<'a, Item>>
67where
68    Item: Display + Clone,
69{
70    fn from(inner: &'a [Item]) -> Self {
71        FmtIter(inner.iter())
72    }
73}
74
75impl<'a, Item, const LEN: usize> From<&'a [Item; LEN]> for FmtIter<core::slice::Iter<'a, Item>>
76where
77    Item: Display + Clone,
78{
79    fn from(inner: &'a [Item; LEN]) -> Self {
80        FmtIter::from(inner as &[Item])
81    }
82}
83
84impl<Inner> Display for FmtIter<Inner>
85where
86    Inner: Iterator + Clone,
87    Inner::Item: Display,
88{
89    fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error> {
90        for item in self.clone() {
91            write!(formatter, "{}", item)?;
92        }
93        Ok(())
94    }
95}
96
97impl<Inner> Iterator for FmtIter<Inner>
98where
99    Inner: Iterator + Clone,
100    Inner::Item: Display,
101{
102    type Item = Inner::Item;
103
104    fn next(&mut self) -> Option<Self::Item> {
105        self.0.next()
106    }
107
108    fn size_hint(&self) -> (usize, Option<usize>) {
109        self.0.size_hint()
110    }
111}
112
113impl<Inner> ExactSizeIterator for FmtIter<Inner>
114where
115    Inner: ExactSizeIterator + Clone,
116    Inner::Item: Display,
117{
118    fn len(&self) -> usize {
119        self.0.len()
120    }
121}
122
123/// Print a certain value multiple times.
124///
125/// **Example:**
126///
127/// ```
128/// # use fmt_iter::repeat;
129/// let fmt_iter = repeat(123, 5);
130/// assert_eq!(fmt_iter.to_string(), "123123123123123");
131/// ```
132pub fn repeat<Value: Display + Clone>(
133    value: Value,
134    times: usize,
135) -> FmtIter<impl Iterator<Item = Value> + ExactSizeIterator + Clone> {
136    FmtIter::from(repeat_n(value, times))
137}