Skip to content

Commit 9fa6b3c

Browse files
borsbors
committed
Auto merge of #99929 - the8472:default-iters, r=scottmcm
Implement Default for some alloc/core iterators Add `Default` impls to the following collection iterators: * slice::{Iter, IterMut} * binary_heap::IntoIter * btree::map::{Iter, IterMut, Keys, Values, Range, IntoIter, IntoKeys, IntoValues} * btree::set::{Iter, IntoIter, Range} * linked_list::IntoIter * vec::IntoIter and these adapters: * adapters::{Chain, Cloned, Copied, Rev, Enumerate, Flatten, Fuse, Rev} For iterators which are generic over allocators it only implements it for the global allocator because we can't conjure an allocator from nothing or would have to turn the allocator field into an `Option` just for this change. These changes will be insta-stable. ACP: rust-lang/libs-team#77
2 parents 24a69af + e44836f commit 9fa6b3c

File tree

14 files changed

+371
-0
lines changed

14 files changed

+371
-0
lines changed

‎library/alloc/src/collections/binary_heap/mod.rs‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1468,6 +1468,20 @@ impl<T> ExactSizeIterator for IntoIter<T> {
14681468
#[stable(feature = "fused", since = "1.26.0")]
14691469
impl<T> FusedIterator for IntoIter<T> {}
14701470

1471+
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
1472+
impl<T> Default for IntoIter<T> {
1473+
/// Creates an empty `binary_heap::IntoIter`.
1474+
///
1475+
/// ```
1476+
/// # use std::collections::binary_heap;
1477+
/// let iter: binary_heap::IntoIter<u8> = Default::default();
1478+
/// assert_eq!(iter.len(), 0);
1479+
/// ```
1480+
fn default() -> Self {
1481+
IntoIter { iter: Default::default() }
1482+
}
1483+
}
1484+
14711485
// In addition to the SAFETY invariants of the following three unsafe traits
14721486
// also refer to the vec::in_place_collect module documentation to get an overview
14731487
#[unstable(issue = "none", feature = "inplace_iteration")]

‎library/alloc/src/collections/btree/map.rs‎

Lines changed: 121 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -362,6 +362,20 @@ impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for Iter<'_, K, V> {
362362
}
363363
}
364364

365+
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
366+
impl<'a, K: 'a, V: 'a> Default for Iter<'a, K, V> {
367+
/// Creates an empty `btree_map::Iter`.
368+
///
369+
/// ```
370+
/// # use std::collections::btree_map;
371+
/// let iter: btree_map::Iter<'_, u8, u8> = Default::default();
372+
/// assert_eq!(iter.len(), 0);
373+
/// ```
374+
fn default() -> Self {
375+
Iter { range: Default::default(), length: 0 }
376+
}
377+
}
378+
365379
/// A mutable iterator over the entries of a `BTreeMap`.
366380
///
367381
/// This `struct` is created by the [`iter_mut`] method on [`BTreeMap`]. See its
@@ -386,6 +400,20 @@ impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for IterMut<'_, K, V> {
386400
}
387401
}
388402

403+
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
404+
impl<'a, K: 'a, V: 'a> Default for IterMut<'a, K, V> {
405+
/// Creates an empty `btree_map::IterMut`.
406+
///
407+
/// ```
408+
/// # use std::collections::btree_map;
409+
/// let iter: btree_map::IterMut<'_, u8, u8> = Default::default();
410+
/// assert_eq!(iter.len(), 0);
411+
/// ```
412+
fn default() -> Self {
413+
IterMut { range: Default::default(), length: 0, _marker: PhantomData {} }
414+
}
415+
}
416+
389417
/// An owning iterator over the entries of a `BTreeMap`.
390418
///
391419
/// This `struct` is created by the [`into_iter`] method on [`BTreeMap`]
@@ -421,6 +449,23 @@ impl<K: Debug, V: Debug, A: Allocator + Clone> Debug for IntoIter<K, V, A> {
421449
}
422450
}
423451

452+
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
453+
impl<K, V, A> Default for IntoIter<K, V, A>
454+
where
455+
A: Allocator + Default + Clone,
456+
{
457+
/// Creates an empty `btree_map::IntoIter`.
458+
///
459+
/// ```
460+
/// # use std::collections::btree_map;
461+
/// let iter: btree_map::IntoIter<u8, u8> = Default::default();
462+
/// assert_eq!(iter.len(), 0);
463+
/// ```
464+
fn default() -> Self {
465+
IntoIter { range: Default::default(), length: 0, alloc: Default::default() }
466+
}
467+
}
468+
424469
/// An iterator over the keys of a `BTreeMap`.
425470
///
426471
/// This `struct` is created by the [`keys`] method on [`BTreeMap`]. See its
@@ -1768,6 +1813,20 @@ impl<K, V> Clone for Keys<'_, K, V> {
17681813
}
17691814
}
17701815

