Constructs a new, emptyVec<T>.

The vector will not allocate until elements are pushed onto it.

§Examples

letmutvec: Vec<i32> = Vec::new();

Constructs a new, emptyVec<T> with at least the specified capacity.

The vector will be able to hold at leastcapacity elements withoutreallocating. This method is allowed to allocate for more elements thancapacity. Ifcapacity is zero, the vector will not allocate.

It is important to note that although the returned vector has theminimumcapacity specified, the vector will have a zerolength. Foran explanation of the difference between length and capacity, seeCapacity and reallocation.

If it is important to know the exact allocated capacity of aVec,always use thecapacity method after construction.

ForVec<T> whereT is a zero-sized type, there will be no allocationand the capacity will always beusize::MAX.

§Panics

Panics if the new capacity exceedsisize::MAXbytes.

§Examples

letmutvec = Vec::with_capacity(10);// The vector contains no items, even though it has capacity for moreassert_eq!(vec.len(),0);assert!(vec.capacity() >=10);// These are all done without reallocating...foriin0..10{    vec.push(i);}assert_eq!(vec.len(),10);assert!(vec.capacity() >=10);// ...but this may make the vector reallocatevec.push(11);assert_eq!(vec.len(),11);assert!(vec.capacity() >=11);// A vector of a zero-sized type will always over-allocate, since no// allocation is necessaryletvec_units = Vec::<()>::with_capacity(10);assert_eq!(vec_units.capacity(), usize::MAX);

Constructs a new, emptyVec<T> with at least the specified capacity.

The vector will be able to hold at leastcapacity elements withoutreallocating. This method is allowed to allocate for more elements thancapacity. Ifcapacity is zero, the vector will not allocate.

§Errors

Returns an error if the capacity exceedsisize::MAXbytes,or if the allocator reports allocation failure.

Creates aVec<T> directly from a pointer, a length, and a capacity.

§Safety

This is highly unsafe, due to the number of invariants that aren’tchecked:

• IfT is not a zero-sized type and the capacity is nonzero,ptr must havebeen allocated using the global allocator, such as via thealloc::allocfunction. IfT is a zero-sized type or the capacity is zero,ptr needonly be non-null and aligned.
• T needs to have the same alignment as whatptr was allocated with,if the pointer is required to be allocated.(T having a less strict alignment is not sufficient, the alignment reallyneeds to be equal to satisfy thedealloc requirement that memory must beallocated and deallocated with the same layout.)
• The size ofT times thecapacity (ie. the allocated size in bytes), ifnonzero, needs to be the same size as the pointer was allocated with.(Because similar to alignment,dealloc must be called with the samelayoutsize.)
• length needs to be less than or equal tocapacity.
• The firstlength values must be properly initialized values of typeT.
• capacity needs to be the capacity that the pointer was allocated with,if the pointer is required to be allocated.
• The allocated size in bytes must be no larger thanisize::MAX.See the safety documentation ofpointer::offset.

These requirements are always upheld by anyptr that has been allocatedviaVec<T>. Other allocation sources are allowed if the invariants areupheld.

Violating these may cause problems like corrupting the allocator’sinternal data structures. For example it is normallynot safeto build aVec<u8> from a pointer to a Cchar array with lengthsize_t, doing so is only safe if the array was initially allocated byaVec orString.It’s also not safe to build one from aVec<u16> and its length, becausethe allocator cares about the alignment, and these two types have differentalignments. The buffer was allocated with alignment 2 (foru16), but afterturning it into aVec<u8> it’ll be deallocated with alignment 1. To avoidthese issues, it is often preferable to do casting/transmuting usingslice::from_raw_parts instead.

The ownership ofptr is effectively transferred to theVec<T> which may then deallocate, reallocate or change thecontents of memory pointed to by the pointer at will. Ensurethat nothing else uses the pointer after calling thisfunction.

§Examples

usestd::ptr;letv =vec![1,2,3];// Deconstruct the vector into parts.let(p, len, cap) = v.into_raw_parts();unsafe{// Overwrite memory with 4, 5, 6foriin0..len {        ptr::write(p.add(i),4+ i);    }// Put everything back together into a Vecletrebuilt = Vec::from_raw_parts(p, len, cap);assert_eq!(rebuilt, [4,5,6]);}

Using memory that was allocated elsewhere:

usestd::alloc::{alloc, Layout};fnmain() {letlayout = Layout::array::<u32>(16).expect("overflow cannot happen");letvec =unsafe{letmem = alloc(layout).cast::<u32>();ifmem.is_null() {return;        }        mem.write(1_000_000);        Vec::from_raw_parts(mem,1,16)    };assert_eq!(vec,&[1_000_000]);assert_eq!(vec.capacity(),16);}

Creates aVec<T> directly from aNonNull pointer, a length, and a capacity.

§Safety

This is highly unsafe, due to the number of invariants that aren’tchecked:

• ptr must have been allocated using the global allocator, such as viathealloc::alloc function.
• T needs to have the same alignment as whatptr was allocated with.(T having a less strict alignment is not sufficient, the alignment reallyneeds to be equal to satisfy thedealloc requirement that memory must beallocated and deallocated with the same layout.)
• The size ofT times thecapacity (ie. the allocated size in bytes) needsto be the same size as the pointer was allocated with. (Because similar toalignment,dealloc must be called with the same layoutsize.)
• length needs to be less than or equal tocapacity.
• The firstlength values must be properly initialized values of typeT.
• capacity needs to be the capacity that the pointer was allocated with.
• The allocated size in bytes must be no larger thanisize::MAX.See the safety documentation ofpointer::offset.

These requirements are always upheld by anyptr that has been allocatedviaVec<T>. Other allocation sources are allowed if the invariants areupheld.

Violating these may cause problems like corrupting the allocator’sinternal data structures. For example it is normallynot safeto build aVec<u8> from a pointer to a Cchar array with lengthsize_t, doing so is only safe if the array was initially allocated byaVec orString.It’s also not safe to build one from aVec<u16> and its length, becausethe allocator cares about the alignment, and these two types have differentalignments. The buffer was allocated with alignment 2 (foru16), but afterturning it into aVec<u8> it’ll be deallocated with alignment 1. To avoidthese issues, it is often preferable to do casting/transmuting usingNonNull::slice_from_raw_parts instead.

The ownership ofptr is effectively transferred to theVec<T> which may then deallocate, reallocate or change thecontents of memory pointed to by the pointer at will. Ensurethat nothing else uses the pointer after calling thisfunction.

§Examples

