1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

//! Print all items from an iterator.
//!
//! **Example:** Print all items from an array slice
//!
//! ```no_run
//! use fmt_iter::FmtIter;
//! println!("{}", FmtIter::from(&[0, 12, 345]));
//! ```
//!
//! _Expected Output:_
//!
//! ```txt
//! 012345
//! ```
//!
//! **Example:** Repeat a certain character multiple times
//!
//! ```no_run
//! use fmt_iter::repeat;
//! println!("{}", repeat('x', 5));
//! ```
//!
//! _Expected Output:_
//!
//! ```txt
//! xxxxx
//! ```

#![no_std]
use core::fmt::{Display, Error, Formatter};
use derive_more::{AsMut, AsRef, Deref, DerefMut, From, IntoIterator};
use pipe_trait::Pipe;

/// Wrap around an [`Iterator`] to print all items.
///
/// **Example:** From an [`Iterator`]
///
/// ```
/// # use fmt_iter::FmtIter;
/// let iter = [0, 1, 2, 3].iter();
/// let fmt_iter = FmtIter::from(iter);
/// assert_eq!(fmt_iter.to_string(), "0123");
/// ```
///
/// **Example:** From an array slice
///
/// ```
/// # use fmt_iter::FmtIter;
/// let fmt_iter = FmtIter::from(&[0, 1, 2, 3] as &[_]);
/// assert_eq!(fmt_iter.to_string(), "0123");
/// ```
///
/// **Example:** From an array reference
///
/// ```
/// # use fmt_iter::FmtIter;
/// let fmt_iter = FmtIter::from(&[0, 1, 2, 3]);
/// assert_eq!(fmt_iter.to_string(), "0123");
/// ```
#[derive(Debug, Clone, Copy, PartialEq, Eq, AsMut, AsRef, Deref, DerefMut, From, IntoIterator)]
pub struct FmtIter<Inner>(Inner)
where
    Inner: Iterator + Clone,
    <Inner as Iterator>::Item: Display;

impl<'a, Item> From<&'a [Item]> for FmtIter<core::slice::Iter<'a, Item>>
where
    Item: Display + Clone,
{
    fn from(inner: &'a [Item]) -> Self {
        FmtIter(inner.iter())
    }
}

impl<'a, Item, const LEN: usize> From<&'a [Item; LEN]> for FmtIter<core::slice::Iter<'a, Item>>
where
    Item: Display + Clone,
{
    fn from(inner: &'a [Item; LEN]) -> Self {
        FmtIter::from(inner as &[Item])
    }
}

impl<Inner> Display for FmtIter<Inner>
where
    Inner: Iterator + Clone,
    Inner::Item: Display,
{
    fn fmt(&self, formatter: &mut Formatter<'_>) -> Result<(), Error> {
        for item in self.clone() {
            write!(formatter, "{}", item)?;
        }
        Ok(())
    }
}

/// Print a certain value multiple times.
///
/// **Example:**
///
/// ```
/// # use fmt_iter::repeat;
/// let fmt_iter = repeat(123, 5);
/// assert_eq!(fmt_iter.to_string(), "123123123123123");
/// ```
pub fn repeat<Value: Display + Clone>(
    value: Value,
    times: usize,
) -> FmtIter<impl Iterator<Item = Value> + Clone> {
    value
        .pipe(core::iter::repeat)
        .take(times)
        .pipe(FmtIter::from)
}