1816+
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
1817+
impl<K, V> Default for Keys<'_, K, V> {
1818+
/// Creates an empty `btree_map::Keys`.
1819+
///
1820+
/// ```
1821+
/// # use std::collections::btree_map;
1822+
/// let iter: btree_map::Keys<'_, u8, u8> = Default::default();
1823+
/// assert_eq!(iter.len(), 0);
1824+
/// ```
1825+
fn default() -> Self {
1826+
Keys { inner: Default::default() }
1827+
}
1828+
}
1829+
17711830
#[stable(feature = "rust1", since = "1.0.0")]
17721831
impl<'a, K, V> Iterator for Values<'a, K, V> {
17731832
type Item = &'a V;
@@ -1809,6 +1868,20 @@ impl<K, V> Clone for Values<'_, K, V> {
18091868
}
18101869
}
18111870

1871+
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
1872+
impl<K, V> Default for Values<'_, K, V> {
1873+
/// Creates an empty `btree_map::Values`.
1874+
///
1875+
/// ```
1876+
/// # use std::collections::btree_map;
1877+
/// let iter: btree_map::Values<'_, u8, u8> = Default::default();
1878+
/// assert_eq!(iter.len(), 0);
1879+
/// ```
1880+
fn default() -> Self {
1881+
Values { inner: Default::default() }
1882+
}
1883+
}
1884+
18121885
/// An iterator produced by calling `drain_filter` on BTreeMap.
18131886
#[unstable(feature = "btree_drain_filter", issue = "70530")]
18141887
pub struct DrainFilter<
@@ -1945,6 +2018,20 @@ impl<'a, K, V> Iterator for Range<'a, K, V> {
19452018
}
19462019
}
19472020

