non-empty-iter 0.2.0

Non-empty iterators.
Documentation 
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

//! Non-empty iterators that repeat items.

use core::iter;

use non_zero_size::Size;

use crate::non_empty::NonEmptyIterator;

/// Creates [`Repeat<T>`] non-empty iterator that repeats the given item endlessly.
pub const fn repeat<T: Clone>(item: T) -> Repeat<T> {
    Repeat::new(item)
}

/// Represents non-empty iterators that repeat the given item endlessly.
///
/// This `struct` is created by the [`repeat`] function. See its documentation for more.
#[derive(Debug, Clone)]
#[must_use = "non-empty iterators are lazy and do nothing unless consumed"]
pub struct Repeat<T: Clone> {
    item: T,
}

impl<T: Clone> Repeat<T> {
    /// Constructs [`Self`].
    pub const fn new(item: T) -> Self {
        Self { item }
    }
}

impl<T: Clone> IntoIterator for Repeat<T> {
    type Item = T;

    type IntoIter = iter::Repeat<T>;

    fn into_iter(self) -> Self::IntoIter {
        iter::repeat(self.item)
    }
}

unsafe impl<T: Clone> NonEmptyIterator for Repeat<T> {}

/// Creates [`RepeatWith<F>`] non-empty iterator that repeats items
/// computed from the given function endlessly.
pub const fn repeat_with<T, F: FnMut() -> T>(function: F) -> RepeatWith<F> {
    RepeatWith::new(function)
}

/// Represents non-empty iterators that repeat items computed from the given function endlessly.
///
/// This `struct` is created by the [`repeat_with`] function. See its documentation for more.
#[derive(Debug, Clone)]
#[must_use = "non-empty iterators are lazy and do nothing unless consumed"]
pub struct RepeatWith<F> {
    function: F,
}

impl<F> RepeatWith<F> {
    /// Constructs [`Self`].
    pub const fn new(function: F) -> Self {
        Self { function }
    }
}

impl<T, F: FnMut() -> T> IntoIterator for RepeatWith<F> {
    type Item = T;

    type IntoIter = iter::RepeatWith<F>;

    fn into_iter(self) -> Self::IntoIter {
        iter::repeat_with(self.function)
    }
}

unsafe impl<T, F: FnMut() -> T> NonEmptyIterator for RepeatWith<F> {}

/// Creates [`RepeatN<T>`] non-empty iterator that repeats the given item the given number of times.
pub const fn repeat_n<T: Clone>(item: T, count: Size) -> RepeatN<T> {
    RepeatN::new(item, count)
}

/// Represents non-empty iterators that repeat the given item exactly the given number of times.
///
/// This `struct` is created by the [`repeat_n`] function. See its documentation for more.
#[derive(Debug, Clone)]
#[must_use = "non-empty iterators are lazy and do nothing unless consumed"]
pub struct RepeatN<T: Clone> {
    item: T,
    count: Size,
}

impl<T: Clone> RepeatN<T> {
    /// Constructs [`Self`].
    pub const fn new(item: T, count: Size) -> Self {
        Self { item, count }
    }
}

impl<T: Clone> IntoIterator for RepeatN<T> {
    type Item = T;

    type IntoIter = iter::RepeatN<T>;

    fn into_iter(self) -> Self::IntoIter {
        iter::repeat_n(self.item, self.count.get())
    }
}

unsafe impl<T: Clone> NonEmptyIterator for RepeatN<T> {}