1 //! Defines the `IntoIter` owned iterator for arrays.
5 iter::{self, ExactSizeIterator, FusedIterator, TrustedLen},
6 mem::{self, MaybeUninit},
11 /// A by-value [array] iterator.
12 #[stable(feature = "array_value_iter", since = "1.51.0")]
13 pub struct IntoIter<T, const N: usize> {
14 /// This is the array we are iterating over.
16 /// Elements with index `i` where `alive.start <= i < alive.end` have not
17 /// been yielded yet and are valid array entries. Elements with indices `i
18 /// < alive.start` or `i >= alive.end` have been yielded already and must
19 /// not be accessed anymore! Those dead elements might even be in a
20 /// completely uninitialized state!
22 /// So the invariants are:
23 /// - `data[alive]` is alive (i.e. contains valid elements)
24 /// - `data[..alive.start]` and `data[alive.end..]` are dead (i.e. the
25 /// elements were already read and must not be touched anymore!)
26 data: [MaybeUninit<T>; N],
28 /// The elements in `data` that have not been yielded yet.
31 /// - `alive.start <= alive.end`
32 /// - `alive.end <= N`
36 impl<T, const N: usize> IntoIter<T, N> {
37 /// Creates a new iterator over the given `array`.
39 /// *Note*: this method might be deprecated in the future,
40 /// after [`IntoIterator` is implemented for arrays][array-into-iter].
47 /// for value in array::IntoIter::new([1, 2, 3, 4, 5]) {
48 /// // The type of `value` is a `i32` here, instead of `&i32`
49 /// let _: i32 = value;
52 /// [array-into-iter]: https://github.com/rust-lang/rust/pull/65819
53 #[stable(feature = "array_value_iter", since = "1.51.0")]
54 pub fn new(array: [T; N]) -> Self {
55 // SAFETY: The transmute here is actually safe. The docs of `MaybeUninit`
58 // > `MaybeUninit<T>` is guaranteed to have the same size and alignment
61 // The docs even show a transmute from an array of `MaybeUninit<T>` to
64 // With that, this initialization satisfies the invariants.
66 // FIXME(LukasKalbertodt): actually use `mem::transmute` here, once it
67 // works with const generics:
68 // `mem::transmute::<[T; N], [MaybeUninit<T>; N]>(array)`
70 // Until then, we can use `mem::transmute_copy` to create a bitwise copy
71 // as a different type, then forget `array` so that it is not dropped.
73 let iter = Self { data: mem::transmute_copy(&array), alive: 0..N };
79 /// Returns an immutable slice of all elements that have not been yielded
81 #[stable(feature = "array_value_iter", since = "1.51.0")]
82 pub fn as_slice(&self) -> &[T] {
83 // SAFETY: We know that all elements within `alive` are properly initialized.
85 let slice = self.data.get_unchecked(self.alive.clone());
86 MaybeUninit::slice_assume_init_ref(slice)
90 /// Returns a mutable slice of all elements that have not been yielded yet.
91 #[stable(feature = "array_value_iter", since = "1.51.0")]
92 pub fn as_mut_slice(&mut self) -> &mut [T] {
93 // SAFETY: We know that all elements within `alive` are properly initialized.
95 let slice = self.data.get_unchecked_mut(self.alive.clone());
96 MaybeUninit::slice_assume_init_mut(slice)
101 #[stable(feature = "array_value_iter_impls", since = "1.40.0")]
102 impl<T, const N: usize> Iterator for IntoIter<T, N> {
104 fn next(&mut self) -> Option<Self::Item> {
105 // Get the next index from the front.
107 // Increasing `alive.start` by 1 maintains the invariant regarding
108 // `alive`. However, due to this change, for a short time, the alive
109 // zone is not `data[alive]` anymore, but `data[idx..alive.end]`.
110 self.alive.next().map(|idx| {
111 // Read the element from the array.
112 // SAFETY: `idx` is an index into the former "alive" region of the
113 // array. Reading this element means that `data[idx]` is regarded as
114 // dead now (i.e. do not touch). As `idx` was the start of the
115 // alive-zone, the alive zone is now `data[alive]` again, restoring
117 unsafe { self.data.get_unchecked(idx).assume_init_read() }
121 fn size_hint(&self) -> (usize, Option<usize>) {
122 let len = self.len();
127 fn fold<Acc, Fold>(mut self, init: Acc, mut fold: Fold) -> Acc
129 Fold: FnMut(Acc, Self::Item) -> Acc,
131 let data = &mut self.data;
132 // FIXME: This uses try_fold(&mut iter) instead of fold(iter) because the latter
133 // would go through the blanket `impl Iterator for &mut I` implementation
134 // which lacks inline annotations on its methods and adding those would be a larger
135 // perturbation than using try_fold here.
136 // Whether it would be beneficial to add those annotations should be investigated separately.
138 .try_fold::<_, _, Result<_, !>>(init, |acc, idx| {
139 // SAFETY: idx is obtained by folding over the `alive` range, which implies the
140 // value is currently considered alive but as the range is being consumed each value
141 // we read here will only be read once and then considered dead.
142 Ok(fold(acc, unsafe { data.get_unchecked(idx).assume_init_read() }))
147 fn count(self) -> usize {
151 fn last(mut self) -> Option<Self::Item> {
156 #[stable(feature = "array_value_iter_impls", since = "1.40.0")]
157 impl<T, const N: usize> DoubleEndedIterator for IntoIter<T, N> {
158 fn next_back(&mut self) -> Option<Self::Item> {
159 // Get the next index from the back.
161 // Decreasing `alive.end` by 1 maintains the invariant regarding
162 // `alive`. However, due to this change, for a short time, the alive
163 // zone is not `data[alive]` anymore, but `data[alive.start..=idx]`.
164 self.alive.next_back().map(|idx| {
165 // Read the element from the array.
166 // SAFETY: `idx` is an index into the former "alive" region of the
167 // array. Reading this element means that `data[idx]` is regarded as
168 // dead now (i.e. do not touch). As `idx` was the end of the
169 // alive-zone, the alive zone is now `data[alive]` again, restoring
171 unsafe { self.data.get_unchecked(idx).assume_init_read() }
176 #[stable(feature = "array_value_iter_impls", since = "1.40.0")]
177 impl<T, const N: usize> Drop for IntoIter<T, N> {
179 // SAFETY: This is safe: `as_mut_slice` returns exactly the sub-slice
180 // of elements that have not been moved out yet and that remain
182 unsafe { ptr::drop_in_place(self.as_mut_slice()) }
186 #[stable(feature = "array_value_iter_impls", since = "1.40.0")]
187 impl<T, const N: usize> ExactSizeIterator for IntoIter<T, N> {
188 fn len(&self) -> usize {
189 // Will never underflow due to the invariant `alive.start <=
191 self.alive.end - self.alive.start
193 fn is_empty(&self) -> bool {
194 self.alive.is_empty()
198 #[stable(feature = "array_value_iter_impls", since = "1.40.0")]
199 impl<T, const N: usize> FusedIterator for IntoIter<T, N> {}
201 // The iterator indeed reports the correct length. The number of "alive"
202 // elements (that will still be yielded) is the length of the range `alive`.
203 // This range is decremented in length in either `next` or `next_back`. It is
204 // always decremented by 1 in those methods, but only if `Some(_)` is returned.
205 #[stable(feature = "array_value_iter_impls", since = "1.40.0")]
206 unsafe impl<T, const N: usize> TrustedLen for IntoIter<T, N> {}
208 #[stable(feature = "array_value_iter_impls", since = "1.40.0")]
209 impl<T: Clone, const N: usize> Clone for IntoIter<T, N> {
210 fn clone(&self) -> Self {
211 // Note, we don't really need to match the exact same alive range, so
212 // we can just clone into offset 0 regardless of where `self` is.
213 let mut new = Self { data: MaybeUninit::uninit_array(), alive: 0..0 };
215 // Clone all alive elements.
216 for (src, dst) in iter::zip(self.as_slice(), &mut new.data) {
217 // Write a clone into the new array, then update its alive range.
218 // If cloning panics, we'll correctly drop the previous items.
219 dst.write(src.clone());
227 #[stable(feature = "array_value_iter_impls", since = "1.40.0")]
228 impl<T: fmt::Debug, const N: usize> fmt::Debug for IntoIter<T, N> {
229 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
230 // Only print the elements that were not yielded yet: we cannot
231 // access the yielded elements anymore.
232 f.debug_tuple("IntoIter").field(&self.as_slice()).finish()