2021+
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
2022+
impl<K, V> Default for Range<'_, K, V> {
2023+
/// Creates an empty `btree_map::Range`.
2024+
///
2025+
/// ```
2026+
/// # use std::collections::btree_map;
2027+
/// let iter: btree_map::Range<'_, u8, u8> = Default::default();
2028+
/// assert_eq!(iter.count(), 0);
2029+
/// ```
2030+
fn default() -> Self {
2031+
Range { inner: Default::default() }
2032+
}
2033+
}
2034+
19482035
#[stable(feature = "map_values_mut", since = "1.10.0")]
19492036
impl<'a, K, V> Iterator for ValuesMut<'a, K, V> {
19502037
type Item = &'a mut V;
@@ -2021,6 +2108,23 @@ impl<K, V, A: Allocator + Clone> ExactSizeIterator for IntoKeys<K, V, A> {
20212108
#[stable(feature = "map_into_keys_values", since = "1.54.0")]
20222109
impl<K, V, A: Allocator + Clone> FusedIterator for IntoKeys<K, V, A> {}
20232110

2111+
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
2112+
impl<K, V, A> Default for IntoKeys<K, V, A>
2113+
where
2114+
A: Allocator + Default + Clone,
2115+
{
2116+
/// Creates an empty `btree_map::IntoKeys`.
2117+
///
2118+
/// ```
2119+
/// # use std::collections::btree_map;
2120+
/// let iter: btree_map::IntoKeys<u8, u8> = Default::default();
2121+
/// assert_eq!(iter.len(), 0);
2122+
/// ```
2123+
fn default() -> Self {
2124+
IntoKeys { inner: Default::default() }
2125+
}
2126+
}
2127+
20242128
#[stable(feature = "map_into_keys_values", since = "1.54.0")]
20252129
impl<K, V, A: Allocator + Clone> Iterator for IntoValues<K, V, A> {
20262130
type Item = V;
@@ -2055,6 +2159,23 @@ impl<K, V, A: Allocator + Clone> ExactSizeIterator for IntoValues<K, V, A> {
20552159
#[stable(feature = "map_into_keys_values", since = "1.54.0")]
20562160
impl<K, V, A: Allocator + Clone> FusedIterator for IntoValues<K, V, A> {}
20572161

2162+
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
2163+
impl<K, V, A> Default for IntoValues<K, V, A>
2164+
where
2165+
A: Allocator + Default + Clone,
2166+
{
2167+
/// Creates an empty `btree_map::IntoValues`.
2168+
///
2169+
/// ```
2170+
/// # use std::collections::btree_map;
2171+
/// let iter: btree_map::IntoValues<u8, u8> = Default::default();
2172+
/// assert_eq!(iter.len(), 0);
2173+
/// ```
2174+
fn default() -> Self {
2175+
IntoValues { inner: Default::default() }
2176+
}
2177+
}
2178+
20582179
#[stable(feature = "btree_range", since = "1.17.0")]
20592180
impl<'a, K, V> DoubleEndedIterator for Range<'a, K, V> {
20602181
fn next_back(&mut self) -> Option<(&'a K, &'a V)> {

‎library/alloc/src/collections/btree/navigate.rs‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -19,6 +19,12 @@ impl<'a, K: 'a, V: 'a> Clone for LeafRange<marker::Immut<'a>, K, V> {
1919
}
2020
}
2121

22+
impl<B, K, V> Default for LeafRange<B, K, V> {
23+
fn default() -> Self {
24+
LeafRange { front: None, back: None }
25+
}
26+
}
27+
2228
impl<BorrowType, K, V> LeafRange<BorrowType, K, V> {
2329
pub fn none() -> Self {
2430
LeafRange { front: None, back: None }
@@ -124,6 +130,12 @@ pub struct LazyLeafRange<BorrowType, K, V> {
124130
back: Option<LazyLeafHandle<BorrowType, K, V>>,
125131
}
126132

133+
impl<B, K, V> Default for LazyLeafRange<B, K, V> {
134+
fn default() -> Self {
135+
LazyLeafRange { front: None, back: None }
136+
}
137+
}
138+
127139
impl<'a, K: 'a, V: 'a> Clone for LazyLeafRange<marker::Immut<'a>, K, V> {
128140
fn clone(&self) -> Self {
129141
LazyLeafRange { front: self.front.clone(), back: self.back.clone() }

‎library/alloc/src/collections/btree/set.rs‎

Lines changed: 46 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1539,6 +1539,21 @@ impl<T, A: Allocator + Clone> Iterator for IntoIter<T, A> {
15391539
self.iter.size_hint()
15401540
}
15411541
}
1542+
1543+
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
1544+
impl<T> Default for Iter<'_, T> {
1545+
/// Creates an empty `btree_set::Iter`.
1546+
///
1547+
/// ```
1548+
/// # use std::collections::btree_set;
1549+
/// let iter: btree_set::Iter<'_, u8> = Default::default();
1550+
/// assert_eq!(iter.len(), 0);
1551+
/// ```
1552+
fn default() -> Self {
1553+
Iter { iter: Default::default() }
1554+
}
1555+
}
1556+
15421557
#[stable(feature = "rust1", since = "1.0.0")]
15431558
impl<T, A: Allocator + Clone> DoubleEndedIterator for IntoIter<T, A> {
15441559
fn next_back(&mut self) -> Option<T> {
@@ -1555,6 +1570,23 @@ impl<T, A: Allocator + Clone> ExactSizeIterator for IntoIter<T, A> {
15551570
#[stable(feature = "fused", since = "1.26.0")]
15561571
impl<T, A: Allocator + Clone> FusedIterator for IntoIter<T, A> {}
15571572

1573+
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
1574+
impl<T, A> Default for IntoIter<T, A>
1575+
where
1576+
A: Allocator + Default + Clone,
1577+
{
1578+
/// Creates an empty `btree_set::IntoIter`.
1579+
///
1580+
/// ```
1581+
/// # use std::collections::btree_set;
1582+
/// let iter: btree_set::IntoIter<u8> = Default::default();
1583+
/// assert_eq!(iter.len(), 0);
1584+
/// ```
1585+
fn default() -> Self {
1586+
IntoIter { iter: Default::default() }
1587+
}
1588+
}
1589+
15581590
#[stable(feature = "btree_range", since = "1.17.0")]
15591591
impl<T> Clone for Range<'_, T> {
15601592
fn clone(&self) -> Self {
@@ -1593,6 +1625,20 @@ impl<'a, T> DoubleEndedIterator for Range<'a, T> {
15931625
#[stable(feature = "fused", since = "1.26.0")]
15941626
impl<T> FusedIterator for Range<'_, T> {}
15951627

1628+
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
1629+
impl<T> Default for Range<'_, T> {
1630+
/// Creates an empty `btree_set::Range`.
1631+
///
1632+
/// ```
1633+
/// # use std::collections::btree_set;
1634+
/// let iter: btree_set::Range<'_, u8> = Default::default();
1635+
/// assert_eq!(iter.count(), 0);
1636+
/// ```
1637+
fn default() -> Self {
1638+
Range { iter: Default::default() }
1639+
}
1640+
}
1641+
15961642
#[stable(feature = "rust1", since = "1.0.0")]
15971643
impl<T, A: Allocator + Clone> Clone for Difference<'_, T, A> {
15981644
fn clone(&self) -> Self {

‎library/alloc/src/collections/linked_list.rs‎

Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1075,6 +1075,20 @@ impl<T> ExactSizeIterator for Iter<'_, T> {}
10751075
#[stable(feature = "fused", since = "1.26.0")]
10761076
impl<T> FusedIterator for Iter<'_, T> {}
10771077

1078+
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
1079+
impl<T> Default for Iter<'_, T> {
1080+
/// Creates an empty `linked_list::Iter`.
1081+
///
1082+
/// ```
1083+
/// # use std::collections::linked_list;
1084+
/// let iter: linked_list::Iter<'_, u8> = Default::default();
1085+
/// assert_eq!(iter.len(), 0);
1086+
/// ```
1087+
fn default() -> Self {
1088+
Iter { head: None, tail: None, len: 0, marker: Default::default() }
1089+
}
1090+
}
1091+
10781092
#[stable(feature = "rust1", since = "1.0.0")]
10791093
impl<'a, T> Iterator for IterMut<'a, T> {
10801094
type Item = &'a mut T;
@@ -1129,6 +1143,13 @@ impl<T> ExactSizeIterator for IterMut<'_, T> {}
11291143
#[stable(feature = "fused", since = "1.26.0")]
11301144
impl<T> FusedIterator for IterMut<'_, T> {}
11311145

1146+
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
1147+
impl<T> Default for IterMut<'_, T> {
1148+
fn default() -> Self {
1149+
IterMut { head: None, tail: None, len: 0, marker: Default::default() }
1150+
}
1151+
}
1152+
11321153
/// A cursor over a `LinkedList`.
11331154
///
11341155
/// A `Cursor` is like an iterator, except that it can freely seek back-and-forth.
@@ -1808,6 +1829,20 @@ impl<T> ExactSizeIterator for IntoIter<T> {}
18081829
#[stable(feature = "fused", since = "1.26.0")]
18091830
impl<T> FusedIterator for IntoIter<T> {}
18101831

1832+
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
1833+
impl<T> Default for IntoIter<T> {
1834+
/// Creates an empty `linked_list::IntoIter`.
1835+
///
1836+
/// ```
1837+
/// # use std::collections::linked_list;
1838+
/// let iter: linked_list::IntoIter<u8> = Default::default();
1839+
/// assert_eq!(iter.len(), 0);
1840+
/// ```
1841+
fn default() -> Self {
1842+
LinkedList::new().into_iter()
1843+
}
1844+
}
1845+
18111846
#[stable(feature = "rust1", since = "1.0.0")]
18121847
impl<T> FromIterator<T> for LinkedList<T> {
18131848
fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {

‎library/alloc/src/vec/into_iter.rs‎

Lines changed: 18 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -347,6 +347,24 @@ impl<T, A: Allocator> FusedIterator for IntoIter<T, A> {}
347347
#[unstable(feature = "trusted_len", issue = "37572")]
348348
unsafe impl<T, A: Allocator> TrustedLen for IntoIter<T, A> {}
349349

350+
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
351+
impl<T, A> Default for IntoIter<T, A>
352+
where
353+
A: Allocator + Default,
354+
{
355+
/// Creates an empty `vec::IntoIter`.
356+
///
357+
/// ```
358+
/// # use std::vec;
359+
/// let iter: vec::IntoIter<u8> = Default::default();
360+
/// assert_eq!(iter.len(), 0);
361+
/// assert_eq!(iter.as_slice(), &[]);
362+
/// ```
363+
fn default() -> Self {
364+
super::Vec::new_in(Default::default()).into_iter()
365+
}
366+
}
367+
350368
#[doc(hidden)]
351369
#[unstable(issue = "none", feature = "std_internals")]
352370
#[rustc_unsafe_specialization_marker]

0 commit comments

Comments
 (0)