mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Auto merge of #105046 - scottmcm:vecdeque-vs-vec, r=Mark-Simulacrum

Browse Source 
Send `VecDeque::from_iter` via `Vec::from_iter`

Since it's O(1) to convert between them now, might as well reuse the logic.

Mostly for the various specializations it does, but might also save some monomorphization work if, say, people collect slice iterators into both `Vec`s and `VecDeque`s.
This commit is contained in:
bors 2022-12-05 08:45:03 +00:00
commit 203c8765ea
1 changed files with 12 additions and 5 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
library/alloc/src/collections/vec_deque/mod.rs
View File

@ -2699,12 +2699,18 @@ impl<T, A: Allocator> IndexMut<usize> for VecDeque<T, A> {
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
impl<T> FromIterator<T> for VecDeque<T> { impl<T> FromIterator<T> for VecDeque<T> {
#[inline]
fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> VecDeque<T> { fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> VecDeque<T> {
let iterator = iter.into_iter(); // Since converting is O(1) now, might as well re-use that logic
let (lower, _) = iterator.size_hint(); // (including things like the `vec::IntoIter`→`Vec` specialization)
let mut deq = VecDeque::with_capacity(lower); // especially as that could save us some monomorphiziation work
deq.extend(iterator); // if one uses the same iterators (like slice ones) with both.
deq return from_iter_via_vec(iter.into_iter());
#[inline]
fn from_iter_via_vec<U>(iter: impl Iterator<Item = U>) -> VecDeque<U> {
Vec::from_iter(iter).into()
}
} }
} }
@ -2791,6 +2797,7 @@ impl<T, A: Allocator> From<Vec<T, A>> for VecDeque<T, A> {
/// In its current implementation, this is a very cheap /// In its current implementation, this is a very cheap
/// conversion. This isn't yet a guarantee though, and /// conversion. This isn't yet a guarantee though, and
/// shouldn't be relied on. /// shouldn't be relied on.
#[inline]
fn from(other: Vec<T, A>) -> Self { fn from(other: Vec<T, A>) -> Self {
let (ptr, len, cap, alloc) = other.into_raw_parts_with_alloc(); let (ptr, len, cap, alloc) = other.into_raw_parts_with_alloc();
Self { head: 0, len, buf: unsafe { RawVec::from_raw_parts_in(ptr, cap, alloc) } } Self { head: 0, len, buf: unsafe { RawVec::from_raw_parts_in(ptr, cap, alloc) } }