#![feature(box_vec_non_null)]letv =vec![1,2,3];// Deconstruct the vector into parts.let(p, len, cap) = v.into_parts();unsafe{// Overwrite memory with 4, 5, 6foriin0..len {        p.add(i).write(4+ i);    }// Put everything back together into a Vecletrebuilt = Vec::from_parts(p, len, cap);assert_eq!(rebuilt, [4,5,6]);}

Using memory that was allocated elsewhere:

#![feature(box_vec_non_null)]usestd::alloc::{alloc, Layout};usestd::ptr::NonNull;fnmain() {letlayout = Layout::array::<u32>(16).expect("overflow cannot happen");letvec =unsafe{letSome(mem) = NonNull::new(alloc(layout).cast::<u32>())else{return;        };        mem.write(1_000_000);        Vec::from_parts(mem,1,16)    };assert_eq!(vec,&[1_000_000]);assert_eq!(vec.capacity(),16);}

Decomposes aVec<T> into its raw components:(pointer, length, capacity).

Returns the raw pointer to the underlying data, the length ofthe vector (in elements), and the allocated capacity of thedata (in elements). These are the same arguments in the sameorder as the arguments tofrom_raw_parts.

After calling this function, the caller is responsible for thememory previously managed by theVec. Most often, one doesthis by converting the raw pointer, length, and capacity backinto aVec with thefrom_raw_parts function; more generally,ifT is non-zero-sized and the capacity is nonzero, one may useany method that callsdealloc with a layout ofLayout::array::<T>(capacity); ifT is zero-sized or thecapacity is zero, nothing needs to be done.

§Examples

