mathieu/granite-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Auto merge of #99929 - the8472:default-iters, r=scottmcm

Browse source 
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: https://github.com/rust-lang/libs-team/issues/77
This commit is contained in:
bors 2023-03-25 06:29:46 +00:00
commit 9fa6b3c157
14 changed files with 371 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
library/alloc/src/collections/binary_heap/mod.rs
View file

@ -1468,6 +1468,20 @@ impl<T> ExactSizeIterator for IntoIter<T> {
#[stable(feature = "fused", since = "1.26.0")]
impl<T> FusedIterator for IntoIter<T> {}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<T> Default for IntoIter<T> {
/// Creates an empty `binary_heap::IntoIter`.
///
/// ```
/// # use std::collections::binary_heap;
/// let iter: binary_heap::IntoIter<u8> = Default::default();
/// assert_eq!(iter.len(), 0);
/// ```
fn default() -> Self {
IntoIter { iter: Default::default() }
}
}
// In addition to the SAFETY invariants of the following three unsafe traits
// also refer to the vec::in_place_collect module documentation to get an overview
#[unstable(issue = "none", feature = "inplace_iteration")]

121
library/alloc/src/collections/btree/map.rs
View file

@ -362,6 +362,20 @@ impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for Iter<'_, K, V> {
}
}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<'a, K: 'a, V: 'a> Default for Iter<'a, K, V> {
/// Creates an empty `btree_map::Iter`.
///
/// ```
/// # use std::collections::btree_map;
/// let iter: btree_map::Iter<'_, u8, u8> = Default::default();
/// assert_eq!(iter.len(), 0);
/// ```
fn default() -> Self {
Iter { range: Default::default(), length: 0 }
}
}
/// A mutable iterator over the entries of a `BTreeMap`.
///
/// 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> {
}
}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<'a, K: 'a, V: 'a> Default for IterMut<'a, K, V> {
/// Creates an empty `btree_map::IterMut`.
///
/// ```
/// # use std::collections::btree_map;
/// let iter: btree_map::IterMut<'_, u8, u8> = Default::default();
/// assert_eq!(iter.len(), 0);
/// ```
fn default() -> Self {
IterMut { range: Default::default(), length: 0, _marker: PhantomData {} }
}
}
/// An owning iterator over the entries of a `BTreeMap`.
///
/// 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> {
}
}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<K, V, A> Default for IntoIter<K, V, A>
where
A: Allocator + Default + Clone,
{
/// Creates an empty `btree_map::IntoIter`.
///
/// ```
/// # use std::collections::btree_map;
/// let iter: btree_map::IntoIter<u8, u8> = Default::default();
/// assert_eq!(iter.len(), 0);
/// ```
fn default() -> Self {
IntoIter { range: Default::default(), length: 0, alloc: Default::default() }
}
}
/// An iterator over the keys of a `BTreeMap`.
///
/// This `struct` is created by the [`keys`] method on [`BTreeMap`]. See its
@ -1768,6 +1813,20 @@ impl<K, V> Clone for Keys<'_, K, V> {
}
}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<K, V> Default for Keys<'_, K, V> {
/// Creates an empty `btree_map::Keys`.
///
/// ```
/// # use std::collections::btree_map;
/// let iter: btree_map::Keys<'_, u8, u8> = Default::default();
/// assert_eq!(iter.len(), 0);
/// ```
fn default() -> Self {
Keys { inner: Default::default() }
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, K, V> Iterator for Values<'a, K, V> {
type Item = &'a V;
@ -1809,6 +1868,20 @@ impl<K, V> Clone for Values<'_, K, V> {
}
}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<K, V> Default for Values<'_, K, V> {
/// Creates an empty `btree_map::Values`.
///
/// ```
/// # use std::collections::btree_map;
/// let iter: btree_map::Values<'_, u8, u8> = Default::default();
/// assert_eq!(iter.len(), 0);
/// ```
fn default() -> Self {
Values { inner: Default::default() }
}
}
/// An iterator produced by calling `drain_filter` on BTreeMap.
#[unstable(feature = "btree_drain_filter", issue = "70530")]
pub struct DrainFilter<
@ -1945,6 +2018,20 @@ impl<'a, K, V> Iterator for Range<'a, K, V> {
}
}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<K, V> Default for Range<'_, K, V> {
/// Creates an empty `btree_map::Range`.
///
/// ```
/// # use std::collections::btree_map;
/// let iter: btree_map::Range<'_, u8, u8> = Default::default();
/// assert_eq!(iter.count(), 0);
/// ```
fn default() -> Self {
Range { inner: Default::default() }
}
}
#[stable(feature = "map_values_mut", since = "1.10.0")]
impl<'a, K, V> Iterator for ValuesMut<'a, K, V> {
type Item = &'a mut V;
@ -2021,6 +2108,23 @@ impl<K, V, A: Allocator + Clone> ExactSizeIterator for IntoKeys<K, V, A> {
#[stable(feature = "map_into_keys_values", since = "1.54.0")]
impl<K, V, A: Allocator + Clone> FusedIterator for IntoKeys<K, V, A> {}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<K, V, A> Default for IntoKeys<K, V, A>
where
A: Allocator + Default + Clone,
{
/// Creates an empty `btree_map::IntoKeys`.
///
/// ```
/// # use std::collections::btree_map;
/// let iter: btree_map::IntoKeys<u8, u8> = Default::default();
/// assert_eq!(iter.len(), 0);
/// ```
fn default() -> Self {
IntoKeys { inner: Default::default() }
}
}
#[stable(feature = "map_into_keys_values", since = "1.54.0")]
impl<K, V, A: Allocator + Clone> Iterator for IntoValues<K, V, A> {
type Item = V;
@ -2055,6 +2159,23 @@ impl<K, V, A: Allocator + Clone> ExactSizeIterator for IntoValues<K, V, A> {
#[stable(feature = "map_into_keys_values", since = "1.54.0")]
impl<K, V, A: Allocator + Clone> FusedIterator for IntoValues<K, V, A> {}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<K, V, A> Default for IntoValues<K, V, A>
where
A: Allocator + Default + Clone,
{
/// Creates an empty `btree_map::IntoValues`.
///
/// ```
/// # use std::collections::btree_map;
/// let iter: btree_map::IntoValues<u8, u8> = Default::default();
/// assert_eq!(iter.len(), 0);
/// ```
fn default() -> Self {
IntoValues { inner: Default::default() }
}
}
#[stable(feature = "btree_range", since = "1.17.0")]
impl<'a, K, V> DoubleEndedIterator for Range<'a, K, V> {
fn next_back(&mut self) -> Option<(&'a K, &'a V)> {

12
library/alloc/src/collections/btree/navigate.rs
View file

@ -19,6 +19,12 @@ impl<'a, K: 'a, V: 'a> Clone for LeafRange<marker::Immut<'a>, K, V> {
}
}
impl<B, K, V> Default for LeafRange<B, K, V> {
fn default() -> Self {
LeafRange { front: None, back: None }
}
}
impl<BorrowType, K, V> LeafRange<BorrowType, K, V> {
pub fn none() -> Self {
LeafRange { front: None, back: None }
@ -124,6 +130,12 @@ pub struct LazyLeafRange<BorrowType, K, V> {
back: Option<LazyLeafHandle<BorrowType, K, V>>,
}
impl<B, K, V> Default for LazyLeafRange<B, K, V> {
fn default() -> Self {
LazyLeafRange { front: None, back: None }
}
}
impl<'a, K: 'a, V: 'a> Clone for LazyLeafRange<marker::Immut<'a>, K, V> {
fn clone(&self) -> Self {
LazyLeafRange { front: self.front.clone(), back: self.back.clone() }

46
library/alloc/src/collections/btree/set.rs
View file

@ -1539,6 +1539,21 @@ impl<T, A: Allocator + Clone> Iterator for IntoIter<T, A> {
self.iter.size_hint()
}
}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<T> Default for Iter<'_, T> {
/// Creates an empty `btree_set::Iter`.
///
/// ```
/// # use std::collections::btree_set;
/// let iter: btree_set::Iter<'_, u8> = Default::default();
/// assert_eq!(iter.len(), 0);
/// ```
fn default() -> Self {
Iter { iter: Default::default() }
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T, A: Allocator + Clone> DoubleEndedIterator for IntoIter<T, A> {
fn next_back(&mut self) -> Option<T> {
@ -1555,6 +1570,23 @@ impl<T, A: Allocator + Clone> ExactSizeIterator for IntoIter<T, A> {
#[stable(feature = "fused", since = "1.26.0")]
impl<T, A: Allocator + Clone> FusedIterator for IntoIter<T, A> {}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<T, A> Default for IntoIter<T, A>
where
A: Allocator + Default + Clone,
{
/// Creates an empty `btree_set::IntoIter`.
///
/// ```
/// # use std::collections::btree_set;
/// let iter: btree_set::IntoIter<u8> = Default::default();
/// assert_eq!(iter.len(), 0);
/// ```
fn default() -> Self {
IntoIter { iter: Default::default() }
}
}
#[stable(feature = "btree_range", since = "1.17.0")]
impl<T> Clone for Range<'_, T> {
fn clone(&self) -> Self {
@ -1593,6 +1625,20 @@ impl<'a, T> DoubleEndedIterator for Range<'a, T> {
#[stable(feature = "fused", since = "1.26.0")]
impl<T> FusedIterator for Range<'_, T> {}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<T> Default for Range<'_, T> {
/// Creates an empty `btree_set::Range`.
///
/// ```
/// # use std::collections::btree_set;
/// let iter: btree_set::Range<'_, u8> = Default::default();
/// assert_eq!(iter.count(), 0);
/// ```
fn default() -> Self {
Range { iter: Default::default() }
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T, A: Allocator + Clone> Clone for Difference<'_, T, A> {
fn clone(&self) -> Self {

35
library/alloc/src/collections/linked_list.rs
View file

@ -1075,6 +1075,20 @@ impl<T> ExactSizeIterator for Iter<'_, T> {}
#[stable(feature = "fused", since = "1.26.0")]
impl<T> FusedIterator for Iter<'_, T> {}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<T> Default for Iter<'_, T> {
/// Creates an empty `linked_list::Iter`.
///
/// ```
/// # use std::collections::linked_list;
/// let iter: linked_list::Iter<'_, u8> = Default::default();
/// assert_eq!(iter.len(), 0);
/// ```
fn default() -> Self {
Iter { head: None, tail: None, len: 0, marker: Default::default() }
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<'a, T> Iterator for IterMut<'a, T> {
type Item = &'a mut T;
@ -1129,6 +1143,13 @@ impl<T> ExactSizeIterator for IterMut<'_, T> {}
#[stable(feature = "fused", since = "1.26.0")]
impl<T> FusedIterator for IterMut<'_, T> {}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<T> Default for IterMut<'_, T> {
fn default() -> Self {
IterMut { head: None, tail: None, len: 0, marker: Default::default() }
}
}
/// A cursor over a `LinkedList`.
///
/// 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> {}
#[stable(feature = "fused", since = "1.26.0")]
impl<T> FusedIterator for IntoIter<T> {}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<T> Default for IntoIter<T> {
/// Creates an empty `linked_list::IntoIter`.
///
/// ```
/// # use std::collections::linked_list;
/// let iter: linked_list::IntoIter<u8> = Default::default();
/// assert_eq!(iter.len(), 0);
/// ```
fn default() -> Self {
LinkedList::new().into_iter()
}
}
#[stable(feature = "rust1", since = "1.0.0")]
impl<T> FromIterator<T> for LinkedList<T> {
fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {

18
library/alloc/src/vec/into_iter.rs
View file

@ -347,6 +347,24 @@ impl<T, A: Allocator> FusedIterator for IntoIter<T, A> {}
#[unstable(feature = "trusted_len", issue = "37572")]
unsafe impl<T, A: Allocator> TrustedLen for IntoIter<T, A> {}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<T, A> Default for IntoIter<T, A>
where
A: Allocator + Default,
{
/// Creates an empty `vec::IntoIter`.
///
/// ```
/// # use std::vec;
/// let iter: vec::IntoIter<u8> = Default::default();
/// assert_eq!(iter.len(), 0);
/// assert_eq!(iter.as_slice(), &[]);
/// ```
fn default() -> Self {
super::Vec::new_in(Default::default()).into_iter()
}
}
#[doc(hidden)]
#[unstable(issue = "none", feature = "std_internals")]
#[rustc_unsafe_specialization_marker]

22
library/core/src/iter/adapters/chain.rs
View file

@ -282,6 +282,28 @@ where
{
}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<A: Default, B: Default> Default for Chain<A, B> {
/// Creates a `Chain` from the default values for `A` and `B`.
///
/// ```
/// # use core::iter::Chain;
/// # use core::slice;
/// # use std::collections::{btree_set, BTreeSet};
/// # use std::mem;
/// struct Foo<'a>(Chain<slice::Iter<'a, u8>, btree_set::Iter<'a, u8>>);
///
/// let set = BTreeSet::<u8>::new();
/// let slice: &[u8] = &[];
/// let mut foo = Foo(slice.iter().chain(set.iter()));
///
/// // take requires `Default`
/// let _: Chain<_, _> = mem::take(&mut foo.0);
fn default() -> Self {
Chain::new(Default::default(), Default::default())
}
}
#[inline]
fn and_then_or_clear<T, U>(opt: &mut Option<T>, f: impl FnOnce(&mut T) -> Option<U>) -> Option<U> {
let x = f(opt.as_mut()?);

14
library/core/src/iter/adapters/cloned.rs
View file

@ -153,3 +153,17 @@ where
item.clone()
}
}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<I: Default> Default for Cloned<I> {
/// Creates a `Cloned` iterator from the default value of `I`
/// ```
/// # use core::slice;
/// # use core::iter::Cloned;
/// let iter: Cloned<slice::Iter<'_, u8>> = Default::default();
/// assert_eq!(iter.len(), 0);
/// ```
fn default() -> Self {
Self::new(Default::default())
}
}

14
library/core/src/iter/adapters/copied.rs
View file

@ -240,3 +240,17 @@ where
}
}
}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<I: Default> Default for Copied<I> {
/// Creates a `Copied` iterator from the default value of `I`
/// ```
/// # use core::slice;
/// # use core::iter::Copied;
/// let iter: Copied<slice::Iter<'_, u8>> = Default::default();
/// assert_eq!(iter.len(), 0);
/// ```
fn default() -> Self {
Self::new(Default::default())
}
}

14
library/core/src/iter/adapters/enumerate.rs
View file

@ -264,3 +264,17 @@ where
#[unstable(issue = "none", feature = "inplace_iteration")]
unsafe impl<I: InPlaceIterable> InPlaceIterable for Enumerate<I> {}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<I: Default> Default for Enumerate<I> {
/// Creates an `Enumerate` iterator from the default value of `I`
/// ```
/// # use core::slice;
/// # use std::iter::Enumerate;
/// let iter: Enumerate<slice::Iter<'_, u8>> = Default::default();
/// assert_eq!(iter.len(), 0);
/// ```
fn default() -> Self {
Enumerate::new(Default::default())
}
}

18
library/core/src/iter/adapters/flatten.rs
View file

@ -302,6 +302,24 @@ where
{
}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<I> Default for Flatten<I>
where
I: Default + Iterator<Item: IntoIterator>,
{
/// Creates a `Flatten` iterator from the default value of `I`.
///
/// ```
/// # use core::slice;
/// # use std::iter::Flatten;
/// let iter: Flatten<slice::Iter<'_, [u8; 4]>> = Default::default();
/// assert_eq!(iter.count(), 0);
/// ```
fn default() -> Self {
Flatten::new(Default::default())
}
}
/// Real logic of both `Flatten` and `FlatMap` which simply delegate to
/// this type.
#[derive(Clone, Debug)]

15
library/core/src/iter/adapters/fuse.rs
View file

@ -181,6 +181,21 @@ where
}
}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<I: Default> Default for Fuse<I> {
/// Creates a `Fuse` iterator from the default value of `I`.
///
/// ```
/// # use core::slice;
/// # use std::iter::Fuse;
/// let iter: Fuse<slice::Iter<'_, u8>> = Default::default();
/// assert_eq!(iter.len(), 0);
/// ```
fn default() -> Self {
Fuse { iter: Default::default() }
}
}
#[unstable(feature = "trusted_len", issue = "37572")]
// SAFETY: `TrustedLen` requires that an accurate length is reported via `size_hint()`. As `Fuse`
// is just forwarding this to the wrapped iterator `I` this property is preserved and it is safe to

14
library/core/src/iter/adapters/rev.rs
View file

@ -135,3 +135,17 @@ impl<I> FusedIterator for Rev<I> where I: FusedIterator + DoubleEndedIterator {}
#[unstable(feature = "trusted_len", issue = "37572")]
unsafe impl<I> TrustedLen for Rev<I> where I: TrustedLen + DoubleEndedIterator {}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<I: Default> Default for Rev<I> {
/// Creates a `Rev` iterator from the default value of `I`
/// ```
/// # use core::slice;
/// # use core::iter::Rev;
/// let iter: Rev<slice::Iter<'_, u8>> = Default::default();
/// assert_eq!(iter.len(), 0);
/// ```
fn default() -> Self {
Rev::new(Default::default())
}
}

14
library/core/src/slice/iter/macros.rs
View file

@ -393,6 +393,20 @@ macro_rules! iterator {
}
}
}
#[stable(feature = "default_iters", since = "CURRENT_RUSTC_VERSION")]
impl<T> Default for $name<'_, T> {
/// Creates an empty slice iterator.
///
/// ```
#[doc = concat!("# use core::slice::", stringify!($name), ";")]
#[doc = concat!("let iter: ", stringify!($name<'_, u8>), " = Default::default();")]
/// assert_eq!(iter.len(), 0);
/// ```
fn default() -> Self {
(& $( $mut_ )? []).into_iter()
}
}
}
}