library/alloc/src/vec/mod.rs

   1 //! A contiguous growable array type with heap-allocated contents, written
   2 //! `Vec<T>`.
   3 //!
   4 //! Vectors have `O(1)` indexing, amortized `O(1)` push (to the end) and
   5 //! `O(1)` pop (from the end).
   6 //!
   7 //! Vectors ensure they never allocate more than `isize::MAX` bytes.
   8 //!
   9 //! # Examples
  10 //!
  11 //! You can explicitly create a [`Vec`] with [`Vec::new`]:
  12 //!
  13 //! ```
  14 //! let v: Vec<i32> = Vec::new();
  15 //! ```
  16 //!
  17 //! ...or by using the [`vec!`] macro:
  18 //!
  19 //! ```
  20 //! let v: Vec<i32> = vec![];
  21 //!
  22 //! let v = vec![1, 2, 3, 4, 5];
  23 //!
  24 //! let v = vec![0; 10]; // ten zeroes
  25 //! ```
  26 //!
  27 //! You can [`push`] values onto the end of a vector (which will grow the vector
  28 //! as needed):
  29 //!
  30 //! ```
  31 //! let mut v = vec![1, 2];
  32 //!
  33 //! v.push(3);
  34 //! ```
  35 //!
  36 //! Popping values works in much the same way:
  37 //!
  38 //! ```
  39 //! let mut v = vec![1, 2];
  40 //!
  41 //! let two = v.pop();
  42 //! ```
  43 //!
  44 //! Vectors also support indexing (through the [`Index`] and [`IndexMut`] traits):
  45 //!
  46 //! ```
  47 //! let mut v = vec![1, 2, 3];
  48 //! let three = v[2];
  49 //! v[1] = v[1] + 5;
  50 //! ```
  51 //!
  52 //! [`push`]: Vec::push
  53
  54 #![stable(feature = "rust1", since = "1.0.0")]
  55
  56 use core::cmp::{self, Ordering};
  57 use core::convert::TryFrom;
  58 use core::fmt;
  59 use core::hash::{Hash, Hasher};
  60 use core::intrinsics::{arith_offset, assume};
  61 use core::iter::FromIterator;
  62 use core::marker::PhantomData;
  63 use core::mem::{self, ManuallyDrop, MaybeUninit};
  64 use core::ops::{self, Index, IndexMut, Range, RangeBounds};
  65 use core::ptr::{self, NonNull};
  66 use core::slice::{self, SliceIndex};
  67
  68 use crate::alloc::{Allocator, Global};
  69 use crate::borrow::{Cow, ToOwned};
  70 use crate::boxed::Box;
  71 use crate::collections::TryReserveError;
  72 use crate::raw_vec::RawVec;
  73
  74 #[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
  75 pub use self::drain_filter::DrainFilter;
  76
  77 mod drain_filter;
  78
  79 #[stable(feature = "vec_splice", since = "1.21.0")]
  80 pub use self::splice::Splice;
  81
  82 mod splice;
  83
  84 #[stable(feature = "drain", since = "1.6.0")]
  85 pub use self::drain::Drain;
  86
  87 mod drain;
  88
  89 mod cow;
  90
  91 pub(crate) use self::into_iter::AsIntoIter;
  92 #[stable(feature = "rust1", since = "1.0.0")]
  93 pub use self::into_iter::IntoIter;
  94
  95 mod into_iter;
  96
  97 use self::is_zero::IsZero;
  98
  99 mod is_zero;
 100
 101 mod source_iter_marker;
 102
 103 mod partial_eq;
 104
 105 use self::spec_from_elem::SpecFromElem;
 106
 107 mod spec_from_elem;
 108
 109 use self::set_len_on_drop::SetLenOnDrop;
 110
 111 mod set_len_on_drop;
 112
 113 use self::in_place_drop::InPlaceDrop;
 114
 115 mod in_place_drop;
 116
 117 use self::spec_from_iter_nested::SpecFromIterNested;
 118
 119 mod spec_from_iter_nested;
 120
 121 use self::spec_from_iter::SpecFromIter;
 122
 123 mod spec_from_iter;
 124
 125 use self::spec_extend::SpecExtend;
 126
 127 mod spec_extend;
 128
 129 /// A contiguous growable array type, written `Vec<T>` but pronounced 'vector'.
 130 ///
 131 /// # Examples
 132 ///
 133 /// ```
 134 /// let mut vec = Vec::new();
 135 /// vec.push(1);
 136 /// vec.push(2);
 137 ///
 138 /// assert_eq!(vec.len(), 2);
 139 /// assert_eq!(vec[0], 1);
 140 ///
 141 /// assert_eq!(vec.pop(), Some(2));
 142 /// assert_eq!(vec.len(), 1);
 143 ///
 144 /// vec[0] = 7;
 145 /// assert_eq!(vec[0], 7);
 146 ///
 147 /// vec.extend([1, 2, 3].iter().copied());
 148 ///
 149 /// for x in &vec {
 150 ///     println!("{}", x);
 151 /// }
 152 /// assert_eq!(vec, [7, 1, 2, 3]);
 153 /// ```
 154 ///
 155 /// The [`vec!`] macro is provided to make initialization more convenient:
 156 ///
 157 /// ```
 158 /// let mut vec = vec![1, 2, 3];
 159 /// vec.push(4);
 160 /// assert_eq!(vec, [1, 2, 3, 4]);
 161 /// ```
 162 ///
 163 /// It can also initialize each element of a `Vec<T>` with a given value.
 164 /// This may be more efficient than performing allocation and initialization
 165 /// in separate steps, especially when initializing a vector of zeros:
 166 ///
 167 /// ```
 168 /// let vec = vec![0; 5];
 169 /// assert_eq!(vec, [0, 0, 0, 0, 0]);
 170 ///
 171 /// // The following is equivalent, but potentially slower:
 172 /// let mut vec = Vec::with_capacity(5);
 173 /// vec.resize(5, 0);
 174 /// assert_eq!(vec, [0, 0, 0, 0, 0]);
 175 /// ```
 176 ///
 177 /// For more information, see
 178 /// [Capacity and Reallocation](#capacity-and-reallocation).
 179 ///
 180 /// Use a `Vec<T>` as an efficient stack:
 181 ///
 182 /// ```
 183 /// let mut stack = Vec::new();
 184 ///
 185 /// stack.push(1);
 186 /// stack.push(2);
 187 /// stack.push(3);
 188 ///
 189 /// while let Some(top) = stack.pop() {
 190 ///     // Prints 3, 2, 1
 191 ///     println!("{}", top);
 192 /// }
 193 /// ```
 194 ///
 195 /// # Indexing
 196 ///
 197 /// The `Vec` type allows to access values by index, because it implements the
 198 /// [`Index`] trait. An example will be more explicit:
 199 ///
 200 /// ```
 201 /// let v = vec![0, 2, 4, 6];
 202 /// println!("{}", v[1]); // it will display '2'
 203 /// ```
 204 ///
 205 /// However be careful: if you try to access an index which isn't in the `Vec`,
 206 /// your software will panic! You cannot do this:
 207 ///
 208 /// ```should_panic
 209 /// let v = vec![0, 2, 4, 6];
 210 /// println!("{}", v[6]); // it will panic!
 211 /// ```
 212 ///
 213 /// Use [`get`] and [`get_mut`] if you want to check whether the index is in
 214 /// the `Vec`.
 215 ///
 216 /// # Slicing
 217 ///
 218 /// A `Vec` can be mutable. Slices, on the other hand, are read-only objects.
 219 /// To get a [slice], use [`&`]. Example:
 220 ///
 221 /// ```
 222 /// fn read_slice(slice: &[usize]) {
 223 ///     // ...
 224 /// }
 225 ///
 226 /// let v = vec![0, 1];
 227 /// read_slice(&v);
 228 ///
 229 /// // ... and that's all!
 230 /// // you can also do it like this:
 231 /// let u: &[usize] = &v;
 232 /// // or like this:
 233 /// let u: &[_] = &v;
 234 /// ```
 235 ///
 236 /// In Rust, it's more common to pass slices as arguments rather than vectors
 237 /// when you just want to provide read access. The same goes for [`String`] and
 238 /// [`&str`].
 239 ///
 240 /// # Capacity and reallocation
 241 ///
 242 /// The capacity of a vector is the amount of space allocated for any future
 243 /// elements that will be added onto the vector. This is not to be confused with
 244 /// the *length* of a vector, which specifies the number of actual elements
 245 /// within the vector. If a vector's length exceeds its capacity, its capacity
 246 /// will automatically be increased, but its elements will have to be
 247 /// reallocated.
 248 ///
 249 /// For example, a vector with capacity 10 and length 0 would be an empty vector
 250 /// with space for 10 more elements. Pushing 10 or fewer elements onto the
 251 /// vector will not change its capacity or cause reallocation to occur. However,
 252 /// if the vector's length is increased to 11, it will have to reallocate, which
 253 /// can be slow. For this reason, it is recommended to use [`Vec::with_capacity`]
 254 /// whenever possible to specify how big the vector is expected to get.
 255 ///
 256 /// # Guarantees
 257 ///
 258 /// Due to its incredibly fundamental nature, `Vec` makes a lot of guarantees
 259 /// about its design. This ensures that it's as low-overhead as possible in
 260 /// the general case, and can be correctly manipulated in primitive ways
 261 /// by unsafe code. Note that these guarantees refer to an unqualified `Vec<T>`.
 262 /// If additional type parameters are added (e.g., to support custom allocators),
 263 /// overriding their defaults may change the behavior.
 264 ///
 265 /// Most fundamentally, `Vec` is and always will be a (pointer, capacity, length)
 266 /// triplet. No more, no less. The order of these fields is completely
 267 /// unspecified, and you should use the appropriate methods to modify these.
 268 /// The pointer will never be null, so this type is null-pointer-optimized.
 269 ///
 270 /// However, the pointer may not actually point to allocated memory. In particular,
 271 /// if you construct a `Vec` with capacity 0 via [`Vec::new`], [`vec![]`][`vec!`],
 272 /// [`Vec::with_capacity(0)`][`Vec::with_capacity`], or by calling [`shrink_to_fit`]
 273 /// on an empty Vec, it will not allocate memory. Similarly, if you store zero-sized
 274 /// types inside a `Vec`, it will not allocate space for them. *Note that in this case
 275 /// the `Vec` may not report a [`capacity`] of 0*. `Vec` will allocate if and only
 276 /// if [`mem::size_of::<T>`]`() * capacity() > 0`. In general, `Vec`'s allocation
 277 /// details are very subtle &mdash; if you intend to allocate memory using a `Vec`
 278 /// and use it for something else (either to pass to unsafe code, or to build your
 279 /// own memory-backed collection), be sure to deallocate this memory by using
 280 /// `from_raw_parts` to recover the `Vec` and then dropping it.
 281 ///
 282 /// If a `Vec` *has* allocated memory, then the memory it points to is on the heap
 283 /// (as defined by the allocator Rust is configured to use by default), and its
 284 /// pointer points to [`len`] initialized, contiguous elements in order (what
 285 /// you would see if you coerced it to a slice), followed by [`capacity`]` -
 286 /// `[`len`] logically uninitialized, contiguous elements.
 287 ///
 288 /// `Vec` will never perform a "small optimization" where elements are actually
 289 /// stored on the stack for two reasons:
 290 ///
 291 /// * It would make it more difficult for unsafe code to correctly manipulate
 292 ///   a `Vec`. The contents of a `Vec` wouldn't have a stable address if it were
 293 ///   only moved, and it would be more difficult to determine if a `Vec` had
 294 ///   actually allocated memory.
 295 ///
 296 /// * It would penalize the general case, incurring an additional branch
 297 ///   on every access.
 298 ///
 299 /// `Vec` will never automatically shrink itself, even if completely empty. This
 300 /// ensures no unnecessary allocations or deallocations occur. Emptying a `Vec`
 301 /// and then filling it back up to the same [`len`] should incur no calls to
 302 /// the allocator. If you wish to free up unused memory, use
 303 /// [`shrink_to_fit`].
 304 ///
 305 /// [`push`] and [`insert`] will never (re)allocate if the reported capacity is
 306 /// sufficient. [`push`] and [`insert`] *will* (re)allocate if
 307 /// [`len`]` == `[`capacity`]. That is, the reported capacity is completely
 308 /// accurate, and can be relied on. It can even be used to manually free the memory
 309 /// allocated by a `Vec` if desired. Bulk insertion methods *may* reallocate, even
 310 /// when not necessary.
 311 ///
 312 /// `Vec` does not guarantee any particular growth strategy when reallocating
 313 /// when full, nor when [`reserve`] is called. The current strategy is basic
 314 /// and it may prove desirable to use a non-constant growth factor. Whatever
 315 /// strategy is used will of course guarantee *O*(1) amortized [`push`].
 316 ///
 317 /// `vec![x; n]`, `vec![a, b, c, d]`, and
 318 /// [`Vec::with_capacity(n)`][`Vec::with_capacity`], will all produce a `Vec`
 319 /// with exactly the requested capacity. If [`len`]` == `[`capacity`],
 320 /// (as is the case for the [`vec!`] macro), then a `Vec<T>` can be converted to
 321 /// and from a [`Box<[T]>`][owned slice] without reallocating or moving the elements.
 322 ///
 323 /// `Vec` will not specifically overwrite any data that is removed from it,
 324 /// but also won't specifically preserve it. Its uninitialized memory is
 325 /// scratch space that it may use however it wants. It will generally just do
 326 /// whatever is most efficient or otherwise easy to implement. Do not rely on
 327 /// removed data to be erased for security purposes. Even if you drop a `Vec`, its
 328 /// buffer may simply be reused by another `Vec`. Even if you zero a `Vec`'s memory
 329 /// first, that may not actually happen because the optimizer does not consider
 330 /// this a side-effect that must be preserved. There is one case which we will
 331 /// not break, however: using `unsafe` code to write to the excess capacity,
 332 /// and then increasing the length to match, is always valid.
 333 ///
 334 /// `Vec` does not currently guarantee the order in which elements are dropped.
 335 /// The order has changed in the past and may change again.
 336 ///
 337 /// [`get`]: ../../std/vec/struct.Vec.html#method.get
 338 /// [`get_mut`]: ../../std/vec/struct.Vec.html#method.get_mut
 339 /// [`String`]: crate::string::String
 340 /// [`&str`]: type@str
 341 /// [`shrink_to_fit`]: Vec::shrink_to_fit
 342 /// [`capacity`]: Vec::capacity
 343 /// [`mem::size_of::<T>`]: core::mem::size_of
 344 /// [`len`]: Vec::len
 345 /// [`push`]: Vec::push
 346 /// [`insert`]: Vec::insert
 347 /// [`reserve`]: Vec::reserve
 348 /// [owned slice]: Box
 349 /// [slice]: ../../std/primitive.slice.html
 350 /// [`&`]: ../../std/primitive.reference.html
 351 #[stable(feature = "rust1", since = "1.0.0")]
 352 #[cfg_attr(not(test), rustc_diagnostic_item = "vec_type")]
 353 pub struct Vec<T, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global> {
 354     buf: RawVec<T, A>,
 355     len: usize,
 356 }
 357
 358 ////////////////////////////////////////////////////////////////////////////////
 359 // Inherent methods
 360 ////////////////////////////////////////////////////////////////////////////////
 361
 362 impl<T> Vec<T> {
 363     /// Constructs a new, empty `Vec<T>`.
 364     ///
 365     /// The vector will not allocate until elements are pushed onto it.
 366     ///
 367     /// # Examples
 368     ///
 369     /// ```
 370     /// # #![allow(unused_mut)]
 371     /// let mut vec: Vec<i32> = Vec::new();
 372     /// ```
 373     #[inline]
 374     #[rustc_const_stable(feature = "const_vec_new", since = "1.39.0")]
 375     #[stable(feature = "rust1", since = "1.0.0")]
 376     pub const fn new() -> Self {
 377         Vec { buf: RawVec::NEW, len: 0 }
 378     }
 379
 380     /// Constructs a new, empty `Vec<T>` with the specified capacity.
 381     ///
 382     /// The vector will be able to hold exactly `capacity` elements without
 383     /// reallocating. If `capacity` is 0, the vector will not allocate.
 384     ///
 385     /// It is important to note that although the returned vector has the
 386     /// *capacity* specified, the vector will have a zero *length*. For an
 387     /// explanation of the difference between length and capacity, see
 388     /// *[Capacity and reallocation]*.
 389     ///
 390     /// [Capacity and reallocation]: #capacity-and-reallocation
 391     ///
 392     /// # Examples
 393     ///
 394     /// ```
 395     /// let mut vec = Vec::with_capacity(10);
 396     ///
 397     /// // The vector contains no items, even though it has capacity for more
 398     /// assert_eq!(vec.len(), 0);
 399     /// assert_eq!(vec.capacity(), 10);
 400     ///
 401     /// // These are all done without reallocating...
 402     /// for i in 0..10 {
 403     ///     vec.push(i);
 404     /// }
 405     /// assert_eq!(vec.len(), 10);
 406     /// assert_eq!(vec.capacity(), 10);
 407     ///
 408     /// // ...but this may make the vector reallocate
 409     /// vec.push(11);
 410     /// assert_eq!(vec.len(), 11);
 411     /// assert!(vec.capacity() >= 11);
 412     /// ```
 413     #[inline]
 414     #[stable(feature = "rust1", since = "1.0.0")]
 415     pub fn with_capacity(capacity: usize) -> Self {
 416         Self::with_capacity_in(capacity, Global)
 417     }
 418
 419     /// Creates a `Vec<T>` directly from the raw components of another vector.
 420     ///
 421     /// # Safety
 422     ///
 423     /// This is highly unsafe, due to the number of invariants that aren't
 424     /// checked:
 425     ///
 426     /// * `ptr` needs to have been previously allocated via [`String`]/`Vec<T>`
 427     ///   (at least, it's highly likely to be incorrect if it wasn't).
 428     /// * `T` needs to have the same size and alignment as what `ptr` was allocated with.
 429     ///   (`T` having a less strict alignment is not sufficient, the alignment really
 430     ///   needs to be equal to satisfy the [`dealloc`] requirement that memory must be
 431     ///   allocated and deallocated with the same layout.)
 432     /// * `length` needs to be less than or equal to `capacity`.
 433     /// * `capacity` needs to be the capacity that the pointer was allocated with.
 434     ///
 435     /// Violating these may cause problems like corrupting the allocator's
 436     /// internal data structures. For example it is **not** safe
 437     /// to build a `Vec<u8>` from a pointer to a C `char` array with length `size_t`.
 438     /// It's also not safe to build one from a `Vec<u16>` and its length, because
 439     /// the allocator cares about the alignment, and these two types have different
 440     /// alignments. The buffer was allocated with alignment 2 (for `u16`), but after
 441     /// turning it into a `Vec<u8>` it'll be deallocated with alignment 1.
 442     ///
 443     /// The ownership of `ptr` is effectively transferred to the
 444     /// `Vec<T>` which may then deallocate, reallocate or change the
 445     /// contents of memory pointed to by the pointer at will. Ensure
 446     /// that nothing else uses the pointer after calling this
 447     /// function.
 448     ///
 449     /// [`String`]: crate::string::String
 450     /// [`dealloc`]: crate::alloc::GlobalAlloc::dealloc
 451     ///
 452     /// # Examples
 453     ///
 454     /// ```
 455     /// use std::ptr;
 456     /// use std::mem;
 457     ///
 458     /// let v = vec![1, 2, 3];
 459     ///
 460     // FIXME Update this when vec_into_raw_parts is stabilized
 461     /// // Prevent running `v`'s destructor so we are in complete control
 462     /// // of the allocation.
 463     /// let mut v = mem::ManuallyDrop::new(v);
 464     ///
 465     /// // Pull out the various important pieces of information about `v`
 466     /// let p = v.as_mut_ptr();
 467     /// let len = v.len();
 468     /// let cap = v.capacity();
 469     ///
 470     /// unsafe {
 471     ///     // Overwrite memory with 4, 5, 6
 472     ///     for i in 0..len as isize {
 473     ///         ptr::write(p.offset(i), 4 + i);
 474     ///     }
 475     ///
 476     ///     // Put everything back together into a Vec
 477     ///     let rebuilt = Vec::from_raw_parts(p, len, cap);
 478     ///     assert_eq!(rebuilt, [4, 5, 6]);
 479     /// }
 480     /// ```
 481     #[inline]
 482     #[stable(feature = "rust1", since = "1.0.0")]
 483     pub unsafe fn from_raw_parts(ptr: *mut T, length: usize, capacity: usize) -> Self {
 484         unsafe { Self::from_raw_parts_in(ptr, length, capacity, Global) }
 485     }
 486 }
 487
 488 impl<T, A: Allocator> Vec<T, A> {
 489     /// Constructs a new, empty `Vec<T, A>`.
 490     ///
 491     /// The vector will not allocate until elements are pushed onto it.
 492     ///
 493     /// # Examples
 494     ///
 495     /// ```
 496     /// #![feature(allocator_api)]
 497     ///
 498     /// use std::alloc::System;
 499     ///
 500     /// # #[allow(unused_mut)]
 501     /// let mut vec: Vec<i32, _> = Vec::new_in(System);
 502     /// ```
 503     #[inline]
 504     #[unstable(feature = "allocator_api", issue = "32838")]
 505     pub const fn new_in(alloc: A) -> Self {
 506         Vec { buf: RawVec::new_in(alloc), len: 0 }
 507     }
 508
 509     /// Constructs a new, empty `Vec<T, A>` with the specified capacity with the provided
 510     /// allocator.
 511     ///
 512     /// The vector will be able to hold exactly `capacity` elements without
 513     /// reallocating. If `capacity` is 0, the vector will not allocate.
 514     ///
 515     /// It is important to note that although the returned vector has the
 516     /// *capacity* specified, the vector will have a zero *length*. For an
 517     /// explanation of the difference between length and capacity, see
 518     /// *[Capacity and reallocation]*.
 519     ///
 520     /// [Capacity and reallocation]: #capacity-and-reallocation
 521     ///
 522     /// # Examples
 523     ///
 524     /// ```
 525     /// #![feature(allocator_api)]
 526     ///
 527     /// use std::alloc::System;
 528     ///
 529     /// let mut vec = Vec::with_capacity_in(10, System);
 530     ///
 531     /// // The vector contains no items, even though it has capacity for more
 532     /// assert_eq!(vec.len(), 0);
 533     /// assert_eq!(vec.capacity(), 10);
 534     ///
 535     /// // These are all done without reallocating...
 536     /// for i in 0..10 {
 537     ///     vec.push(i);
 538     /// }
 539     /// assert_eq!(vec.len(), 10);
 540     /// assert_eq!(vec.capacity(), 10);
 541     ///
 542     /// // ...but this may make the vector reallocate
 543     /// vec.push(11);
 544     /// assert_eq!(vec.len(), 11);
 545     /// assert!(vec.capacity() >= 11);
 546     /// ```
 547     #[inline]
 548     #[unstable(feature = "allocator_api", issue = "32838")]
 549     pub fn with_capacity_in(capacity: usize, alloc: A) -> Self {
 550         Vec { buf: RawVec::with_capacity_in(capacity, alloc), len: 0 }
 551     }
 552
 553     /// Creates a `Vec<T, A>` directly from the raw components of another vector.
 554     ///
 555     /// # Safety
 556     ///
 557     /// This is highly unsafe, due to the number of invariants that aren't
 558     /// checked:
 559     ///
 560     /// * `ptr` needs to have been previously allocated via [`String`]/`Vec<T>`
 561     ///   (at least, it's highly likely to be incorrect if it wasn't).
 562     /// * `T` needs to have the same size and alignment as what `ptr` was allocated with.
 563     ///   (`T` having a less strict alignment is not sufficient, the alignment really
 564     ///   needs to be equal to satisfy the [`dealloc`] requirement that memory must be
 565     ///   allocated and deallocated with the same layout.)
 566     /// * `length` needs to be less than or equal to `capacity`.
 567     /// * `capacity` needs to be the capacity that the pointer was allocated with.
 568     ///
 569     /// Violating these may cause problems like corrupting the allocator's
 570     /// internal data structures. For example it is **not** safe
 571     /// to build a `Vec<u8>` from a pointer to a C `char` array with length `size_t`.
 572     /// It's also not safe to build one from a `Vec<u16>` and its length, because
 573     /// the allocator cares about the alignment, and these two types have different
 574     /// alignments. The buffer was allocated with alignment 2 (for `u16`), but after
 575     /// turning it into a `Vec<u8>` it'll be deallocated with alignment 1.
 576     ///
 577     /// The ownership of `ptr` is effectively transferred to the
 578     /// `Vec<T>` which may then deallocate, reallocate or change the
 579     /// contents of memory pointed to by the pointer at will. Ensure
 580     /// that nothing else uses the pointer after calling this
 581     /// function.
 582     ///
 583     /// [`String`]: crate::string::String
 584     /// [`dealloc`]: crate::alloc::GlobalAlloc::dealloc
 585     ///
 586     /// # Examples
 587     ///
 588     /// ```
 589     /// #![feature(allocator_api)]
 590     ///
 591     /// use std::alloc::System;
 592     ///
 593     /// use std::ptr;
 594     /// use std::mem;
 595     ///
 596     /// let mut v = Vec::with_capacity_in(3, System);
 597     /// v.push(1);
 598     /// v.push(2);
 599     /// v.push(3);
 600     ///
 601     // FIXME Update this when vec_into_raw_parts is stabilized
 602     /// // Prevent running `v`'s destructor so we are in complete control
 603     /// // of the allocation.
 604     /// let mut v = mem::ManuallyDrop::new(v);
 605     ///
 606     /// // Pull out the various important pieces of information about `v`
 607     /// let p = v.as_mut_ptr();
 608     /// let len = v.len();
 609     /// let cap = v.capacity();
 610     /// let alloc = v.allocator();
 611     ///
 612     /// unsafe {
 613     ///     // Overwrite memory with 4, 5, 6
 614     ///     for i in 0..len as isize {
 615     ///         ptr::write(p.offset(i), 4 + i);
 616     ///     }
 617     ///
 618     ///     // Put everything back together into a Vec
 619     ///     let rebuilt = Vec::from_raw_parts_in(p, len, cap, alloc.clone());
 620     ///     assert_eq!(rebuilt, [4, 5, 6]);
 621     /// }
 622     /// ```
 623     #[inline]
 624     #[unstable(feature = "allocator_api", issue = "32838")]
 625     pub unsafe fn from_raw_parts_in(ptr: *mut T, length: usize, capacity: usize, alloc: A) -> Self {
 626         unsafe { Vec { buf: RawVec::from_raw_parts_in(ptr, capacity, alloc), len: length } }
 627     }
 628
 629     /// Decomposes a `Vec<T>` into its raw components.
 630     ///
 631     /// Returns the raw pointer to the underlying data, the length of
 632     /// the vector (in elements), and the allocated capacity of the
 633     /// data (in elements). These are the same arguments in the same
 634     /// order as the arguments to [`from_raw_parts`].
 635     ///
 636     /// After calling this function, the caller is responsible for the
 637     /// memory previously managed by the `Vec`. The only way to do
 638     /// this is to convert the raw pointer, length, and capacity back
 639     /// into a `Vec` with the [`from_raw_parts`] function, allowing
 640     /// the destructor to perform the cleanup.
 641     ///
 642     /// [`from_raw_parts`]: Vec::from_raw_parts
 643     ///
 644     /// # Examples
 645     ///
 646     /// ```
 647     /// #![feature(vec_into_raw_parts)]
 648     /// let v: Vec<i32> = vec![-1, 0, 1];
 649     ///
 650     /// let (ptr, len, cap) = v.into_raw_parts();
 651     ///
 652     /// let rebuilt = unsafe {
 653     ///     // We can now make changes to the components, such as
 654     ///     // transmuting the raw pointer to a compatible type.
 655     ///     let ptr = ptr as *mut u32;
 656     ///
 657     ///     Vec::from_raw_parts(ptr, len, cap)
 658     /// };
 659     /// assert_eq!(rebuilt, [4294967295, 0, 1]);
 660     /// ```
 661     #[unstable(feature = "vec_into_raw_parts", reason = "new API", issue = "65816")]
 662     pub fn into_raw_parts(self) -> (*mut T, usize, usize) {
 663         let mut me = ManuallyDrop::new(self);
 664         (me.as_mut_ptr(), me.len(), me.capacity())
 665     }
 666
 667     /// Decomposes a `Vec<T>` into its raw components.
 668     ///
 669     /// Returns the raw pointer to the underlying data, the length of the vector (in elements),
 670     /// the allocated capacity of the data (in elements), and the allocator. These are the same
 671     /// arguments in the same order as the arguments to [`from_raw_parts_in`].
 672     ///
 673     /// After calling this function, the caller is responsible for the
 674     /// memory previously managed by the `Vec`. The only way to do
 675     /// this is to convert the raw pointer, length, and capacity back
 676     /// into a `Vec` with the [`from_raw_parts_in`] function, allowing
 677     /// the destructor to perform the cleanup.
 678     ///
 679     /// [`from_raw_parts_in`]: Vec::from_raw_parts_in
 680     ///
 681     /// # Examples
 682     ///
 683     /// ```
 684     /// #![feature(allocator_api, vec_into_raw_parts)]
 685     ///
 686     /// use std::alloc::System;
 687     ///
 688     /// let mut v: Vec<i32, System> = Vec::new_in(System);
 689     /// v.push(-1);
 690     /// v.push(0);
 691     /// v.push(1);
 692     ///
 693     /// let (ptr, len, cap, alloc) = v.into_raw_parts_with_alloc();
 694     ///
 695     /// let rebuilt = unsafe {
 696     ///     // We can now make changes to the components, such as
 697     ///     // transmuting the raw pointer to a compatible type.
 698     ///     let ptr = ptr as *mut u32;
 699     ///
 700     ///     Vec::from_raw_parts_in(ptr, len, cap, alloc)
 701     /// };
 702     /// assert_eq!(rebuilt, [4294967295, 0, 1]);
 703     /// ```
 704     #[unstable(feature = "allocator_api", issue = "32838")]
 705     // #[unstable(feature = "vec_into_raw_parts", reason = "new API", issue = "65816")]
 706     pub fn into_raw_parts_with_alloc(self) -> (*mut T, usize, usize, A) {
 707         let mut me = ManuallyDrop::new(self);
 708         let len = me.len();
 709         let capacity = me.capacity();
 710         let ptr = me.as_mut_ptr();
 711         let alloc = unsafe { ptr::read(me.allocator()) };
 712         (ptr, len, capacity, alloc)
 713     }
 714
 715     /// Returns the number of elements the vector can hold without
 716     /// reallocating.
 717     ///
 718     /// # Examples
 719     ///
 720     /// ```
 721     /// let vec: Vec<i32> = Vec::with_capacity(10);
 722     /// assert_eq!(vec.capacity(), 10);
 723     /// ```
 724     #[inline]
 725     #[stable(feature = "rust1", since = "1.0.0")]
 726     pub fn capacity(&self) -> usize {
 727         self.buf.capacity()
 728     }
 729
 730     /// Reserves capacity for at least `additional` more elements to be inserted
 731     /// in the given `Vec<T>`. The collection may reserve more space to avoid
 732     /// frequent reallocations. After calling `reserve`, capacity will be
 733     /// greater than or equal to `self.len() + additional`. Does nothing if
 734     /// capacity is already sufficient.
 735     ///
 736     /// # Panics
 737     ///
 738     /// Panics if the new capacity exceeds `isize::MAX` bytes.
 739     ///
 740     /// # Examples
 741     ///
 742     /// ```
 743     /// let mut vec = vec![1];
 744     /// vec.reserve(10);
 745     /// assert!(vec.capacity() >= 11);
 746     /// ```
 747     #[stable(feature = "rust1", since = "1.0.0")]
 748     pub fn reserve(&mut self, additional: usize) {
 749         self.buf.reserve(self.len, additional);
 750     }
 751
 752     /// Reserves the minimum capacity for exactly `additional` more elements to
 753     /// be inserted in the given `Vec<T>`. After calling `reserve_exact`,
 754     /// capacity will be greater than or equal to `self.len() + additional`.
 755     /// Does nothing if the capacity is already sufficient.
 756     ///
 757     /// Note that the allocator may give the collection more space than it
 758     /// requests. Therefore, capacity can not be relied upon to be precisely
 759     /// minimal. Prefer `reserve` if future insertions are expected.
 760     ///
 761     /// # Panics
 762     ///
 763     /// Panics if the new capacity overflows `usize`.
 764     ///
 765     /// # Examples
 766     ///
 767     /// ```
 768     /// let mut vec = vec![1];
 769     /// vec.reserve_exact(10);
 770     /// assert!(vec.capacity() >= 11);
 771     /// ```
 772     #[stable(feature = "rust1", since = "1.0.0")]
 773     pub fn reserve_exact(&mut self, additional: usize) {
 774         self.buf.reserve_exact(self.len, additional);
 775     }
 776
 777     /// Tries to reserve capacity for at least `additional` more elements to be inserted
 778     /// in the given `Vec<T>`. The collection may reserve more space to avoid
 779     /// frequent reallocations. After calling `try_reserve`, capacity will be
 780     /// greater than or equal to `self.len() + additional`. Does nothing if
 781     /// capacity is already sufficient.
 782     ///
 783     /// # Errors
 784     ///
 785     /// If the capacity overflows, or the allocator reports a failure, then an error
 786     /// is returned.
 787     ///
 788     /// # Examples
 789     ///
 790     /// ```
 791     /// #![feature(try_reserve)]
 792     /// use std::collections::TryReserveError;
 793     ///
 794     /// fn process_data(data: &[u32]) -> Result<Vec<u32>, TryReserveError> {
 795     ///     let mut output = Vec::new();
 796     ///
 797     ///     // Pre-reserve the memory, exiting if we can't
 798     ///     output.try_reserve(data.len())?;
 799     ///
 800     ///     // Now we know this can't OOM in the middle of our complex work
 801     ///     output.extend(data.iter().map(|&val| {
 802     ///         val * 2 + 5 // very complicated
 803     ///     }));
 804     ///
 805     ///     Ok(output)
 806     /// }
 807     /// # process_data(&[1, 2, 3]).expect("why is the test harness OOMing on 12 bytes?");
 808     /// ```
 809     #[unstable(feature = "try_reserve", reason = "new API", issue = "48043")]
 810     pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError> {
 811         self.buf.try_reserve(self.len, additional)
 812     }
 813
 814     /// Tries to reserve the minimum capacity for exactly `additional`
 815     /// elements to be inserted in the given `Vec<T>`. After calling
 816     /// `try_reserve_exact`, capacity will be greater than or equal to
 817     /// `self.len() + additional` if it returns `Ok(())`.
 818     /// Does nothing if the capacity is already sufficient.
 819     ///
 820     /// Note that the allocator may give the collection more space than it
 821     /// requests. Therefore, capacity can not be relied upon to be precisely
 822     /// minimal. Prefer `reserve` if future insertions are expected.
 823     ///
 824     /// # Errors
 825     ///
 826     /// If the capacity overflows, or the allocator reports a failure, then an error
 827     /// is returned.
 828     ///
 829     /// # Examples
 830     ///
 831     /// ```
 832     /// #![feature(try_reserve)]
 833     /// use std::collections::TryReserveError;
 834     ///
 835     /// fn process_data(data: &[u32]) -> Result<Vec<u32>, TryReserveError> {
 836     ///     let mut output = Vec::new();
 837     ///
 838     ///     // Pre-reserve the memory, exiting if we can't
 839     ///     output.try_reserve_exact(data.len())?;
 840     ///
 841     ///     // Now we know this can't OOM in the middle of our complex work
 842     ///     output.extend(data.iter().map(|&val| {
 843     ///         val * 2 + 5 // very complicated
 844     ///     }));
 845     ///
 846     ///     Ok(output)
 847     /// }
 848     /// # process_data(&[1, 2, 3]).expect("why is the test harness OOMing on 12 bytes?");
 849     /// ```
 850     #[unstable(feature = "try_reserve", reason = "new API", issue = "48043")]
 851     pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), TryReserveError> {
 852         self.buf.try_reserve_exact(self.len, additional)
 853     }
 854
 855     /// Shrinks the capacity of the vector as much as possible.
 856     ///
 857     /// It will drop down as close as possible to the length but the allocator
 858     /// may still inform the vector that there is space for a few more elements.
 859     ///
 860     /// # Examples
 861     ///
 862     /// ```
 863     /// let mut vec = Vec::with_capacity(10);
 864     /// vec.extend([1, 2, 3].iter().cloned());
 865     /// assert_eq!(vec.capacity(), 10);
 866     /// vec.shrink_to_fit();
 867     /// assert!(vec.capacity() >= 3);
 868     /// ```
 869     #[stable(feature = "rust1", since = "1.0.0")]
 870     pub fn shrink_to_fit(&mut self) {
 871         // The capacity is never less than the length, and there's nothing to do when
 872         // they are equal, so we can avoid the panic case in `RawVec::shrink_to_fit`
 873         // by only calling it with a greater capacity.
 874         if self.capacity() > self.len {
 875             self.buf.shrink_to_fit(self.len);
 876         }
 877     }
 878
 879     /// Shrinks the capacity of the vector with a lower bound.
 880     ///
 881     /// The capacity will remain at least as large as both the length
 882     /// and the supplied value.
 883     ///
 884     /// # Panics
 885     ///
 886     /// Panics if the current capacity is smaller than the supplied
 887     /// minimum capacity.
 888     ///
 889     /// # Examples
 890     ///
 891     /// ```
 892     /// #![feature(shrink_to)]
 893     /// let mut vec = Vec::with_capacity(10);
 894     /// vec.extend([1, 2, 3].iter().cloned());
 895     /// assert_eq!(vec.capacity(), 10);
 896     /// vec.shrink_to(4);
 897     /// assert!(vec.capacity() >= 4);
 898     /// vec.shrink_to(0);
 899     /// assert!(vec.capacity() >= 3);
 900     /// ```
 901     #[unstable(feature = "shrink_to", reason = "new API", issue = "56431")]
 902     pub fn shrink_to(&mut self, min_capacity: usize) {
 903         self.buf.shrink_to_fit(cmp::max(self.len, min_capacity));
 904     }
 905
 906     /// Converts the vector into [`Box<[T]>`][owned slice].
 907     ///
 908     /// Note that this will drop any excess capacity.
 909     ///
 910     /// [owned slice]: Box
 911     ///
 912     /// # Examples
 913     ///
 914     /// ```
 915     /// let v = vec![1, 2, 3];
 916     ///
 917     /// let slice = v.into_boxed_slice();
 918     /// ```
 919     ///
 920     /// Any excess capacity is removed:
 921     ///
 922     /// ```
 923     /// let mut vec = Vec::with_capacity(10);
 924     /// vec.extend([1, 2, 3].iter().cloned());
 925     ///
 926     /// assert_eq!(vec.capacity(), 10);
 927     /// let slice = vec.into_boxed_slice();
 928     /// assert_eq!(slice.into_vec().capacity(), 3);
 929     /// ```
 930     #[stable(feature = "rust1", since = "1.0.0")]
 931     pub fn into_boxed_slice(mut self) -> Box<[T], A> {
 932         unsafe {
 933             self.shrink_to_fit();
 934             let me = ManuallyDrop::new(self);
 935             let buf = ptr::read(&me.buf);
 936             let len = me.len();
 937             buf.into_box(len).assume_init()
 938         }
 939     }
 940
 941     /// Shortens the vector, keeping the first `len` elements and dropping
 942     /// the rest.
 943     ///
 944     /// If `len` is greater than the vector's current length, this has no
 945     /// effect.
 946     ///
 947     /// The [`drain`] method can emulate `truncate`, but causes the excess
 948     /// elements to be returned instead of dropped.
 949     ///
 950     /// Note that this method has no effect on the allocated capacity
 951     /// of the vector.
 952     ///
 953     /// # Examples
 954     ///
 955     /// Truncating a five element vector to two elements:
 956     ///
 957     /// ```
 958     /// let mut vec = vec![1, 2, 3, 4, 5];
 959     /// vec.truncate(2);
 960     /// assert_eq!(vec, [1, 2]);
 961     /// ```
 962     ///
 963     /// No truncation occurs when `len` is greater than the vector's current
 964     /// length:
 965     ///
 966     /// ```
 967     /// let mut vec = vec![1, 2, 3];
 968     /// vec.truncate(8);
 969     /// assert_eq!(vec, [1, 2, 3]);
 970     /// ```
 971     ///
 972     /// Truncating when `len == 0` is equivalent to calling the [`clear`]
 973     /// method.
 974     ///
 975     /// ```
 976     /// let mut vec = vec![1, 2, 3];
 977     /// vec.truncate(0);
 978     /// assert_eq!(vec, []);
 979     /// ```
 980     ///
 981     /// [`clear`]: Vec::clear
 982     /// [`drain`]: Vec::drain
 983     #[stable(feature = "rust1", since = "1.0.0")]
 984     pub fn truncate(&mut self, len: usize) {
 985         // This is safe because:
 986         //
 987         // * the slice passed to `drop_in_place` is valid; the `len > self.len`
 988         //   case avoids creating an invalid slice, and
 989         // * the `len` of the vector is shrunk before calling `drop_in_place`,
 990         //   such that no value will be dropped twice in case `drop_in_place`
 991         //   were to panic once (if it panics twice, the program aborts).
 992         unsafe {
 993             // Note: It's intentional that this is `>` and not `>=`.
 994             //       Changing it to `>=` has negative performance
 995             //       implications in some cases. See #78884 for more.
 996             if len > self.len {
 997                 return;
 998             }
 999             let remaining_len = self.len - len;
1000             let s = ptr::slice_from_raw_parts_mut(self.as_mut_ptr().add(len), remaining_len);
1001             self.len = len;
1002             ptr::drop_in_place(s);
1003         }
1004     }
1005
1006     /// Extracts a slice containing the entire vector.
1007     ///
1008     /// Equivalent to `&s[..]`.
1009     ///
1010     /// # Examples
1011     ///
1012     /// ```
1013     /// use std::io::{self, Write};
1014     /// let buffer = vec![1, 2, 3, 5, 8];
1015     /// io::sink().write(buffer.as_slice()).unwrap();
1016     /// ```
1017     #[inline]
1018     #[stable(feature = "vec_as_slice", since = "1.7.0")]
1019     pub fn as_slice(&self) -> &[T] {
1020         self
1021     }
1022
1023     /// Extracts a mutable slice of the entire vector.
1024     ///
1025     /// Equivalent to `&mut s[..]`.
1026     ///
1027     /// # Examples
1028     ///
1029     /// ```
1030     /// use std::io::{self, Read};
1031     /// let mut buffer = vec![0; 3];
1032     /// io::repeat(0b101).read_exact(buffer.as_mut_slice()).unwrap();
1033     /// ```
1034     #[inline]
1035     #[stable(feature = "vec_as_slice", since = "1.7.0")]
1036     pub fn as_mut_slice(&mut self) -> &mut [T] {
1037         self
1038     }
1039
1040     /// Returns a raw pointer to the vector's buffer.
1041     ///
1042     /// The caller must ensure that the vector outlives the pointer this
1043     /// function returns, or else it will end up pointing to garbage.
1044     /// Modifying the vector may cause its buffer to be reallocated,
1045     /// which would also make any pointers to it invalid.
1046     ///
1047     /// The caller must also ensure that the memory the pointer (non-transitively) points to
1048     /// is never written to (except inside an `UnsafeCell`) using this pointer or any pointer
1049     /// derived from it. If you need to mutate the contents of the slice, use [`as_mut_ptr`].
1050     ///
1051     /// # Examples
1052     ///
1053     /// ```
1054     /// let x = vec![1, 2, 4];
1055     /// let x_ptr = x.as_ptr();
1056     ///
1057     /// unsafe {
1058     ///     for i in 0..x.len() {
1059     ///         assert_eq!(*x_ptr.add(i), 1 << i);
1060     ///     }
1061     /// }
1062     /// ```
1063     ///
1064     /// [`as_mut_ptr`]: Vec::as_mut_ptr
1065     #[stable(feature = "vec_as_ptr", since = "1.37.0")]
1066     #[inline]
1067     pub fn as_ptr(&self) -> *const T {
1068         // We shadow the slice method of the same name to avoid going through
1069         // `deref`, which creates an intermediate reference.
1070         let ptr = self.buf.ptr();
1071         unsafe {
1072             assume(!ptr.is_null());
1073         }
1074         ptr
1075     }
1076
1077     /// Returns an unsafe mutable pointer to the vector's buffer.
1078     ///
1079     /// The caller must ensure that the vector outlives the pointer this
1080     /// function returns, or else it will end up pointing to garbage.
1081     /// Modifying the vector may cause its buffer to be reallocated,
1082     /// which would also make any pointers to it invalid.
1083     ///
1084     /// # Examples
1085     ///
1086     /// ```
1087     /// // Allocate vector big enough for 4 elements.
1088     /// let size = 4;
1089     /// let mut x: Vec<i32> = Vec::with_capacity(size);
1090     /// let x_ptr = x.as_mut_ptr();
1091     ///
1092     /// // Initialize elements via raw pointer writes, then set length.
1093     /// unsafe {
1094     ///     for i in 0..size {
1095     ///         *x_ptr.add(i) = i as i32;
1096     ///     }
1097     ///     x.set_len(size);
1098     /// }
1099     /// assert_eq!(&*x, &[0, 1, 2, 3]);
1100     /// ```
1101     #[stable(feature = "vec_as_ptr", since = "1.37.0")]
1102     #[inline]
1103     pub fn as_mut_ptr(&mut self) -> *mut T {
1104         // We shadow the slice method of the same name to avoid going through
1105         // `deref_mut`, which creates an intermediate reference.
1106         let ptr = self.buf.ptr();
1107         unsafe {
1108             assume(!ptr.is_null());
1109         }
1110         ptr
1111     }
1112
1113     /// Returns a reference to the underlying allocator.
1114     #[unstable(feature = "allocator_api", issue = "32838")]
1115     #[inline]
1116     pub fn allocator(&self) -> &A {
1117         self.buf.allocator()
1118     }
1119
1120     /// Forces the length of the vector to `new_len`.
1121     ///
1122     /// This is a low-level operation that maintains none of the normal
1123     /// invariants of the type. Normally changing the length of a vector
1124     /// is done using one of the safe operations instead, such as
1125     /// [`truncate`], [`resize`], [`extend`], or [`clear`].
1126     ///
1127     /// [`truncate`]: Vec::truncate
1128     /// [`resize`]: Vec::resize
1129     /// [`extend`]: Extend::extend
1130     /// [`clear`]: Vec::clear
1131     ///
1132     /// # Safety
1133     ///
1134     /// - `new_len` must be less than or equal to [`capacity()`].
1135     /// - The elements at `old_len..new_len` must be initialized.
1136     ///
1137     /// [`capacity()`]: Vec::capacity
1138     ///
1139     /// # Examples
1140     ///
1141     /// This method can be useful for situations in which the vector
1142     /// is serving as a buffer for other code, particularly over FFI:
1143     ///
1144     /// ```no_run
1145     /// # #![allow(dead_code)]
1146     /// # // This is just a minimal skeleton for the doc example;
1147     /// # // don't use this as a starting point for a real library.
1148     /// # pub struct StreamWrapper { strm: *mut std::ffi::c_void }
1149     /// # const Z_OK: i32 = 0;
1150     /// # extern "C" {
1151     /// #     fn deflateGetDictionary(
1152     /// #         strm: *mut std::ffi::c_void,
1153     /// #         dictionary: *mut u8,
1154     /// #         dictLength: *mut usize,
1155     /// #     ) -> i32;
1156     /// # }
1157     /// # impl StreamWrapper {
1158     /// pub fn get_dictionary(&self) -> Option<Vec<u8>> {
1159     ///     // Per the FFI method's docs, "32768 bytes is always enough".
1160     ///     let mut dict = Vec::with_capacity(32_768);
1161     ///     let mut dict_length = 0;
1162     ///     // SAFETY: When `deflateGetDictionary` returns `Z_OK`, it holds that:
1163     ///     // 1. `dict_length` elements were initialized.
1164     ///     // 2. `dict_length` <= the capacity (32_768)
1165     ///     // which makes `set_len` safe to call.
1166     ///     unsafe {
1167     ///         // Make the FFI call...
1168     ///         let r = deflateGetDictionary(self.strm, dict.as_mut_ptr(), &mut dict_length);
1169     ///         if r == Z_OK {
1170     ///             // ...and update the length to what was initialized.
1171     ///             dict.set_len(dict_length);
1172     ///             Some(dict)
1173     ///         } else {
1174     ///             None
1175     ///         }
1176     ///     }
1177     /// }
1178     /// # }
1179     /// ```
1180     ///
1181     /// While the following example is sound, there is a memory leak since
1182     /// the inner vectors were not freed prior to the `set_len` call:
1183     ///
1184     /// ```
1185     /// let mut vec = vec![vec![1, 0, 0],
1186     ///                    vec![0, 1, 0],
1187     ///                    vec![0, 0, 1]];
1188     /// // SAFETY:
1189     /// // 1. `old_len..0` is empty so no elements need to be initialized.
1190     /// // 2. `0 <= capacity` always holds whatever `capacity` is.
1191     /// unsafe {
1192     ///     vec.set_len(0);
1193     /// }
1194     /// ```
1195     ///
1196     /// Normally, here, one would use [`clear`] instead to correctly drop
1197     /// the contents and thus not leak memory.
1198     #[inline]
1199     #[stable(feature = "rust1", since = "1.0.0")]
1200     pub unsafe fn set_len(&mut self, new_len: usize) {
1201         debug_assert!(new_len <= self.capacity());
1202
1203         self.len = new_len;
1204     }
1205
1206     /// Removes an element from the vector and returns it.
1207     ///
1208     /// The removed element is replaced by the last element of the vector.
1209     ///
1210     /// This does not preserve ordering, but is O(1).
1211     ///
1212     /// # Panics
1213     ///
1214     /// Panics if `index` is out of bounds.
1215     ///
1216     /// # Examples
1217     ///
1218     /// ```
1219     /// let mut v = vec!["foo", "bar", "baz", "qux"];
1220     ///
1221     /// assert_eq!(v.swap_remove(1), "bar");
1222     /// assert_eq!(v, ["foo", "qux", "baz"]);
1223     ///
1224     /// assert_eq!(v.swap_remove(0), "foo");
1225     /// assert_eq!(v, ["baz", "qux"]);
1226     /// ```
1227     #[inline]
1228     #[stable(feature = "rust1", since = "1.0.0")]
1229     pub fn swap_remove(&mut self, index: usize) -> T {
1230         #[cold]
1231         #[inline(never)]
1232         fn assert_failed(index: usize, len: usize) -> ! {
1233             panic!("swap_remove index (is {}) should be < len (is {})", index, len);
1234         }
1235
1236         let len = self.len();
1237         if index >= len {
1238             assert_failed(index, len);
1239         }
1240         unsafe {
1241             // We replace self[index] with the last element. Note that if the
1242             // bounds check above succeeds there must be a last element (which
1243             // can be self[index] itself).
1244             let last = ptr::read(self.as_ptr().add(len - 1));
1245             let hole = self.as_mut_ptr().add(index);
1246             self.set_len(len - 1);
1247             ptr::replace(hole, last)
1248         }
1249     }
1250
1251     /// Inserts an element at position `index` within the vector, shifting all
1252     /// elements after it to the right.
1253     ///
1254     /// # Panics
1255     ///
1256     /// Panics if `index > len`.
1257     ///
1258     /// # Examples
1259     ///
1260     /// ```
1261     /// let mut vec = vec![1, 2, 3];
1262     /// vec.insert(1, 4);
1263     /// assert_eq!(vec, [1, 4, 2, 3]);
1264     /// vec.insert(4, 5);
1265     /// assert_eq!(vec, [1, 4, 2, 3, 5]);
1266     /// ```
1267     #[stable(feature = "rust1", since = "1.0.0")]
1268     pub fn insert(&mut self, index: usize, element: T) {
1269         #[cold]
1270         #[inline(never)]
1271         fn assert_failed(index: usize, len: usize) -> ! {
1272             panic!("insertion index (is {}) should be <= len (is {})", index, len);
1273         }
1274
1275         let len = self.len();
1276         if index > len {
1277             assert_failed(index, len);
1278         }
1279
1280         // space for the new element
1281         if len == self.buf.capacity() {
1282             self.reserve(1);
1283         }
1284
1285         unsafe {
1286             // infallible
1287             // The spot to put the new value
1288             {
1289                 let p = self.as_mut_ptr().add(index);
1290                 // Shift everything over to make space. (Duplicating the
1291                 // `index`th element into two consecutive places.)
1292                 ptr::copy(p, p.offset(1), len - index);
1293                 // Write it in, overwriting the first copy of the `index`th
1294                 // element.
1295                 ptr::write(p, element);
1296             }
1297             self.set_len(len + 1);
1298         }
1299     }
1300
1301     /// Removes and returns the element at position `index` within the vector,
1302     /// shifting all elements after it to the left.
1303     ///
1304     /// # Panics
1305     ///
1306     /// Panics if `index` is out of bounds.
1307     ///
1308     /// # Examples
1309     ///
1310     /// ```
1311     /// let mut v = vec![1, 2, 3];
1312     /// assert_eq!(v.remove(1), 2);
1313     /// assert_eq!(v, [1, 3]);
1314     /// ```
1315     #[stable(feature = "rust1", since = "1.0.0")]
1316     pub fn remove(&mut self, index: usize) -> T {
1317         #[cold]
1318         #[inline(never)]
1319         fn assert_failed(index: usize, len: usize) -> ! {
1320             panic!("removal index (is {}) should be < len (is {})", index, len);
1321         }
1322
1323         let len = self.len();
1324         if index >= len {
1325             assert_failed(index, len);
1326         }
1327         unsafe {
1328             // infallible
1329             let ret;
1330             {
1331                 // the place we are taking from.
1332                 let ptr = self.as_mut_ptr().add(index);
1333                 // copy it out, unsafely having a copy of the value on
1334                 // the stack and in the vector at the same time.
1335                 ret = ptr::read(ptr);
1336
1337                 // Shift everything down to fill in that spot.
1338                 ptr::copy(ptr.offset(1), ptr, len - index - 1);
1339             }
1340             self.set_len(len - 1);
1341             ret
1342         }
1343     }
1344
1345     /// Retains only the elements specified by the predicate.
1346     ///
1347     /// In other words, remove all elements `e` such that `f(&e)` returns `false`.
1348     /// This method operates in place, visiting each element exactly once in the
1349     /// original order, and preserves the order of the retained elements.
1350     ///
1351     /// # Examples
1352     ///
1353     /// ```
1354     /// let mut vec = vec![1, 2, 3, 4];
1355     /// vec.retain(|&x| x % 2 == 0);
1356     /// assert_eq!(vec, [2, 4]);
1357     /// ```
1358     ///
1359     /// The exact order may be useful for tracking external state, like an index.
1360     ///
1361     /// ```
1362     /// let mut vec = vec![1, 2, 3, 4, 5];
1363     /// let keep = [false, true, true, false, true];
1364     /// let mut i = 0;
1365     /// vec.retain(|_| (keep[i], i += 1).0);
1366     /// assert_eq!(vec, [2, 3, 5]);
1367     /// ```
1368     #[stable(feature = "rust1", since = "1.0.0")]
1369     pub fn retain<F>(&mut self, mut f: F)
1370     where
1371         F: FnMut(&T) -> bool,
1372     {
1373         let len = self.len();
1374         let mut del = 0;
1375         {
1376             let v = &mut **self;
1377
1378             for i in 0..len {
1379                 if !f(&v[i]) {
1380                     del += 1;
1381                 } else if del > 0 {
1382                     v.swap(i - del, i);
1383                 }
1384             }
1385         }
1386         if del > 0 {
1387             self.truncate(len - del);
1388         }
1389     }
1390
1391     /// Removes all but the first of consecutive elements in the vector that resolve to the same
1392     /// key.
1393     ///
1394     /// If the vector is sorted, this removes all duplicates.
1395     ///
1396     /// # Examples
1397     ///
1398     /// ```
1399     /// let mut vec = vec![10, 20, 21, 30, 20];
1400     ///
1401     /// vec.dedup_by_key(|i| *i / 10);
1402     ///
1403     /// assert_eq!(vec, [10, 20, 30, 20]);
1404     /// ```
1405     #[stable(feature = "dedup_by", since = "1.16.0")]
1406     #[inline]
1407     pub fn dedup_by_key<F, K>(&mut self, mut key: F)
1408     where
1409         F: FnMut(&mut T) -> K,
1410         K: PartialEq,
1411     {
1412         self.dedup_by(|a, b| key(a) == key(b))
1413     }
1414
1415     /// Removes all but the first of consecutive elements in the vector satisfying a given equality
1416     /// relation.
1417     ///
1418     /// The `same_bucket` function is passed references to two elements from the vector and
1419     /// must determine if the elements compare equal. The elements are passed in opposite order
1420     /// from their order in the slice, so if `same_bucket(a, b)` returns `true`, `a` is removed.
1421     ///
1422     /// If the vector is sorted, this removes all duplicates.
1423     ///
1424     /// # Examples
1425     ///
1426     /// ```
1427     /// let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"];
1428     ///
1429     /// vec.dedup_by(|a, b| a.eq_ignore_ascii_case(b));
1430     ///
1431     /// assert_eq!(vec, ["foo", "bar", "baz", "bar"]);
1432     /// ```
1433     #[stable(feature = "dedup_by", since = "1.16.0")]
1434     pub fn dedup_by<F>(&mut self, same_bucket: F)
1435     where
1436         F: FnMut(&mut T, &mut T) -> bool,
1437     {
1438         let len = {
1439             let (dedup, _) = self.as_mut_slice().partition_dedup_by(same_bucket);
1440             dedup.len()
1441         };
1442         self.truncate(len);
1443     }
1444
1445     /// Appends an element to the back of a collection.
1446     ///
1447     /// # Panics
1448     ///
1449     /// Panics if the new capacity exceeds `isize::MAX` bytes.
1450     ///
1451     /// # Examples
1452     ///
1453     /// ```
1454     /// let mut vec = vec![1, 2];
1455     /// vec.push(3);
1456     /// assert_eq!(vec, [1, 2, 3]);
1457     /// ```
1458     #[inline]
1459     #[stable(feature = "rust1", since = "1.0.0")]
1460     pub fn push(&mut self, value: T) {
1461         // This will panic or abort if we would allocate > isize::MAX bytes
1462         // or if the length increment would overflow for zero-sized types.
1463         if self.len == self.buf.capacity() {
1464             self.reserve(1);
1465         }
1466         unsafe {
1467             let end = self.as_mut_ptr().add(self.len);
1468             ptr::write(end, value);
1469             self.len += 1;
1470         }
1471     }
1472
1473     /// Removes the last element from a vector and returns it, or [`None`] if it
1474     /// is empty.
1475     ///
1476     /// # Examples
1477     ///
1478     /// ```
1479     /// let mut vec = vec![1, 2, 3];
1480     /// assert_eq!(vec.pop(), Some(3));
1481     /// assert_eq!(vec, [1, 2]);
1482     /// ```
1483     #[inline]
1484     #[stable(feature = "rust1", since = "1.0.0")]
1485     pub fn pop(&mut self) -> Option<T> {
1486         if self.len == 0 {
1487             None
1488         } else {
1489             unsafe {
1490                 self.len -= 1;
1491                 Some(ptr::read(self.as_ptr().add(self.len())))
1492             }
1493         }
1494     }
1495
1496     /// Moves all the elements of `other` into `Self`, leaving `other` empty.
1497     ///
1498     /// # Panics
1499     ///
1500     /// Panics if the number of elements in the vector overflows a `usize`.
1501     ///
1502     /// # Examples
1503     ///
1504     /// ```
1505     /// let mut vec = vec![1, 2, 3];
1506     /// let mut vec2 = vec![4, 5, 6];
1507     /// vec.append(&mut vec2);
1508     /// assert_eq!(vec, [1, 2, 3, 4, 5, 6]);
1509     /// assert_eq!(vec2, []);
1510     /// ```
1511     #[inline]
1512     #[stable(feature = "append", since = "1.4.0")]
1513     pub fn append(&mut self, other: &mut Self) {
1514         unsafe {
1515             self.append_elements(other.as_slice() as _);
1516             other.set_len(0);
1517         }
1518     }
1519
1520     /// Appends elements to `Self` from other buffer.
1521     #[inline]
1522     unsafe fn append_elements(&mut self, other: *const [T]) {
1523         let count = unsafe { (*other).len() };
1524         self.reserve(count);
1525         let len = self.len();
1526         unsafe { ptr::copy_nonoverlapping(other as *const T, self.as_mut_ptr().add(len), count) };
1527         self.len += count;
1528     }
1529
1530     /// Creates a draining iterator that removes the specified range in the vector
1531     /// and yields the removed items.
1532     ///
1533     /// When the iterator **is** dropped, all elements in the range are removed
1534     /// from the vector, even if the iterator was not fully consumed. If the
1535     /// iterator **is not** dropped (with [`mem::forget`] for example), it is
1536     /// unspecified how many elements are removed.
1537     ///
1538     /// # Panics
1539     ///
1540     /// Panics if the starting point is greater than the end point or if
1541     /// the end point is greater than the length of the vector.
1542     ///
1543     /// # Examples
1544     ///
1545     /// ```
1546     /// let mut v = vec![1, 2, 3];
1547     /// let u: Vec<_> = v.drain(1..).collect();
1548     /// assert_eq!(v, &[1]);
1549     /// assert_eq!(u, &[2, 3]);
1550     ///
1551     /// // A full range clears the vector
1552     /// v.drain(..);
1553     /// assert_eq!(v, &[]);
1554     /// ```
1555     #[stable(feature = "drain", since = "1.6.0")]
1556     pub fn drain<R>(&mut self, range: R) -> Drain<'_, T, A>
1557     where
1558         R: RangeBounds<usize>,
1559     {
1560         // Memory safety
1561         //
1562         // When the Drain is first created, it shortens the length of
1563         // the source vector to make sure no uninitialized or moved-from elements
1564         // are accessible at all if the Drain's destructor never gets to run.
1565         //
1566         // Drain will ptr::read out the values to remove.
1567         // When finished, remaining tail of the vec is copied back to cover
1568         // the hole, and the vector length is restored to the new length.
1569         //
1570         let len = self.len();
1571         let Range { start, end } = range.assert_len(len);
1572
1573         unsafe {
1574             // set self.vec length's to start, to be safe in case Drain is leaked
1575             self.set_len(start);
1576             // Use the borrow in the IterMut to indicate borrowing behavior of the
1577             // whole Drain iterator (like &mut T).
1578             let range_slice = slice::from_raw_parts_mut(self.as_mut_ptr().add(start), end - start);
1579             Drain {
1580                 tail_start: end,
1581                 tail_len: len - end,
1582                 iter: range_slice.iter(),
1583                 vec: NonNull::from(self),
1584             }
1585         }
1586     }
1587
1588     /// Clears the vector, removing all values.
1589     ///
1590     /// Note that this method has no effect on the allocated capacity
1591     /// of the vector.
1592     ///
1593     /// # Examples
1594     ///
1595     /// ```
1596     /// let mut v = vec![1, 2, 3];
1597     ///
1598     /// v.clear();
1599     ///
1600     /// assert!(v.is_empty());
1601     /// ```
1602     #[inline]
1603     #[stable(feature = "rust1", since = "1.0.0")]
1604     pub fn clear(&mut self) {
1605         self.truncate(0)
1606     }
1607
1608     /// Returns the number of elements in the vector, also referred to
1609     /// as its 'length'.
1610     ///
1611     /// # Examples
1612     ///
1613     /// ```
1614     /// let a = vec![1, 2, 3];
1615     /// assert_eq!(a.len(), 3);
1616     /// ```
1617     #[doc(alias = "length")]
1618     #[inline]
1619     #[stable(feature = "rust1", since = "1.0.0")]
1620     pub fn len(&self) -> usize {
1621         self.len
1622     }
1623
1624     /// Returns `true` if the vector contains no elements.
1625     ///
1626     /// # Examples
1627     ///
1628     /// ```
1629     /// let mut v = Vec::new();
1630     /// assert!(v.is_empty());
1631     ///
1632     /// v.push(1);
1633     /// assert!(!v.is_empty());
1634     /// ```
1635     #[stable(feature = "rust1", since = "1.0.0")]
1636     pub fn is_empty(&self) -> bool {
1637         self.len() == 0
1638     }
1639
1640     /// Splits the collection into two at the given index.
1641     ///
1642     /// Returns a newly allocated vector containing the elements in the range
1643     /// `[at, len)`. After the call, the original vector will be left containing
1644     /// the elements `[0, at)` with its previous capacity unchanged.
1645     ///
1646     /// # Panics
1647     ///
1648     /// Panics if `at > len`.
1649     ///
1650     /// # Examples
1651     ///
1652     /// ```
1653     /// let mut vec = vec![1, 2, 3];
1654     /// let vec2 = vec.split_off(1);
1655     /// assert_eq!(vec, [1]);
1656     /// assert_eq!(vec2, [2, 3]);
1657     /// ```
1658     #[inline]
1659     #[must_use = "use `.truncate()` if you don't need the other half"]
1660     #[stable(feature = "split_off", since = "1.4.0")]
1661     pub fn split_off(&mut self, at: usize) -> Self
1662     where
1663         A: Clone,
1664     {
1665         #[cold]
1666         #[inline(never)]
1667         fn assert_failed(at: usize, len: usize) -> ! {
1668             panic!("`at` split index (is {}) should be <= len (is {})", at, len);
1669         }
1670
1671         if at > self.len() {
1672             assert_failed(at, self.len());
1673         }
1674
1675         if at == 0 {
1676             // the new vector can take over the original buffer and avoid the copy
1677             return mem::replace(
1678                 self,
1679                 Vec::with_capacity_in(self.capacity(), self.allocator().clone()),
1680             );
1681         }
1682
1683         let other_len = self.len - at;
1684         let mut other = Vec::with_capacity_in(other_len, self.allocator().clone());
1685
1686         // Unsafely `set_len` and copy items to `other`.
1687         unsafe {
1688             self.set_len(at);
1689             other.set_len(other_len);
1690
1691             ptr::copy_nonoverlapping(self.as_ptr().add(at), other.as_mut_ptr(), other.len());
1692         }
1693         other
1694     }
1695
1696     /// Resizes the `Vec` in-place so that `len` is equal to `new_len`.
1697     ///
1698     /// If `new_len` is greater than `len`, the `Vec` is extended by the
1699     /// difference, with each additional slot filled with the result of
1700     /// calling the closure `f`. The return values from `f` will end up
1701     /// in the `Vec` in the order they have been generated.
1702     ///
1703     /// If `new_len` is less than `len`, the `Vec` is simply truncated.
1704     ///
1705     /// This method uses a closure to create new values on every push. If
1706     /// you'd rather [`Clone`] a given value, use [`Vec::resize`]. If you
1707     /// want to use the [`Default`] trait to generate values, you can
1708     /// pass [`Default::default`] as the second argument.
1709     ///
1710     /// # Examples
1711     ///
1712     /// ```
1713     /// let mut vec = vec![1, 2, 3];
1714     /// vec.resize_with(5, Default::default);
1715     /// assert_eq!(vec, [1, 2, 3, 0, 0]);
1716     ///
1717     /// let mut vec = vec![];
1718     /// let mut p = 1;
1719     /// vec.resize_with(4, || { p *= 2; p });
1720     /// assert_eq!(vec, [2, 4, 8, 16]);
1721     /// ```
1722     #[stable(feature = "vec_resize_with", since = "1.33.0")]
1723     pub fn resize_with<F>(&mut self, new_len: usize, f: F)
1724     where
1725         F: FnMut() -> T,
1726     {
1727         let len = self.len();
1728         if new_len > len {
1729             self.extend_with(new_len - len, ExtendFunc(f));
1730         } else {
1731             self.truncate(new_len);
1732         }
1733     }
1734
1735     /// Consumes and leaks the `Vec`, returning a mutable reference to the contents,
1736     /// `&'a mut [T]`. Note that the type `T` must outlive the chosen lifetime
1737     /// `'a`. If the type has only static references, or none at all, then this
1738     /// may be chosen to be `'static`.
1739     ///
1740     /// This function is similar to the [`leak`][Box::leak] function on [`Box`]
1741     /// except that there is no way to recover the leaked memory.
1742     ///
1743     /// This function is mainly useful for data that lives for the remainder of
1744     /// the program's life. Dropping the returned reference will cause a memory
1745     /// leak.
1746     ///
1747     /// # Examples
1748     ///
1749     /// Simple usage:
1750     ///
1751     /// ```
1752     /// let x = vec![1, 2, 3];
1753     /// let static_ref: &'static mut [usize] = x.leak();
1754     /// static_ref[0] += 1;
1755     /// assert_eq!(static_ref, &[2, 2, 3]);
1756     /// ```
1757     #[stable(feature = "vec_leak", since = "1.47.0")]
1758     #[inline]
1759     pub fn leak<'a>(self) -> &'a mut [T]
1760     where
1761         A: 'a,
1762     {
1763         Box::leak(self.into_boxed_slice())
1764     }
1765
1766     /// Returns the remaining spare capacity of the vector as a slice of
1767     /// `MaybeUninit<T>`.
1768     ///
1769     /// The returned slice can be used to fill the vector with data (e.g. by
1770     /// reading from a file) before marking the data as initialized using the
1771     /// [`set_len`] method.
1772     ///
1773     /// [`set_len`]: Vec::set_len
1774     ///
1775     /// # Examples
1776     ///
1777     /// ```
1778     /// #![feature(vec_spare_capacity, maybe_uninit_extra)]
1779     ///
1780     /// // Allocate vector big enough for 10 elements.
1781     /// let mut v = Vec::with_capacity(10);
1782     ///
1783     /// // Fill in the first 3 elements.
1784     /// let uninit = v.spare_capacity_mut();
1785     /// uninit[0].write(0);
1786     /// uninit[1].write(1);
1787     /// uninit[2].write(2);
1788     ///
1789     /// // Mark the first 3 elements of the vector as being initialized.
1790     /// unsafe {
1791     ///     v.set_len(3);
1792     /// }
1793     ///
1794     /// assert_eq!(&v, &[0, 1, 2]);
1795     /// ```
1796     #[unstable(feature = "vec_spare_capacity", issue = "75017")]
1797     #[inline]
1798     pub fn spare_capacity_mut(&mut self) -> &mut [MaybeUninit<T>] {
1799         unsafe {
1800             slice::from_raw_parts_mut(
1801                 self.as_mut_ptr().add(self.len) as *mut MaybeUninit<T>,
1802                 self.buf.capacity() - self.len,
1803             )
1804         }
1805     }
1806 }
1807
1808 impl<T: Clone, A: Allocator> Vec<T, A> {
1809     /// Resizes the `Vec` in-place so that `len` is equal to `new_len`.
1810     ///
1811     /// If `new_len` is greater than `len`, the `Vec` is extended by the
1812     /// difference, with each additional slot filled with `value`.
1813     /// If `new_len` is less than `len`, the `Vec` is simply truncated.
1814     ///
1815     /// This method requires `T` to implement [`Clone`],
1816     /// in order to be able to clone the passed value.
1817     /// If you need more flexibility (or want to rely on [`Default`] instead of
1818     /// [`Clone`]), use [`Vec::resize_with`].
1819     ///
1820     /// # Examples
1821     ///
1822     /// ```
1823     /// let mut vec = vec!["hello"];
1824     /// vec.resize(3, "world");
1825     /// assert_eq!(vec, ["hello", "world", "world"]);
1826     ///
1827     /// let mut vec = vec![1, 2, 3, 4];
1828     /// vec.resize(2, 0);
1829     /// assert_eq!(vec, [1, 2]);
1830     /// ```
1831     #[stable(feature = "vec_resize", since = "1.5.0")]
1832     pub fn resize(&mut self, new_len: usize, value: T) {
1833         let len = self.len();
1834
1835         if new_len > len {
1836             self.extend_with(new_len - len, ExtendElement(value))
1837         } else {
1838             self.truncate(new_len);
1839         }
1840     }
1841
1842     /// Clones and appends all elements in a slice to the `Vec`.
1843     ///
1844     /// Iterates over the slice `other`, clones each element, and then appends
1845     /// it to this `Vec`. The `other` vector is traversed in-order.
1846     ///
1847     /// Note that this function is same as [`extend`] except that it is
1848     /// specialized to work with slices instead. If and when Rust gets
1849     /// specialization this function will likely be deprecated (but still
1850     /// available).
1851     ///
1852     /// # Examples
1853     ///
1854     /// ```
1855     /// let mut vec = vec![1];
1856     /// vec.extend_from_slice(&[2, 3, 4]);
1857     /// assert_eq!(vec, [1, 2, 3, 4]);
1858     /// ```
1859     ///
1860     /// [`extend`]: Vec::extend
1861     #[stable(feature = "vec_extend_from_slice", since = "1.6.0")]
1862     pub fn extend_from_slice(&mut self, other: &[T]) {
1863         self.spec_extend(other.iter())
1864     }
1865 }
1866
1867 // This code generalizes `extend_with_{element,default}`.
1868 trait ExtendWith<T> {
1869     fn next(&mut self) -> T;
1870     fn last(self) -> T;
1871 }
1872
1873 struct ExtendElement<T>(T);
1874 impl<T: Clone> ExtendWith<T> for ExtendElement<T> {
1875     fn next(&mut self) -> T {
1876         self.0.clone()
1877     }
1878     fn last(self) -> T {
1879         self.0
1880     }
1881 }
1882
1883 struct ExtendDefault;
1884 impl<T: Default> ExtendWith<T> for ExtendDefault {
1885     fn next(&mut self) -> T {
1886         Default::default()
1887     }
1888     fn last(self) -> T {
1889         Default::default()
1890     }
1891 }
1892
1893 struct ExtendFunc<F>(F);
1894 impl<T, F: FnMut() -> T> ExtendWith<T> for ExtendFunc<F> {
1895     fn next(&mut self) -> T {
1896         (self.0)()
1897     }
1898     fn last(mut self) -> T {
1899         (self.0)()
1900     }
1901 }
1902
1903 impl<T, A: Allocator> Vec<T, A> {
1904     /// Extend the vector by `n` values, using the given generator.
1905     fn extend_with<E: ExtendWith<T>>(&mut self, n: usize, mut value: E) {
1906         self.reserve(n);
1907
1908         unsafe {
1909             let mut ptr = self.as_mut_ptr().add(self.len());
1910             // Use SetLenOnDrop to work around bug where compiler
1911             // may not realize the store through `ptr` through self.set_len()
1912             // don't alias.
1913             let mut local_len = SetLenOnDrop::new(&mut self.len);
1914
1915             // Write all elements except the last one
1916             for _ in 1..n {
1917                 ptr::write(ptr, value.next());
1918                 ptr = ptr.offset(1);
1919                 // Increment the length in every step in case next() panics
1920                 local_len.increment_len(1);
1921             }
1922
1923             if n > 0 {
1924                 // We can write the last element directly without cloning needlessly
1925                 ptr::write(ptr, value.last());
1926                 local_len.increment_len(1);
1927             }
1928
1929             // len set by scope guard
1930         }
1931     }
1932 }
1933
1934 impl<T: PartialEq, A: Allocator> Vec<T, A> {
1935     /// Removes consecutive repeated elements in the vector according to the
1936     /// [`PartialEq`] trait implementation.
1937     ///
1938     /// If the vector is sorted, this removes all duplicates.
1939     ///
1940     /// # Examples
1941     ///
1942     /// ```
1943     /// let mut vec = vec![1, 2, 2, 3, 2];
1944     ///
1945     /// vec.dedup();
1946     ///
1947     /// assert_eq!(vec, [1, 2, 3, 2]);
1948     /// ```
1949     #[stable(feature = "rust1", since = "1.0.0")]
1950     #[inline]
1951     pub fn dedup(&mut self) {
1952         self.dedup_by(|a, b| a == b)
1953     }
1954 }
1955
1956 impl<T, A: Allocator> Vec<T, A> {
1957     /// Removes the first instance of `item` from the vector if the item exists.
1958     ///
1959     /// This method will be removed soon.
1960     #[unstable(feature = "vec_remove_item", reason = "recently added", issue = "40062")]
1961     #[rustc_deprecated(
1962         reason = "Removing the first item equal to a needle is already easily possible \
1963             with iterators and the current Vec methods. Furthermore, having a method for \
1964             one particular case of removal (linear search, only the first item, no swap remove) \
1965             but not for others is inconsistent. This method will be removed soon.",
1966         since = "1.46.0"
1967     )]
1968     pub fn remove_item<V>(&mut self, item: &V) -> Option<T>
1969     where
1970         T: PartialEq<V>,
1971     {
1972         let pos = self.iter().position(|x| *x == *item)?;
1973         Some(self.remove(pos))
1974     }
1975 }
1976
1977 ////////////////////////////////////////////////////////////////////////////////
1978 // Internal methods and functions
1979 ////////////////////////////////////////////////////////////////////////////////
1980
1981 #[doc(hidden)]
1982 #[stable(feature = "rust1", since = "1.0.0")]
1983 pub fn from_elem<T: Clone>(elem: T, n: usize) -> Vec<T> {
1984     <T as SpecFromElem>::from_elem(elem, n, Global)
1985 }
1986
1987 #[doc(hidden)]
1988 #[unstable(feature = "allocator_api", issue = "32838")]
1989 pub fn from_elem_in<T: Clone, A: Allocator>(elem: T, n: usize, alloc: A) -> Vec<T, A> {
1990     <T as SpecFromElem>::from_elem(elem, n, alloc)
1991 }
1992
1993 ////////////////////////////////////////////////////////////////////////////////
1994 // Common trait implementations for Vec
1995 ////////////////////////////////////////////////////////////////////////////////
1996
1997 #[stable(feature = "rust1", since = "1.0.0")]
1998 impl<T, A: Allocator> ops::Deref for Vec<T, A> {
1999     type Target = [T];
2000
2001     fn deref(&self) -> &[T] {
2002         unsafe { slice::from_raw_parts(self.as_ptr(), self.len) }
2003     }
2004 }
2005
2006 #[stable(feature = "rust1", since = "1.0.0")]
2007 impl<T, A: Allocator> ops::DerefMut for Vec<T, A> {
2008     fn deref_mut(&mut self) -> &mut [T] {
2009         unsafe { slice::from_raw_parts_mut(self.as_mut_ptr(), self.len) }
2010     }
2011 }
2012
2013 #[stable(feature = "rust1", since = "1.0.0")]
2014 impl<T: Clone, A: Allocator + Clone> Clone for Vec<T, A> {
2015     #[cfg(not(test))]
2016     fn clone(&self) -> Self {
2017         let alloc = self.allocator().clone();
2018         <[T]>::to_vec_in(&**self, alloc)
2019     }
2020
2021     // HACK(japaric): with cfg(test) the inherent `[T]::to_vec` method, which is
2022     // required for this method definition, is not available. Instead use the
2023     // `slice::to_vec`  function which is only available with cfg(test)
2024     // NB see the slice::hack module in slice.rs for more information
2025     #[cfg(test)]
2026     fn clone(&self) -> Self {
2027         let alloc = self.allocator().clone();
2028         crate::slice::to_vec(&**self, alloc)
2029     }
2030
2031     fn clone_from(&mut self, other: &Self) {
2032         // drop anything that will not be overwritten
2033         self.truncate(other.len());
2034
2035         // self.len <= other.len due to the truncate above, so the
2036         // slices here are always in-bounds.
2037         let (init, tail) = other.split_at(self.len());
2038
2039         // reuse the contained values' allocations/resources.
2040         self.clone_from_slice(init);
2041         self.extend_from_slice(tail);
2042     }
2043 }
2044
2045 #[stable(feature = "rust1", since = "1.0.0")]
2046 impl<T: Hash, A: Allocator> Hash for Vec<T, A> {
2047     #[inline]
2048     fn hash<H: Hasher>(&self, state: &mut H) {
2049         Hash::hash(&**self, state)
2050     }
2051 }
2052
2053 #[stable(feature = "rust1", since = "1.0.0")]
2054 #[rustc_on_unimplemented(
2055     message = "vector indices are of type `usize` or ranges of `usize`",
2056     label = "vector indices are of type `usize` or ranges of `usize`"
2057 )]
2058 impl<T, I: SliceIndex<[T]>, A: Allocator> Index<I> for Vec<T, A> {
2059     type Output = I::Output;
2060
2061     #[inline]
2062     fn index(&self, index: I) -> &Self::Output {
2063         Index::index(&**self, index)
2064     }
2065 }
2066
2067 #[stable(feature = "rust1", since = "1.0.0")]
2068 #[rustc_on_unimplemented(
2069     message = "vector indices are of type `usize` or ranges of `usize`",
2070     label = "vector indices are of type `usize` or ranges of `usize`"
2071 )]
2072 impl<T, I: SliceIndex<[T]>, A: Allocator> IndexMut<I> for Vec<T, A> {
2073     #[inline]
2074     fn index_mut(&mut self, index: I) -> &mut Self::Output {
2075         IndexMut::index_mut(&mut **self, index)
2076     }
2077 }
2078
2079 #[stable(feature = "rust1", since = "1.0.0")]
2080 impl<T> FromIterator<T> for Vec<T> {
2081     #[inline]
2082     fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Vec<T> {
2083         <Self as SpecFromIter<T, I::IntoIter>>::from_iter(iter.into_iter())
2084     }
2085 }
2086
2087 #[stable(feature = "rust1", since = "1.0.0")]
2088 impl<T, A: Allocator> IntoIterator for Vec<T, A> {
2089     type Item = T;
2090     type IntoIter = IntoIter<T, A>;
2091
2092     /// Creates a consuming iterator, that is, one that moves each value out of
2093     /// the vector (from start to end). The vector cannot be used after calling
2094     /// this.
2095     ///
2096     /// # Examples
2097     ///
2098     /// ```
2099     /// let v = vec!["a".to_string(), "b".to_string()];
2100     /// for s in v.into_iter() {
2101     ///     // s has type String, not &String
2102     ///     println!("{}", s);
2103     /// }
2104     /// ```
2105     #[inline]
2106     fn into_iter(self) -> IntoIter<T, A> {
2107         unsafe {
2108             let mut me = ManuallyDrop::new(self);
2109             let alloc = ptr::read(me.allocator());
2110             let begin = me.as_mut_ptr();
2111             let end = if mem::size_of::<T>() == 0 {
2112                 arith_offset(begin as *const i8, me.len() as isize) as *const T
2113             } else {
2114                 begin.add(me.len()) as *const T
2115             };
2116             let cap = me.buf.capacity();
2117             IntoIter {
2118                 buf: NonNull::new_unchecked(begin),
2119                 phantom: PhantomData,
2120                 cap,
2121                 alloc,
2122                 ptr: begin,
2123                 end,
2124             }
2125         }
2126     }
2127 }
2128
2129 #[stable(feature = "rust1", since = "1.0.0")]
2130 impl<'a, T, A: Allocator> IntoIterator for &'a Vec<T, A> {
2131     type Item = &'a T;
2132     type IntoIter = slice::Iter<'a, T>;
2133
2134     fn into_iter(self) -> slice::Iter<'a, T> {
2135         self.iter()
2136     }
2137 }
2138
2139 #[stable(feature = "rust1", since = "1.0.0")]
2140 impl<'a, T, A: Allocator> IntoIterator for &'a mut Vec<T, A> {
2141     type Item = &'a mut T;
2142     type IntoIter = slice::IterMut<'a, T>;
2143
2144     fn into_iter(self) -> slice::IterMut<'a, T> {
2145         self.iter_mut()
2146     }
2147 }
2148
2149 #[stable(feature = "rust1", since = "1.0.0")]
2150 impl<T, A: Allocator> Extend<T> for Vec<T, A> {
2151     #[inline]
2152     fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
2153         <Self as SpecExtend<T, I::IntoIter>>::spec_extend(self, iter.into_iter())
2154     }
2155
2156     #[inline]
2157     fn extend_one(&mut self, item: T) {
2158         self.push(item);
2159     }
2160
2161     #[inline]
2162     fn extend_reserve(&mut self, additional: usize) {
2163         self.reserve(additional);
2164     }
2165 }
2166
2167 impl<T, A: Allocator> Vec<T, A> {
2168     // leaf method to which various SpecFrom/SpecExtend implementations delegate when
2169     // they have no further optimizations to apply
2170     fn extend_desugared<I: Iterator<Item = T>>(&mut self, mut iterator: I) {
2171         // This is the case for a general iterator.
2172         //
2173         // This function should be the moral equivalent of:
2174         //
2175         //      for item in iterator {
2176         //          self.push(item);
2177         //      }
2178         while let Some(element) = iterator.next() {
2179             let len = self.len();
2180             if len == self.capacity() {
2181                 let (lower, _) = iterator.size_hint();
2182                 self.reserve(lower.saturating_add(1));
2183             }
2184             unsafe {
2185                 ptr::write(self.as_mut_ptr().add(len), element);
2186                 // NB can't overflow since we would have had to alloc the address space
2187                 self.set_len(len + 1);
2188             }
2189         }
2190     }
2191
2192     /// Creates a splicing iterator that replaces the specified range in the vector
2193     /// with the given `replace_with` iterator and yields the removed items.
2194     /// `replace_with` does not need to be the same length as `range`.
2195     ///
2196     /// `range` is removed even if the iterator is not consumed until the end.
2197     ///
2198     /// It is unspecified how many elements are removed from the vector
2199     /// if the `Splice` value is leaked.
2200     ///
2201     /// The input iterator `replace_with` is only consumed when the `Splice` value is dropped.
2202     ///
2203     /// This is optimal if:
2204     ///
2205     /// * The tail (elements in the vector after `range`) is empty,
2206     /// * or `replace_with` yields fewer elements than `range`’s length
2207     /// * or the lower bound of its `size_hint()` is exact.
2208     ///
2209     /// Otherwise, a temporary vector is allocated and the tail is moved twice.
2210     ///
2211     /// # Panics
2212     ///
2213     /// Panics if the starting point is greater than the end point or if
2214     /// the end point is greater than the length of the vector.
2215     ///
2216     /// # Examples
2217     ///
2218     /// ```
2219     /// let mut v = vec![1, 2, 3];
2220     /// let new = [7, 8];
2221     /// let u: Vec<_> = v.splice(..2, new.iter().cloned()).collect();
2222     /// assert_eq!(v, &[7, 8, 3]);
2223     /// assert_eq!(u, &[1, 2]);
2224     /// ```
2225     #[inline]
2226     #[stable(feature = "vec_splice", since = "1.21.0")]
2227     pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoIter, A>
2228     where
2229         R: RangeBounds<usize>,
2230         I: IntoIterator<Item = T>,
2231     {
2232         Splice { drain: self.drain(range), replace_with: replace_with.into_iter() }
2233     }
2234
2235     /// Creates an iterator which uses a closure to determine if an element should be removed.
2236     ///
2237     /// If the closure returns true, then the element is removed and yielded.
2238     /// If the closure returns false, the element will remain in the vector and will not be yielded
2239     /// by the iterator.
2240     ///
2241     /// Using this method is equivalent to the following code:
2242     ///
2243     /// ```
2244     /// # let some_predicate = |x: &mut i32| { *x == 2 || *x == 3 || *x == 6 };
2245     /// # let mut vec = vec![1, 2, 3, 4, 5, 6];
2246     /// let mut i = 0;
2247     /// while i != vec.len() {
2248     ///     if some_predicate(&mut vec[i]) {
2249     ///         let val = vec.remove(i);
2250     ///         // your code here
2251     ///     } else {
2252     ///         i += 1;
2253     ///     }
2254     /// }
2255     ///
2256     /// # assert_eq!(vec, vec![1, 4, 5]);
2257     /// ```
2258     ///
2259     /// But `drain_filter` is easier to use. `drain_filter` is also more efficient,
2260     /// because it can backshift the elements of the array in bulk.
2261     ///
2262     /// Note that `drain_filter` also lets you mutate every element in the filter closure,
2263     /// regardless of whether you choose to keep or remove it.
2264     ///
2265     /// # Examples
2266     ///
2267     /// Splitting an array into evens and odds, reusing the original allocation:
2268     ///
2269     /// ```
2270     /// #![feature(drain_filter)]
2271     /// let mut numbers = vec![1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15];
2272     ///
2273     /// let evens = numbers.drain_filter(|x| *x % 2 == 0).collect::<Vec<_>>();
2274     /// let odds = numbers;
2275     ///
2276     /// assert_eq!(evens, vec![2, 4, 6, 8, 14]);
2277     /// assert_eq!(odds, vec![1, 3, 5, 9, 11, 13, 15]);
2278     /// ```
2279     #[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
2280     pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<'_, T, F, A>
2281     where
2282         F: FnMut(&mut T) -> bool,
2283     {
2284         let old_len = self.len();
2285
2286         // Guard against us getting leaked (leak amplification)
2287         unsafe {
2288             self.set_len(0);
2289         }
2290
2291         DrainFilter { vec: self, idx: 0, del: 0, old_len, pred: filter, panic_flag: false }
2292     }
2293 }
2294
2295 /// Extend implementation that copies elements out of references before pushing them onto the Vec.
2296 ///
2297 /// This implementation is specialized for slice iterators, where it uses [`copy_from_slice`] to
2298 /// append the entire slice at once.
2299 ///
2300 /// [`copy_from_slice`]: ../../std/primitive.slice.html#method.copy_from_slice
2301 #[stable(feature = "extend_ref", since = "1.2.0")]
2302 impl<'a, T: Copy + 'a, A: Allocator + 'a> Extend<&'a T> for Vec<T, A> {
2303     fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
2304         self.spec_extend(iter.into_iter())
2305     }
2306
2307     #[inline]
2308     fn extend_one(&mut self, &item: &'a T) {
2309         self.push(item);
2310     }
2311
2312     #[inline]
2313     fn extend_reserve(&mut self, additional: usize) {
2314         self.reserve(additional);
2315     }
2316 }
2317
2318 /// Implements comparison of vectors, [lexicographically](core::cmp::Ord#lexicographical-comparison).
2319 #[stable(feature = "rust1", since = "1.0.0")]
2320 impl<T: PartialOrd, A: Allocator> PartialOrd for Vec<T, A> {
2321     #[inline]
2322     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
2323         PartialOrd::partial_cmp(&**self, &**other)
2324     }
2325 }
2326
2327 #[stable(feature = "rust1", since = "1.0.0")]
2328 impl<T: Eq, A: Allocator> Eq for Vec<T, A> {}
2329
2330 /// Implements ordering of vectors, [lexicographically](core::cmp::Ord#lexicographical-comparison).
2331 #[stable(feature = "rust1", since = "1.0.0")]
2332 impl<T: Ord, A: Allocator> Ord for Vec<T, A> {
2333     #[inline]
2334     fn cmp(&self, other: &Self) -> Ordering {
2335         Ord::cmp(&**self, &**other)
2336     }
2337 }
2338
2339 #[stable(feature = "rust1", since = "1.0.0")]
2340 unsafe impl<#[may_dangle] T, A: Allocator> Drop for Vec<T, A> {
2341     fn drop(&mut self) {
2342         unsafe {
2343             // use drop for [T]
2344             // use a raw slice to refer to the elements of the vector as weakest necessary type;
2345             // could avoid questions of validity in certain cases
2346             ptr::drop_in_place(ptr::slice_from_raw_parts_mut(self.as_mut_ptr(), self.len))
2347         }
2348         // RawVec handles deallocation
2349     }
2350 }
2351
2352 #[stable(feature = "rust1", since = "1.0.0")]
2353 impl<T> Default for Vec<T> {
2354     /// Creates an empty `Vec<T>`.
2355     fn default() -> Vec<T> {
2356         Vec::new()
2357     }
2358 }
2359
2360 #[stable(feature = "rust1", since = "1.0.0")]
2361 impl<T: fmt::Debug, A: Allocator> fmt::Debug for Vec<T, A> {
2362     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2363         fmt::Debug::fmt(&**self, f)
2364     }
2365 }
2366
2367 #[stable(feature = "rust1", since = "1.0.0")]
2368 impl<T, A: Allocator> AsRef<Vec<T, A>> for Vec<T, A> {
2369     fn as_ref(&self) -> &Vec<T, A> {
2370         self
2371     }
2372 }
2373
2374 #[stable(feature = "vec_as_mut", since = "1.5.0")]
2375 impl<T, A: Allocator> AsMut<Vec<T, A>> for Vec<T, A> {
2376     fn as_mut(&mut self) -> &mut Vec<T, A> {
2377         self
2378     }
2379 }
2380
2381 #[stable(feature = "rust1", since = "1.0.0")]
2382 impl<T, A: Allocator> AsRef<[T]> for Vec<T, A> {
2383     fn as_ref(&self) -> &[T] {
2384         self
2385     }
2386 }
2387
2388 #[stable(feature = "vec_as_mut", since = "1.5.0")]
2389 impl<T, A: Allocator> AsMut<[T]> for Vec<T, A> {
2390     fn as_mut(&mut self) -> &mut [T] {
2391         self
2392     }
2393 }
2394
2395 #[stable(feature = "rust1", since = "1.0.0")]
2396 impl<T: Clone> From<&[T]> for Vec<T> {
2397     #[cfg(not(test))]
2398     fn from(s: &[T]) -> Vec<T> {
2399         s.to_vec()
2400     }
2401     #[cfg(test)]
2402     fn from(s: &[T]) -> Vec<T> {
2403         crate::slice::to_vec(s, Global)
2404     }
2405 }
2406
2407 #[stable(feature = "vec_from_mut", since = "1.19.0")]
2408 impl<T: Clone> From<&mut [T]> for Vec<T> {
2409     #[cfg(not(test))]
2410     fn from(s: &mut [T]) -> Vec<T> {
2411         s.to_vec()
2412     }
2413     #[cfg(test)]
2414     fn from(s: &mut [T]) -> Vec<T> {
2415         crate::slice::to_vec(s, Global)
2416     }
2417 }
2418
2419 #[stable(feature = "vec_from_array", since = "1.44.0")]
2420 impl<T, const N: usize> From<[T; N]> for Vec<T> {
2421     #[cfg(not(test))]
2422     fn from(s: [T; N]) -> Vec<T> {
2423         <[T]>::into_vec(box s)
2424     }
2425     #[cfg(test)]
2426     fn from(s: [T; N]) -> Vec<T> {
2427         crate::slice::into_vec(box s)
2428     }
2429 }
2430
2431 #[stable(feature = "vec_from_cow_slice", since = "1.14.0")]
2432 impl<'a, T> From<Cow<'a, [T]>> for Vec<T>
2433 where
2434     [T]: ToOwned<Owned = Vec<T>>,
2435 {
2436     fn from(s: Cow<'a, [T]>) -> Vec<T> {
2437         s.into_owned()
2438     }
2439 }
2440
2441 // note: test pulls in libstd, which causes errors here
2442 #[cfg(not(test))]
2443 #[stable(feature = "vec_from_box", since = "1.18.0")]
2444 impl<T, A: Allocator> From<Box<[T], A>> for Vec<T, A> {
2445     fn from(s: Box<[T], A>) -> Self {
2446         let len = s.len();
2447         Self { buf: RawVec::from_box(s), len }
2448     }
2449 }
2450
2451 // note: test pulls in libstd, which causes errors here
2452 #[cfg(not(test))]
2453 #[stable(feature = "box_from_vec", since = "1.20.0")]
2454 impl<T, A: Allocator> From<Vec<T, A>> for Box<[T], A> {
2455     fn from(v: Vec<T, A>) -> Self {
2456         v.into_boxed_slice()
2457     }
2458 }
2459
2460 #[stable(feature = "rust1", since = "1.0.0")]
2461 impl From<&str> for Vec<u8> {
2462     fn from(s: &str) -> Vec<u8> {
2463         From::from(s.as_bytes())
2464     }
2465 }
2466
2467 #[stable(feature = "array_try_from_vec", since = "1.48.0")]
2468 impl<T, A: Allocator, const N: usize> TryFrom<Vec<T, A>> for [T; N] {
2469     type Error = Vec<T, A>;
2470
2471     /// Gets the entire contents of the `Vec<T>` as an array,
2472     /// if its size exactly matches that of the requested array.
2473     ///
2474     /// # Examples
2475     ///
2476     /// ```
2477     /// use std::convert::TryInto;
2478     /// assert_eq!(vec![1, 2, 3].try_into(), Ok([1, 2, 3]));
2479     /// assert_eq!(<Vec<i32>>::new().try_into(), Ok([]));
2480     /// ```
2481     ///
2482     /// If the length doesn't match, the input comes back in `Err`:
2483     /// ```
2484     /// use std::convert::TryInto;
2485     /// let r: Result<[i32; 4], _> = (0..10).collect::<Vec<_>>().try_into();
2486     /// assert_eq!(r, Err(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));
2487     /// ```
2488     ///
2489     /// If you're fine with just getting a prefix of the `Vec<T>`,
2490     /// you can call [`.truncate(N)`](Vec::truncate) first.
2491     /// ```
2492     /// use std::convert::TryInto;
2493     /// let mut v = String::from("hello world").into_bytes();
2494     /// v.sort();
2495     /// v.truncate(2);
2496     /// let [a, b]: [_; 2] = v.try_into().unwrap();
2497     /// assert_eq!(a, b' ');
2498     /// assert_eq!(b, b'd');
2499     /// ```
2500     fn try_from(mut vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>> {
2501         if vec.len() != N {
2502             return Err(vec);
2503         }
2504
2505         // SAFETY: `.set_len(0)` is always sound.
2506         unsafe { vec.set_len(0) };
2507
2508         // SAFETY: A `Vec`'s pointer is always aligned properly, and
2509         // the alignment the array needs is the same as the items.
2510         // We checked earlier that we have sufficient items.
2511         // The items will not double-drop as the `set_len`
2512         // tells the `Vec` not to also drop them.
2513         let array = unsafe { ptr::read(vec.as_ptr() as *const [T; N]) };
2514         Ok(array)
2515     }
2516 }