letv: Vec<i32> =vec![-1,0,1];let(ptr, len, cap) = v.into_raw_parts();letrebuilt =unsafe{// We can now make changes to the components, such as    // transmuting the raw pointer to a compatible type.letptr = ptras*mutu32;    Vec::from_raw_parts(ptr, len, cap)};assert_eq!(rebuilt, [4294967295,0,1]);

Decomposes aVec<T> into its raw components:(NonNull pointer, length, capacity).

Returns theNonNull pointer to the underlying data, the length ofthe vector (in elements), and the allocated capacity of thedata (in elements). These are the same arguments in the sameorder as the arguments tofrom_parts.

After calling this function, the caller is responsible for thememory previously managed by theVec. The only way to dothis is to convert theNonNull pointer, length, and capacity backinto aVec with thefrom_parts function, allowingthe destructor to perform the cleanup.

§Examples

#![feature(box_vec_non_null)]letv: Vec<i32> =vec![-1,0,1];let(ptr, len, cap) = v.into_parts();letrebuilt =unsafe{// We can now make changes to the components, such as    // transmuting the raw pointer to a compatible type.letptr = ptr.cast::<u32>();    Vec::from_parts(ptr, len, cap)};assert_eq!(rebuilt, [4294967295,0,1]);

Constructs a new, emptyVec<T, A>.

The vector will not allocate until elements are pushed onto it.

§Examples

#![feature(allocator_api)]usestd::alloc::System;letmutvec: Vec<i32,_> = Vec::new_in(System);

Constructs a new, emptyVec<T, A> with at least the specified capacitywith the provided allocator.

The vector will be able to hold at leastcapacity elements withoutreallocating. This method is allowed to allocate for more elements thancapacity. Ifcapacity is zero, the vector will not allocate.

It is important to note that although the returned vector has theminimumcapacity specified, the vector will have a zerolength. Foran explanation of the difference between length and capacity, seeCapacity and reallocation.

If it is important to know the exact allocated capacity of aVec,always use thecapacity method after construction.

ForVec<T, A> whereT is a zero-sized type, there will be no allocationand the capacity will always beusize::MAX.

§Panics

Panics if the new capacity exceedsisize::MAXbytes.

§Examples

#![feature(allocator_api)]usestd::alloc::System;letmutvec = Vec::with_capacity_in(10, System);// The vector contains no items, even though it has capacity for moreassert_eq!(vec.len(),0);assert!(vec.capacity() >=10);// These are all done without reallocating...foriin0..10{    vec.push(i);}assert_eq!(vec.len(),10);assert!(vec.capacity() >=10);// ...but this may make the vector reallocatevec.push(11);assert_eq!(vec.len(),11);assert!(vec.capacity() >=11);// A vector of a zero-sized type will always over-allocate, since no// allocation is necessaryletvec_units = Vec::<(), System>::with_capacity_in(10, System);assert_eq!(vec_units.capacity(), usize::MAX);

Constructs a new, emptyVec<T, A> with at least the specified capacitywith the provided allocator.

The vector will be able to hold at leastcapacity elements withoutreallocating. This method is allowed to allocate for more elements thancapacity. Ifcapacity is zero, the vector will not allocate.

§Errors

Returns an error if the capacity exceedsisize::MAXbytes,or if the allocator reports allocation failure.

Creates aVec<T, A> directly from a pointer, a length, a capacity,and an allocator.

§Safety

This is highly unsafe, due to the number of invariants that aren’tchecked:

• ptr must becurrently allocated via the given allocatoralloc.
• T needs to have the same alignment as whatptr was allocated with.(T having a less strict alignment is not sufficient, the alignment reallyneeds to be equal to satisfy thedealloc requirement that memory must beallocated and deallocated with the same layout.)
• The size ofT times thecapacity (ie. the allocated size in bytes) needsto be the same size as the pointer was allocated with. (Because similar toalignment,dealloc must be called with the same layoutsize.)
• length needs to be less than or equal tocapacity.
• The firstlength values must be properly initialized values of typeT.
• capacity needs tofit the layout size that the pointer was allocated with.
• The allocated size in bytes must be no larger thanisize::MAX.See the safety documentation ofpointer::offset.

These requirements are always upheld by anyptr that has been allocatedviaVec<T, A>. Other allocation sources are allowed if the invariants areupheld.

Violating these may cause problems like corrupting the allocator’sinternal data structures. For example it isnot safeto build aVec<u8> from a pointer to a Cchar array with lengthsize_t.It’s also not safe to build one from aVec<u16> and its length, becausethe allocator cares about the alignment, and these two types have differentalignments. The buffer was allocated with alignment 2 (foru16), but afterturning it into aVec<u8> it’ll be deallocated with alignment 1.

The ownership ofptr is effectively transferred to theVec<T> which may then deallocate, reallocate or change thecontents of memory pointed to by the pointer at will. Ensurethat nothing else uses the pointer after calling thisfunction.

§Examples

#![feature(allocator_api)]usestd::alloc::System;usestd::ptr;letmutv = Vec::with_capacity_in(3, System);v.push(1);v.push(2);v.push(3);// Deconstruct the vector into parts.let(p, len, cap, alloc) = v.into_raw_parts_with_alloc();unsafe{// Overwrite memory with 4, 5, 6foriin0..len {        ptr::write(p.add(i),4+ i);    }// Put everything back together into a Vecletrebuilt = Vec::from_raw_parts_in(p, len, cap, alloc.clone());assert_eq!(rebuilt, [4,5,6]);}

Using memory that was allocated elsewhere:

#![feature(allocator_api)]usestd::alloc::{AllocError, Allocator, Global, Layout};fnmain() {letlayout = Layout::array::<u32>(16).expect("overflow cannot happen");letvec =unsafe{letmem =matchGlobal.allocate(layout) {Ok(mem) => mem.cast::<u32>().as_ptr(),Err(AllocError) =>return,        };        mem.write(1_000_000);        Vec::from_raw_parts_in(mem,1,16, Global)    };assert_eq!(vec,&[1_000_000]);assert_eq!(vec.capacity(),16);}

Creates aVec<T, A> directly from aNonNull pointer, a length, a capacity,and an allocator.

§Safety

This is highly unsafe, due to the number of invariants that aren’tchecked:

• ptr must becurrently allocated via the given allocatoralloc.
• T needs to have the same alignment as whatptr was allocated with.(T having a less strict alignment is not sufficient, the alignment reallyneeds to be equal to satisfy thedealloc requirement that memory must beallocated and deallocated with the same layout.)
• The size ofT times thecapacity (ie. the allocated size in bytes) needsto be the same size as the pointer was allocated with. (Because similar toalignment,dealloc must be called with the same layoutsize.)
• length needs to be less than or equal tocapacity.
• The firstlength values must be properly initialized values of typeT.
• capacity needs tofit the layout size that the pointer was allocated with.
• The allocated size in bytes must be no larger thanisize::MAX.See the safety documentation ofpointer::offset.

These requirements are always upheld by anyptr that has been allocatedviaVec<T, A>. Other allocation sources are allowed if the invariants areupheld.

Violating these may cause problems like corrupting the allocator’sinternal data structures. For example it isnot safeto build aVec<u8> from a pointer to a Cchar array with lengthsize_t.It’s also not safe to build one from aVec<u16> and its length, becausethe allocator cares about the alignment, and these two types have differentalignments. The buffer was allocated with alignment 2 (foru16), but afterturning it into aVec<u8> it’ll be deallocated with alignment 1.

The ownership ofptr is effectively transferred to theVec<T> which may then deallocate, reallocate or change thecontents of memory pointed to by the pointer at will. Ensurethat nothing else uses the pointer after calling thisfunction.

§Examples

#![feature(allocator_api, box_vec_non_null)]usestd::alloc::System;letmutv = Vec::with_capacity_in(3, System);v.push(1);v.push(2);v.push(3);// Deconstruct the vector into parts.let(p, len, cap, alloc) = v.into_parts_with_alloc();unsafe{// Overwrite memory with 4, 5, 6foriin0..len {        p.add(i).write(4+ i);    }// Put everything back together into a Vecletrebuilt = Vec::from_parts_in(p, len, cap, alloc.clone());assert_eq!(rebuilt, [4,5,6]);}

Using memory that was allocated elsewhere:

#![feature(allocator_api, box_vec_non_null)]usestd::alloc::{AllocError, Allocator, Global, Layout};fnmain() {letlayout = Layout::array::<u32>(16).expect("overflow cannot happen");letvec =unsafe{letmem =matchGlobal.allocate(layout) {Ok(mem) => mem.cast::<u32>(),Err(AllocError) =>return,        };        mem.write(1_000_000);        Vec::from_parts_in(mem,1,16, Global)    };assert_eq!(vec,&[1_000_000]);assert_eq!(vec.capacity(),16);}

Decomposes aVec<T> into its raw components:(pointer, length, capacity, allocator).

Returns the raw pointer to the underlying data, the length of the vector (in elements),the allocated capacity of the data (in elements), and the allocator. These are the samearguments in the same order as the arguments tofrom_raw_parts_in.

After calling this function, the caller is responsible for thememory previously managed by theVec. The only way to dothis is to convert the raw pointer, length, and capacity backinto aVec with thefrom_raw_parts_in function, allowingthe destructor to perform the cleanup.

§Examples

#![feature(allocator_api)]usestd::alloc::System;letmutv: Vec<i32, System> = Vec::new_in(System);v.push(-1);v.push(0);v.push(1);let(ptr, len, cap, alloc) = v.into_raw_parts_with_alloc();letrebuilt =unsafe{// We can now make changes to the components, such as    // transmuting the raw pointer to a compatible type.letptr = ptras*mutu32;    Vec::from_raw_parts_in(ptr, len, cap, alloc)};assert_eq!(rebuilt, [4294967295,0,1]);

Decomposes aVec<T> into its raw components:(NonNull pointer, length, capacity, allocator).

Returns theNonNull pointer to the underlying data, the length of the vector (in elements),the allocated capacity of the data (in elements), and the allocator. These are the samearguments in the same order as the arguments tofrom_parts_in.

After calling this function, the caller is responsible for thememory previously managed by theVec. The only way to dothis is to convert theNonNull pointer, length, and capacity backinto aVec with thefrom_parts_in function, allowingthe destructor to perform the cleanup.

§Examples

#![feature(allocator_api, box_vec_non_null)]usestd::alloc::System;letmutv: Vec<i32, System> = Vec::new_in(System);v.push(-1);v.push(0);v.push(1);let(ptr, len, cap, alloc) = v.into_parts_with_alloc();letrebuilt =unsafe{// We can now make changes to the components, such as    // transmuting the raw pointer to a compatible type.letptr = ptr.cast::<u32>();    Vec::from_parts_in(ptr, len, cap, alloc)};assert_eq!(rebuilt, [4294967295,0,1]);

Returns the total number of elements the vector can hold withoutreallocating.

§Examples

letmutvec: Vec<i32> = Vec::with_capacity(10);vec.push(42);assert!(vec.capacity() >=10);

A vector with zero-sized elements will always have a capacity of usize::MAX:

#[derive(Clone)]structZeroSized;fnmain() {assert_eq!(std::mem::size_of::<ZeroSized>(),0);letv =vec![ZeroSized;0];assert_eq!(v.capacity(), usize::MAX);}

Reserves capacity for at leastadditional more elements to be insertedin the givenVec<T>. The collection may reserve more space tospeculatively avoid frequent reallocations. After callingreserve,capacity will be greater than or equal toself.len() + additional.Does nothing if capacity is already sufficient.

§Panics

Panics if the new capacity exceedsisize::MAXbytes.

§Examples

letmutvec =vec![1];vec.reserve(10);assert!(vec.capacity() >=11);

Reserves the minimum capacity for at leastadditional more elements tobe inserted in the givenVec<T>. Unlikereserve, this will notdeliberately over-allocate to speculatively avoid frequent allocations.After callingreserve_exact, capacity will be greater than or equal toself.len() + additional. Does nothing if the capacity is alreadysufficient.

Note that the allocator may give the collection more space than itrequests. Therefore, capacity can not be relied upon to be preciselyminimal. Preferreserve if future insertions are expected.

§Panics

Panics if the new capacity exceedsisize::MAXbytes.

§Examples

letmutvec =vec![1];vec.reserve_exact(10);assert!(vec.capacity() >=11);

Tries to reserve capacity for at leastadditional more elements to be insertedin the givenVec<T>. The collection may reserve more space to speculatively avoidfrequent reallocations. After callingtry_reserve, capacity will begreater than or equal toself.len() + additional if it returnsOk(()). Does nothing if capacity is already sufficient. This methodpreserves the contents even if an error occurs.

§Errors

If the capacity overflows, or the allocator reports a failure, then an erroris returned.

§Examples

usestd::collections::TryReserveError;fnprocess_data(data:&[u32]) ->Result<Vec<u32>, TryReserveError> {letmutoutput = Vec::new();// Pre-reserve the memory, exiting if we can'toutput.try_reserve(data.len())?;// Now we know this can't OOM in the middle of our complex workoutput.extend(data.iter().map(|&val| {        val *2+5// very complicated}));Ok(output)}

Tries to reserve the minimum capacity for at leastadditionalelements to be inserted in the givenVec<T>. Unliketry_reserve,this will not deliberately over-allocate to speculatively avoid frequentallocations. After callingtry_reserve_exact, capacity will be greaterthan or equal toself.len() + additional if it returnsOk(()).Does nothing if the capacity is already sufficient.

Note that the allocator may give the collection more space than itrequests. Therefore, capacity can not be relied upon to be preciselyminimal. Prefertry_reserve if future insertions are expected.

§Errors

If the capacity overflows, or the allocator reports a failure, then an erroris returned.

§Examples

usestd::collections::TryReserveError;fnprocess_data(data:&[u32]) ->Result<Vec<u32>, TryReserveError> {letmutoutput = Vec::new();// Pre-reserve the memory, exiting if we can'toutput.try_reserve_exact(data.len())?;// Now we know this can't OOM in the middle of our complex workoutput.extend(data.iter().map(|&val| {        val *2+5// very complicated}));Ok(output)}

Shrinks the capacity of the vector as much as possible.

The behavior of this method depends on the allocator, which may either shrink the vectorin-place or reallocate. The resulting vector might still have some excess capacity, just asis the case forwith_capacity. SeeAllocator::shrink for more details.

§Examples

letmutvec = Vec::with_capacity(10);vec.extend([1,2,3]);assert!(vec.capacity() >=10);vec.shrink_to_fit();assert!(vec.capacity() >=3);

Shrinks the capacity of the vector with a lower bound.

The capacity will remain at least as large as both the lengthand the supplied value.

If the current capacity is less than the lower limit, this is a no-op.

§Examples

letmutvec = Vec::with_capacity(10);vec.extend([1,2,3]);assert!(vec.capacity() >=10);vec.shrink_to(4);assert!(vec.capacity() >=4);vec.shrink_to(0);assert!(vec.capacity() >=3);

Converts the vector intoBox<[T]>.

Before doing the conversion, this method discards excess capacity likeshrink_to_fit.

§Examples

letv =vec![1,2,3];letslice = v.into_boxed_slice();

Any excess capacity is removed:

letmutvec = Vec::with_capacity(10);vec.extend([1,2,3]);assert!(vec.capacity() >=10);letslice = vec.into_boxed_slice();assert_eq!(slice.into_vec().capacity(),3);

Shortens the vector, keeping the firstlen elements and droppingthe rest.

Iflen is greater or equal to the vector’s current length, this hasno effect.

Thedrain method can emulatetruncate, but causes the excesselements to be returned instead of dropped.

Note that this method has no effect on the allocated capacityof the vector.

§Examples

Truncating a five element vector to two elements:

letmutvec =vec![1,2,3,4,5];vec.truncate(2);assert_eq!(vec, [1,2]);

No truncation occurs whenlen is greater than the vector’s currentlength:

letmutvec =vec![1,2,3];vec.truncate(8);assert_eq!(vec, [1,2,3]);

Truncating whenlen == 0 is equivalent to calling theclearmethod.

letmutvec =vec![1,2,3];vec.truncate(0);assert_eq!(vec, []);

Extracts a slice containing the entire vector.

Equivalent to&s[..].

§Examples

usestd::io::{self, Write};letbuffer =vec![1,2,3,5,8];io::sink().write(buffer.as_slice()).unwrap();

Extracts a mutable slice of the entire vector.

Equivalent to&mut s[..].

§Examples

usestd::io::{self, Read};letmutbuffer =vec![0;3];io::repeat(0b101).read_exact(buffer.as_mut_slice()).unwrap();

Returns a raw pointer to the vector’s buffer, or a dangling raw pointervalid for zero sized reads if the vector didn’t allocate.

The caller must ensure that the vector outlives the pointer thisfunction returns, or else it will end up dangling.Modifying the vector may cause its buffer to be reallocated,which would also make any pointers to it invalid.

The caller must also ensure that the memory the pointer (non-transitively) points tois never written to (except inside anUnsafeCell) using this pointer or any pointerderived from it. If you need to mutate the contents of the slice, useas_mut_ptr.

This method guarantees that for the purpose of the aliasing model, this methoddoes not materialize a reference to the underlying slice, and thus the returned pointerwill remain valid when mixed with other calls toas_ptr,as_mut_ptr,andas_non_null.Note that calling other methods that materialize mutable references to the slice,or mutable references to specific elements you are planning on accessing through this pointer,as well as writing to those elements, may still invalidate this pointer.See the second example below for how this guarantee can be used.

§Examples

letx =vec![1,2,4];letx_ptr = x.as_ptr();unsafe{foriin0..x.len() {assert_eq!(*x_ptr.add(i),1<< i);    }}

Due to the aliasing guarantee, the following code is legal:

unsafe{letmutv =vec![0,1,2];letptr1 = v.as_ptr();let _= ptr1.read();letptr2 = v.as_mut_ptr().offset(2);    ptr2.write(2);// Notably, the write to `ptr2` did *not* invalidate `ptr1`    // because it mutated a different element:let _= ptr1.read();}

Returns a raw mutable pointer to the vector’s buffer, or a danglingraw pointer valid for zero sized reads if the vector didn’t allocate.

The caller must ensure that the vector outlives the pointer thisfunction returns, or else it will end up dangling.Modifying the vector may cause its buffer to be reallocated,which would also make any pointers to it invalid.

This method guarantees that for the purpose of the aliasing model, this methoddoes not materialize a reference to the underlying slice, and thus the returned pointerwill remain valid when mixed with other calls toas_ptr,as_mut_ptr,andas_non_null.Note that calling other methods that materialize references to the slice,or references to specific elements you are planning on accessing through this pointer,may still invalidate this pointer.See the second example below for how this guarantee can be used.

The method also guarantees that, as long asT is not zero-sized and the capacity isnonzero, the pointer may be passed intodealloc with a layout ofLayout::array::<T>(capacity) in order to deallocate the backing memory. If this is done,be careful not to run the destructor of theVec, as dropping it will result indouble-frees. Wrapping theVec in aManuallyDrop is the typical way to achieve this.

§Examples

// Allocate vector big enough for 4 elements.letsize =4;letmutx: Vec<i32> = Vec::with_capacity(size);letx_ptr = x.as_mut_ptr();// Initialize elements via raw pointer writes, then set length.unsafe{foriin0..size {*x_ptr.add(i) = iasi32;    }    x.set_len(size);}assert_eq!(&*x,&[0,1,2,3]);

Due to the aliasing guarantee, the following code is legal:

unsafe{letmutv =vec![0];letptr1 = v.as_mut_ptr();    ptr1.write(1);letptr2 = v.as_mut_ptr();    ptr2.write(2);// Notably, the write to `ptr2` did *not* invalidate `ptr1`:ptr1.write(3);}

Deallocating a vector usingBox (which usesdealloc internally):

usestd::mem::{ManuallyDrop, MaybeUninit};letmutv = ManuallyDrop::new(vec![0,1,2]);letptr = v.as_mut_ptr();letcapacity = v.capacity();letslice_ptr:*mut[MaybeUninit<i32>] =    std::ptr::slice_from_raw_parts_mut(ptr.cast(), capacity);drop(unsafe{ Box::from_raw(slice_ptr) });

Returns aNonNull pointer to the vector’s buffer, or a danglingNonNull pointer valid for zero sized reads if the vector didn’t allocate.

The caller must ensure that the vector outlives the pointer thisfunction returns, or else it will end up dangling.Modifying the vector may cause its buffer to be reallocated,which would also make any pointers to it invalid.

This method guarantees that for the purpose of the aliasing model, this methoddoes not materialize a reference to the underlying slice, and thus the returned pointerwill remain valid when mixed with other calls toas_ptr,as_mut_ptr,andas_non_null.Note that calling other methods that materialize references to the slice,or references to specific elements you are planning on accessing through this pointer,may still invalidate this pointer.See the second example below for how this guarantee can be used.

§Examples

#![feature(box_vec_non_null)]// Allocate vector big enough for 4 elements.letsize =4;letmutx: Vec<i32> = Vec::with_capacity(size);letx_ptr = x.as_non_null();// Initialize elements via raw pointer writes, then set length.unsafe{foriin0..size {        x_ptr.add(i).write(iasi32);    }    x.set_len(size);}assert_eq!(&*x,&[0,1,2,3]);

Due to the aliasing guarantee, the following code is legal:

#![feature(box_vec_non_null)]unsafe{letmutv =vec![0];letptr1 = v.as_non_null();    ptr1.write(1);letptr2 = v.as_non_null();    ptr2.write(2);// Notably, the write to `ptr2` did *not* invalidate `ptr1`:ptr1.write(3);}

Returns a reference to the underlying allocator.

Forces the length of the vector tonew_len.

This is a low-level operation that maintains none of the normalinvariants of the type. Normally changing the length of a vectoris done using one of the safe operations instead, such astruncate,resize,extend, orclear.

§Safety

• new_len must be less than or equal tocapacity().
• The elements atold_len..new_len must be initialized.

§Examples

Seespare_capacity_mut() for an example with safeinitialization of capacity elements and use of this method.

set_len() can be useful for situations in which the vectoris serving as a buffer for other code, particularly over FFI:

pub fnget_dictionary(&self) ->Option<Vec<u8>> {// Per the FFI method's docs, "32768 bytes is always enough".letmutdict = Vec::with_capacity(32_768);letmutdict_length =0;// SAFETY: When `deflateGetDictionary` returns `Z_OK`, it holds that:    // 1. `dict_length` elements were initialized.    // 2. `dict_length` <= the capacity (32_768)    // which makes `set_len` safe to call.unsafe{// Make the FFI call...letr = deflateGetDictionary(self.strm, dict.as_mut_ptr(),&mutdict_length);ifr == Z_OK {// ...and update the length to what was initialized.dict.set_len(dict_length);Some(dict)        }else{None}    }}

While the following example is sound, there is a memory leak sincethe inner vectors were not freed prior to theset_len call:

letmutvec =vec![vec![1,0,0],vec![0,1,0],vec![0,0,1]];// SAFETY:// 1. `old_len..0` is empty so no elements need to be initialized.// 2. `0 <= capacity` always holds whatever `capacity` is.unsafe{    vec.set_len(0);}

Normally, here, one would useclear instead to correctly dropthe contents and thus not leak memory.

Removes an element from the vector and returns it.

The removed element is replaced by the last element of the vector.

This does not preserve ordering of the remaining elements, but isO(1).If you need to preserve the element order, useremove instead.

§Panics

Panics ifindex is out of bounds.

§Examples

letmutv =vec!["foo","bar","baz","qux"];assert_eq!(v.swap_remove(1),"bar");assert_eq!(v, ["foo","qux","baz"]);assert_eq!(v.swap_remove(0),"foo");assert_eq!(v, ["baz","qux"]);

Inserts an element at positionindex within the vector, shifting allelements after it to the right.

§Panics

Panics ifindex > len.

§Examples

letmutvec =vec!['a','b','c'];vec.insert(1,'d');assert_eq!(vec, ['a','d','b','c']);vec.insert(4,'e');assert_eq!(vec, ['a','d','b','c','e']);

§Time complexity

TakesO(Vec::len) time. All items after the insertion index must beshifted to the right. In the worst case, all elements are shifted whenthe insertion index is 0.

Inserts an element at positionindex within the vector, shifting allelements after it to the right, and returning a reference to the newelement.

§Panics

Panics ifindex > len.

§Examples

#![feature(push_mut)]letmutvec =vec![1,3,5,9];letx = vec.insert_mut(3,6);*x +=1;assert_eq!(vec, [1,3,5,7,9]);

§Time complexity

TakesO(Vec::len) time. All items after the insertion index must beshifted to the right. In the worst case, all elements are shifted whenthe insertion index is 0.

Removes and returns the element at positionindex within the vector,shifting all elements after it to the left.

Note: Because this shifts over the remaining elements, it has aworst-case performance ofO(n). If you don’t need the order of elementsto be preserved, useswap_remove instead. If you’d like to removeelements from the beginning of theVec, consider usingVecDeque::pop_front instead.

§Panics

Panics ifindex is out of bounds.

§Examples

letmutv =vec!['a','b','c'];assert_eq!(v.remove(1),'b');assert_eq!(v, ['a','c']);

Remove and return the element at positionindex within the vector,shifting all elements after it to the left, orNone if it does notexist.

Note: Because this shifts over the remaining elements, it has aworst-case performance ofO(n). If you’d like to removeelements from the beginning of theVec, consider usingVecDeque::pop_front instead.

§Examples

#![feature(vec_try_remove)]letmutv =vec![1,2,3];assert_eq!(v.try_remove(0),Some(1));assert_eq!(v.try_remove(2),None);

Retains only the elements specified by the predicate.

In other words, remove all elementse for whichf(&e) returnsfalse.This method operates in place, visiting each element exactly once in theoriginal order, and preserves the order of the retained elements.

§Examples

letmutvec =vec![1,2,3,4];vec.retain(|&x| x %2==0);assert_eq!(vec, [2,4]);

Because the elements are visited exactly once in the original order,external state may be used to decide which elements to keep.

letmutvec =vec![1,2,3,4,5];letkeep = [false,true,true,false,true];letmutiter = keep.iter();vec.retain(|_|*iter.next().unwrap());assert_eq!(vec, [2,3,5]);

Retains only the elements specified by the predicate, passing a mutable reference to it.

In other words, remove all elementse such thatf(&mut e) returnsfalse.This method operates in place, visiting each element exactly once in theoriginal order, and preserves the order of the retained elements.

§Examples

letmutvec =vec![1,2,3,4];vec.retain_mut(|x|if*x <=3{*x +=1;true}else{false});assert_eq!(vec, [2,3,4]);

Removes all but the first of consecutive elements in the vector that resolve to the samekey.

If the vector is sorted, this removes all duplicates.

§Examples

letmutvec =vec![10,20,21,30,20];vec.dedup_by_key(|i|*i /10);assert_eq!(vec, [10,20,30,20]);

Removes all but the first of consecutive elements in the vector satisfying a given equalityrelation.

Thesame_bucket function is passed references to two elements from the vector andmust determine if the elements compare equal. The elements are passed in opposite orderfrom their order in the slice, so ifsame_bucket(a, b) returnstrue,a is removed.

If the vector is sorted, this removes all duplicates.

§Examples

letmutvec =vec!["foo","bar","Bar","baz","bar"];vec.dedup_by(|a, b| a.eq_ignore_ascii_case(b));assert_eq!(vec, ["foo","bar","baz","bar"]);

Appends an element to the back of a collection.

§Panics

Panics if the new capacity exceedsisize::MAXbytes.

§Examples

letmutvec =vec![1,2];vec.push(3);assert_eq!(vec, [1,2,3]);

§Time complexity

Takes amortizedO(1) time. If the vector’s length would exceed itscapacity after the push,O(capacity) time is taken to copy thevector’s elements to a larger allocation. This expensive operation isoffset by thecapacityO(1) insertions it allows.

Appends an element and returns a reference to it if there is sufficient spare capacity,otherwise an error is returned with the element.

Unlikepush this method will not reallocate when there’s insufficient capacity.The caller should usereserve ortry_reserve to ensure that there is enough capacity.

§Examples

A manual, panic-free alternative toFromIterator:

#![feature(vec_push_within_capacity)]usestd::collections::TryReserveError;fnfrom_iter_fallible<T>(iter:implIterator<Item=T>) ->Result<Vec<T>, TryReserveError> {letmutvec = Vec::new();forvalueiniter {if letErr(value) = vec.push_within_capacity(value) {            vec.try_reserve(1)?;// this cannot fail, the previous line either returned or added at least 1 free slotlet _= vec.push_within_capacity(value);        }    }Ok(vec)}assert_eq!(from_iter_fallible(0..100),Ok(Vec::from_iter(0..100)));

§Time complexity

TakesO(1) time.

Appends an element to the back of a collection, returning a reference to it.

§Panics

Panics if the new capacity exceedsisize::MAXbytes.

§Examples

#![feature(push_mut)]letmutvec =vec![1,2];letlast = vec.push_mut(3);assert_eq!(*last,3);assert_eq!(vec, [1,2,3]);letlast = vec.push_mut(3);*last +=1;assert_eq!(vec, [1,2,3,4]);

§Time complexity

Takes amortizedO(1) time. If the vector’s length would exceed itscapacity after the push,O(capacity) time is taken to copy thevector’s elements to a larger allocation. This expensive operation isoffset by thecapacityO(1) insertions it allows.

Removes the last element from a vector and returns it, orNone if itis empty.

If you’d like to pop the first element, consider usingVecDeque::pop_front instead.

§Examples

letmutvec =vec![1,2,3];assert_eq!(vec.pop(),Some(3));assert_eq!(vec, [1,2]);

§Time complexity

TakesO(1) time.

Removes and returns the last element from a vector if the predicatereturnstrue, orNone if the predicate returns false or the vectoris empty (the predicate will not be called in that case).

§Examples

letmutvec =vec![1,2,3,4];letpred = |x:&muti32|*x %2==0;assert_eq!(vec.pop_if(pred),Some(4));assert_eq!(vec, [1,2,3]);assert_eq!(vec.pop_if(pred),None);

Returns a mutable reference to the last item in the vector, orNone if it is empty.

§Examples

Basic usage:

#![feature(vec_peek_mut)]letmutvec = Vec::new();assert!(vec.peek_mut().is_none());vec.push(1);vec.push(5);vec.push(2);assert_eq!(vec.last(),Some(&2));if letSome(mutval) = vec.peek_mut() {*val =0;}assert_eq!(vec.last(),Some(&0));

Moves all the elements ofother intoself, leavingother empty.

§Panics

Panics if the new capacity exceedsisize::MAXbytes.

§Examples

letmutvec =vec![1,2,3];letmutvec2 =vec![4,5,6];vec.append(&mutvec2);assert_eq!(vec, [1,2,3,4,5,6]);assert_eq!(vec2, []);

Removes the subslice indicated by the given range from the vector,returning a double-ended iterator over the removed subslice.

If the iterator is dropped before being fully consumed,it drops the remaining removed elements.

The returned iterator keeps a mutable borrow on the vector to optimizeits implementation.

§Panics

Panics if the range hasstart_bound > end_bound, or, if the range isbounded on either end and past the length of the vector.

§Leaking

If the returned iterator goes out of scope without being dropped (due tomem::forget, for example), the vector may have lost and leakedelements arbitrarily, including elements outside the range.

§Examples

letmutv =vec![1,2,3];letu: Vec<_> = v.drain(1..).collect();assert_eq!(v,&[1]);assert_eq!(u,&[2,3]);// A full range clears the vector, like `clear()` doesv.drain(..);assert_eq!(v,&[]);

Clears the vector, removing all values.

Note that this method has no effect on the allocated capacityof the vector.

§Examples

letmutv =vec![1,2,3];v.clear();assert!(v.is_empty());

Returns the number of elements in the vector, also referred toas its ‘length’.

§Examples

leta =vec![1,2,3];assert_eq!(a.len(),3);

Returnstrue if the vector contains no elements.

§Examples

letmutv = Vec::new();assert!(v.is_empty());v.push(1);assert!(!v.is_empty());

Splits the collection into two at the given index.

Returns a newly allocated vector containing the elements in the range[at, len). After the call, the original vector will be left containingthe elements[0, at) with its previous capacity unchanged.

• If you want to take ownership of the entire contents and capacity ofthe vector, seemem::take ormem::replace.
• If you don’t need the returned vector at all, seeVec::truncate.
• If you want to take ownership of an arbitrary subslice, or you don’tnecessarily want to store the removed items in a vector, seeVec::drain.

§Panics

Panics ifat > len.

§Examples

letmutvec =vec!['a','b','c'];letvec2 = vec.split_off(1);assert_eq!(vec, ['a']);assert_eq!(vec2, ['b','c']);

Resizes theVec in-place so thatlen is equal tonew_len.

Ifnew_len is greater thanlen, theVec is extended by thedifference, with each additional slot filled with the result ofcalling the closuref. The return values fromf will end upin theVec in the order they have been generated.

Ifnew_len is less thanlen, theVec is simply truncated.

This method uses a closure to create new values on every push. Ifyou’d ratherClone a given value, useVec::resize. If youwant to use theDefault trait to generate values, you canpassDefault::default as the second argument.

§Panics

Panics if the new capacity exceedsisize::MAXbytes.

§Examples

letmutvec =vec![1,2,3];vec.resize_with(5, Default::default);assert_eq!(vec, [1,2,3,0,0]);letmutvec =vec![];letmutp =1;vec.resize_with(4, || { p*=2; p });assert_eq!(vec, [2,4,8,16]);

Consumes and leaks theVec, returning a mutable reference to the contents,&'a mut [T].

Note that the typeT must outlive the chosen lifetime'a. If the typehas only static references, or none at all, then this may be chosen to be'static.

As of Rust 1.57, this method does not reallocate or shrink theVec,so the leaked allocation may include unused capacity that is not partof the returned slice.

This function is mainly useful for data that lives for the remainder ofthe program’s life. Dropping the returned reference will cause a memoryleak.

§Examples

Simple usage:

letx =vec![1,2,3];letstatic_ref:&'staticmut[usize] = x.leak();static_ref[0] +=1;assert_eq!(static_ref,&[2,2,3]);

Returns the remaining spare capacity of the vector as a slice ofMaybeUninit<T>.

The returned slice can be used to fill the vector with data (e.g. byreading from a file) before marking the data as initialized using theset_len method.

§Examples

// Allocate vector big enough for 10 elements.letmutv = Vec::with_capacity(10);// Fill in the first 3 elements.letuninit = v.spare_capacity_mut();uninit[0].write(0);uninit[1].write(1);uninit[2].write(2);// Mark the first 3 elements of the vector as being initialized.unsafe{    v.set_len(3);}assert_eq!(&v,&[0,1,2]);

Returns vector content as a slice ofT, along with the remaining sparecapacity of the vector as a slice ofMaybeUninit<T>.

The returned spare capacity slice can be used to fill the vector with data(e.g. by reading from a file) before marking the data as initialized usingtheset_len method.

Note that this is a low-level API, which should be used with care foroptimization purposes. If you need to append data to aVecyou can usepush,extend,extend_from_slice,extend_from_within,insert,append,resize orresize_with, depending on your exact needs.

§Examples

#![feature(vec_split_at_spare)]letmutv =vec![1,1,2];// Reserve additional space big enough for 10 elements.v.reserve(10);let(init, uninit) = v.split_at_spare_mut();letsum = init.iter().copied().sum::<u32>();// Fill in the next 4 elements.uninit[0].write(sum);uninit[1].write(sum *2);uninit[2].write(sum *3);uninit[3].write(sum *4);// Mark the 4 elements of the vector as being initialized.unsafe{letlen = v.len();    v.set_len(len +4);}assert_eq!(&v,&[1,1,2,4,8,12,16]);

Groups everyN elements in theVec<T> into chunks to produce aVec<[T; N]>, droppingelements in the remainder.N must be greater than zero.

If the capacity is not a multiple of the chunk size, the buffer will shrink down to thenearest multiple with a reallocation or deallocation.

This function can be used to reverseVec::into_flattened.

§Examples

#![feature(vec_into_chunks)]letvec =vec![0,1,2,3,4,5,6,7];assert_eq!(vec.into_chunks::<3>(), [[0,1,2], [3,4,5]]);letvec =vec![0,1,2,3];letchunks: Vec<[u8;10]> = vec.into_chunks();assert!(chunks.is_empty());letflat =vec![0;8*8*8];letreshaped: Vec<[[[u8;8];8];8]> = flat.into_chunks().into_chunks().into_chunks();assert_eq!(reshaped.len(),1);

This clears out thisVec and recycles the allocation into a newVec.The item type of the resultingVec needs to have the same size andalignment as the item type of the originalVec.

§Examples

#![feature(vec_recycle, transmutability)]leta: Vec<u8> =vec![0;100];letcapacity = a.capacity();letaddr = a.as_ptr().addr();letb: Vec<i8> = a.recycle();assert_eq!(b.len(),0);assert_eq!(b.capacity(), capacity);assert_eq!(b.as_ptr().addr(), addr);

TheRecyclable bound prevents this method from being called whenT andU have different sizes; e.g.:

#![feature(vec_recycle, transmutability)]letvec: Vec<[u8;2]> = Vec::new();let _: Vec<[u8;1]> = vec.recycle();

…or different alignments:

#![feature(vec_recycle, transmutability)]letvec: Vec<[u16;0]> = Vec::new();let _: Vec<[u8;0]> = vec.recycle();

However, due to temporary implementation limitations ofRecyclable,this method is not yet callable whenT orU are slices, trait objects,or other exotic types; e.g.:

#![feature(vec_recycle, transmutability)]letmutstorage: Vec<&[&str]> = Vec::new();forinputininputs {letmutbuffer: Vec<&str> = storage.recycle();    buffer.extend(input.split(" "));    process(&buffer);    storage = buffer.recycle();}

Resizes theVec in-place so thatlen is equal tonew_len.

Ifnew_len is greater thanlen, theVec is extended by thedifference, with each additional slot filled withvalue.Ifnew_len is less thanlen, theVec is simply truncated.

This method requiresT to implementClone,in order to be able to clone the passed value.If you need more flexibility (or want to rely onDefault instead ofClone), useVec::resize_with.If you only need to resize to a smaller size, useVec::truncate.

§Panics

Panics if the new capacity exceedsisize::MAXbytes.

§Examples

letmutvec =vec!["hello"];vec.resize(3,"world");assert_eq!(vec, ["hello","world","world"]);letmutvec =vec!['a','b','c','d'];vec.resize(2,'_');assert_eq!(vec, ['a','b']);

Clones and appends all elements in a slice to theVec.

Iterates over the sliceother, clones each element, and then appendsit to thisVec. Theother slice is traversed in-order.

Note that this function is the same asextend,except that it also works with slice elements that are Clone but not Copy.If Rust gets specialization this function may be deprecated.

§Panics

Panics if the new capacity exceedsisize::MAXbytes.

§Examples

letmutvec =vec![1];vec.extend_from_slice(&[2,3,4]);assert_eq!(vec, [1,2,3,4]);

Given a rangesrc, clones a slice of elements in that range and appends it to the end.

src must be a range that can form a valid subslice of theVec.

§Panics

Panics if starting index is greater than the end index, if the index isgreater than the length of the vector, or if the new capacity exceedsisize::MAXbytes.

§Examples

letmutcharacters =vec!['a','b','c','d','e'];characters.extend_from_within(2..);assert_eq!(characters, ['a','b','c','d','e','c','d','e']);letmutnumbers =vec![0,1,2,3,4];numbers.extend_from_within(..2);assert_eq!(numbers, [0,1,2,3,4,0,1]);letmutstrings =vec![String::from("hello"), String::from("world"), String::from("!")];strings.extend_from_within(1..=2);assert_eq!(strings, ["hello","world","!","world","!"]);

Takes aVec<[T; N]> and flattens it into aVec<T>.

§Panics

Panics if the length of the resulting vector would overflow ausize.

This is only possible when flattening a vector of arrays of zero-sizedtypes, and thus tends to be irrelevant in practice. Ifsize_of::<T>() > 0, this will never panic.

§Examples

letmutvec =vec![[1,2,3], [4,5,6], [7,8,9]];assert_eq!(vec.pop(),Some([7,8,9]));letmutflattened = vec.into_flattened();assert_eq!(flattened.pop(),Some(6));

Removes consecutive repeated elements in the vector according to thePartialEq trait implementation.

If the vector is sorted, this removes all duplicates.

§Examples

letmutvec =vec![1,2,2,3,2];vec.dedup();assert_eq!(vec, [1,2,3,2]);

Creates a splicing iterator that replaces the specified range in the vectorwith the givenreplace_with iterator and yields the removed items.replace_with does not need to be the same length asrange.

range is removed even if theSplice iterator is not consumed before it is dropped.

It is unspecified how many elements are removed from the vectorif theSplice value is leaked.

The input iteratorreplace_with is only consumed when theSplice value is dropped.

This is optimal if:

• The tail (elements in the vector afterrange) is empty,
• orreplace_with yields fewer or equal elements thanrange’s length
• or the lower bound of itssize_hint() is exact.

Otherwise, a temporary vector is allocated and the tail is moved twice.

§Panics

Panics if the range hasstart_bound > end_bound, or, if the range isbounded on either end and past the length of the vector.

§Examples

letmutv =vec![1,2,3,4];letnew = [7,8,9];letu: Vec<_> = v.splice(1..3, new).collect();assert_eq!(v, [1,7,8,9,4]);assert_eq!(u, [2,3]);

Usingsplice to insert new items into a vector efficiently at a specific positionindicated by an empty range:

letmutv =vec![1,5];letnew = [2,3,4];v.splice(1..1, new);assert_eq!(v, [1,2,3,4,5]);

Creates an iterator which uses a closure to determine if an element in the range should be removed.

If the closure returnstrue, the element is removed from the vectorand yielded. If the closure returnsfalse, or panics, the elementremains in the vector and will not be yielded.

Only elements that fall in the provided range are considered for extraction, but any elementsafter the range will still have to be moved if any element has been extracted.

If the returnedExtractIf is not exhausted, e.g. because it is dropped without iteratingor the iteration short-circuits, then the remaining elements will be retained.Useextract_if().for_each(drop) if you do not need the returned iterator,orretain_mut with a negated predicate if you also do not need to restrict the range.

Using this method is equivalent to the following code:

letmuti = range.start;letend_items = vec.len() - range.end;whilei < vec.len() - end_items {ifsome_predicate(&mutvec[i]) {letval = vec.remove(i);// your code here}else{        i +=1;    }}

Butextract_if is easier to use.extract_if is also more efficient,because it can backshift the elements of the array in bulk.

The iterator also lets you mutate the value of each element in theclosure, regardless of whether you choose to keep or remove it.

§Panics

Ifrange is out of bounds.

§Examples

Splitting a vector into even and odd values, reusing the original vector:

letmutnumbers =vec![1,2,3,4,5,6,8,9,11,13,14,15];letevens = numbers.extract_if(.., |x|*x %2==0).collect::<Vec<_>>();letodds = numbers;assert_eq!(evens,vec![2,4,6,8,14]);assert_eq!(odds,vec![1,3,5,9,11,13,15]);

Using the range argument to only process a part of the vector:

letmutitems =vec![0,0,0,0,0,0,0,1,2,1,2,1,2];letones = items.extract_if(7.., |x|*x ==1).collect::<Vec<_>>();assert_eq!(items,vec![0,0,0,0,0,0,0,2,2,2]);assert_eq!(ones.len(),3);