1.0.0[−][src]Struct std::vec::Vec
A contiguous growable array type, written Vec<T>
but pronounced 'vector'.
Examples
let mut vec = Vec::new(); vec.push(1); vec.push(2); assert_eq!(vec.len(), 2); assert_eq!(vec[0], 1); assert_eq!(vec.pop(), Some(2)); assert_eq!(vec.len(), 1); vec[0] = 7; assert_eq!(vec[0], 7); vec.extend([1, 2, 3].iter().cloned()); for x in &vec { println!("{}", x); } assert_eq!(vec, [7, 1, 2, 3]);Run
The vec!
macro is provided to make initialization more convenient:
let mut vec = vec![1, 2, 3]; vec.push(4); assert_eq!(vec, [1, 2, 3, 4]);Run
It can also initialize each element of a Vec<T>
with a given value.
This may be more efficient than performing allocation and initialization
in separate steps, especially when initializing a vector of zeros:
let vec = vec![0; 5]; assert_eq!(vec, [0, 0, 0, 0, 0]); // The following is equivalent, but potentially slower: let mut vec1 = Vec::with_capacity(5); vec1.resize(5, 0);Run
Use a Vec<T>
as an efficient stack:
let mut stack = Vec::new(); stack.push(1); stack.push(2); stack.push(3); while let Some(top) = stack.pop() { // Prints 3, 2, 1 println!("{}", top); }Run
Indexing
The Vec
type allows to access values by index, because it implements the
Index
trait. An example will be more explicit:
let v = vec![0, 2, 4, 6]; println!("{}", v[1]); // it will display '2'Run
However be careful: if you try to access an index which isn't in the Vec
,
your software will panic! You cannot do this:
let v = vec![0, 2, 4, 6]; println!("{}", v[6]); // it will panic!Run
In conclusion: always check if the index you want to get really exists before doing it.
Slicing
A Vec
can be mutable. Slices, on the other hand, are read-only objects.
To get a slice, use &
. Example:
fn read_slice(slice: &[usize]) { // ... } let v = vec![0, 1]; read_slice(&v); // ... and that's all! // you can also do it like this: let x : &[usize] = &v;Run
In Rust, it's more common to pass slices as arguments rather than vectors
when you just want to provide a read access. The same goes for String
and
&str
.
Capacity and reallocation
The capacity of a vector is the amount of space allocated for any future elements that will be added onto the vector. This is not to be confused with the length of a vector, which specifies the number of actual elements within the vector. If a vector's length exceeds its capacity, its capacity will automatically be increased, but its elements will have to be reallocated.
For example, a vector with capacity 10 and length 0 would be an empty vector
with space for 10 more elements. Pushing 10 or fewer elements onto the
vector will not change its capacity or cause reallocation to occur. However,
if the vector's length is increased to 11, it will have to reallocate, which
can be slow. For this reason, it is recommended to use Vec::with_capacity
whenever possible to specify how big the vector is expected to get.
Guarantees
Due to its incredibly fundamental nature, Vec
makes a lot of guarantees
about its design. This ensures that it's as low-overhead as possible in
the general case, and can be correctly manipulated in primitive ways
by unsafe code. Note that these guarantees refer to an unqualified Vec<T>
.
If additional type parameters are added (e.g., to support custom allocators),
overriding their defaults may change the behavior.
Most fundamentally, Vec
is and always will be a (pointer, capacity, length)
triplet. No more, no less. The order of these fields is completely
unspecified, and you should use the appropriate methods to modify these.
The pointer will never be null, so this type is null-pointer-optimized.
However, the pointer may not actually point to allocated memory. In particular,
if you construct a Vec
with capacity 0 via Vec::new
, vec![]
,
Vec::with_capacity(0)
, or by calling shrink_to_fit
on an empty Vec, it will not allocate memory. Similarly, if you store zero-sized
types inside a Vec
, it will not allocate space for them. Note that in this case
the Vec
may not report a capacity
of 0. Vec
will allocate if and only
if mem::size_of::<T>
() * capacity() > 0
. In general, Vec
's allocation
details are very subtle — if you intend to allocate memory using a Vec
and use it for something else (either to pass to unsafe code, or to build your
own memory-backed collection), be sure to deallocate this memory by using
from_raw_parts
to recover the Vec
and then dropping it.
If a Vec
has allocated memory, then the memory it points to is on the heap
(as defined by the allocator Rust is configured to use by default), and its
pointer points to len
initialized, contiguous elements in order (what
you would see if you coerced it to a slice), followed by capacity
-
len
logically uninitialized, contiguous elements.
Vec
will never perform a "small optimization" where elements are actually
stored on the stack for two reasons:
-
It would make it more difficult for unsafe code to correctly manipulate a
Vec
. The contents of aVec
wouldn't have a stable address if it were only moved, and it would be more difficult to determine if aVec
had actually allocated memory. -
It would penalize the general case, incurring an additional branch on every access.
Vec
will never automatically shrink itself, even if completely empty. This
ensures no unnecessary allocations or deallocations occur. Emptying a Vec
and then filling it back up to the same len
should incur no calls to
the allocator. If you wish to free up unused memory, use
shrink_to_fit
.
push
and insert
will never (re)allocate if the reported capacity is
sufficient. push
and insert
will (re)allocate if
len
==
capacity
. That is, the reported capacity is completely
accurate, and can be relied on. It can even be used to manually free the memory
allocated by a Vec
if desired. Bulk insertion methods may reallocate, even
when not necessary.
Vec
does not guarantee any particular growth strategy when reallocating
when full, nor when reserve
is called. The current strategy is basic
and it may prove desirable to use a non-constant growth factor. Whatever
strategy is used will of course guarantee O(1)
amortized push
.
vec![x; n]
, vec![a, b, c, d]
, and
Vec::with_capacity(n)
, will all produce a Vec
with exactly the requested capacity. If len
==
capacity
,
(as is the case for the vec!
macro), then a Vec<T>
can be converted to
and from a Box<[T]>
without reallocating or moving the elements.
Vec
will not specifically overwrite any data that is removed from it,
but also won't specifically preserve it. Its uninitialized memory is
scratch space that it may use however it wants. It will generally just do
whatever is most efficient or otherwise easy to implement. Do not rely on
removed data to be erased for security purposes. Even if you drop a Vec
, its
buffer may simply be reused by another Vec
. Even if you zero a Vec
's memory
first, that may not actually happen because the optimizer does not consider
this a side-effect that must be preserved. There is one case which we will
not break, however: using unsafe
code to write to the excess capacity,
and then increasing the length to match, is always valid.
Vec
does not currently guarantee the order in which elements are dropped.
The order has changed in the past and may change again.
Methods
impl<T> Vec<T>
[src]
pub const fn new() -> Vec<T>
[src]
Constructs a new, empty Vec<T>
.
The vector will not allocate until elements are pushed onto it.
Examples
let mut vec: Vec<i32> = Vec::new();Run
pub fn with_capacity(capacity: usize) -> Vec<T>
[src]
Constructs a new, empty Vec<T>
with the specified capacity.
The vector will be able to hold exactly capacity
elements without
reallocating. If capacity
is 0, the vector will not allocate.
It is important to note that although the returned vector has the capacity specified, the vector will have a zero length. For an explanation of the difference between length and capacity, see Capacity and reallocation.
Examples
let mut vec = Vec::with_capacity(10); // The vector contains no items, even though it has capacity for more assert_eq!(vec.len(), 0); // These are all done without reallocating... for i in 0..10 { vec.push(i); } // ...but this may make the vector reallocate vec.push(11);Run
pub unsafe fn from_raw_parts(
ptr: *mut T,
length: usize,
capacity: usize
) -> Vec<T>
[src]
ptr: *mut T,
length: usize,
capacity: usize
) -> Vec<T>
Creates a Vec<T>
directly from the raw components of another vector.
Safety
This is highly unsafe, due to the number of invariants that aren't checked:
ptr
needs to have been previously allocated viaString
/Vec<T>
(at least, it's highly likely to be incorrect if it wasn't).ptr
'sT
needs to have the same size and alignment as it was allocated with.length
needs to be less than or equal tocapacity
.capacity
needs to be the capacity that the pointer was allocated with.
Violating these may cause problems like corrupting the allocator's
internal data structures. For example it is not safe
to build a Vec<u8>
from a pointer to a C char
array and a size_t
.
The ownership of ptr
is effectively transferred to the
Vec<T>
which may then deallocate, reallocate or change the
contents of memory pointed to by the pointer at will. Ensure
that nothing else uses the pointer after calling this
function.
Examples
use std::ptr; use std::mem; fn main() { let mut v = vec![1, 2, 3]; // Pull out the various important pieces of information about `v` let p = v.as_mut_ptr(); let len = v.len(); let cap = v.capacity(); unsafe { // Cast `v` into the void: no destructor run, so we are in // complete control of the allocation to which `p` points. mem::forget(v); // Overwrite memory with 4, 5, 6 for i in 0..len as isize { ptr::write(p.offset(i), 4 + i); } // Put everything back together into a Vec let rebuilt = Vec::from_raw_parts(p, len, cap); assert_eq!(rebuilt, [4, 5, 6]); } }Run
pub fn capacity(&self) -> usize
[src]
Returns the number of elements the vector can hold without reallocating.
Examples
let vec: Vec<i32> = Vec::with_capacity(10); assert_eq!(vec.capacity(), 10);Run
pub fn reserve(&mut self, additional: usize)
[src]
Reserves capacity for at least additional
more elements to be inserted
in the given Vec<T>
. The collection may reserve more space to avoid
frequent reallocations. After calling reserve
, capacity will be
greater than or equal to self.len() + additional
. Does nothing if
capacity is already sufficient.
Panics
Panics if the new capacity overflows usize
.
Examples
let mut vec = vec![1]; vec.reserve(10); assert!(vec.capacity() >= 11);Run
pub fn reserve_exact(&mut self, additional: usize)
[src]
Reserves the minimum capacity for exactly additional
more elements to
be inserted in the given Vec<T>
. After calling reserve_exact
,
capacity will be greater than or equal to self.len() + additional
.
Does nothing if the capacity is already sufficient.
Note that the allocator may give the collection more space than it
requests. Therefore, capacity can not be relied upon to be precisely
minimal. Prefer reserve
if future insertions are expected.
Panics
Panics if the new capacity overflows usize
.
Examples
let mut vec = vec![1]; vec.reserve_exact(10); assert!(vec.capacity() >= 11);Run
pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>
[src]
🔬 This is a nightly-only experimental API. (try_reserve
#48043)
new API
Tries to reserve capacity for at least additional
more elements to be inserted
in the given Vec<T>
. The collection may reserve more space to avoid
frequent reallocations. After calling reserve
, capacity will be
greater than or equal to self.len() + additional
. Does nothing if
capacity is already sufficient.
Errors
If the capacity overflows, or the allocator reports a failure, then an error is returned.
Examples
#![feature(try_reserve)] use std::collections::TryReserveError; fn process_data(data: &[u32]) -> Result<Vec<u32>, TryReserveError> { let mut output = Vec::new(); // Pre-reserve the memory, exiting if we can't output.try_reserve(data.len())?; // Now we know this can't OOM in the middle of our complex work output.extend(data.iter().map(|&val| { val * 2 + 5 // very complicated })); Ok(output) }Run
pub fn try_reserve_exact(
&mut self,
additional: usize
) -> Result<(), TryReserveError>
[src]
&mut self,
additional: usize
) -> Result<(), TryReserveError>
🔬 This is a nightly-only experimental API. (try_reserve
#48043)
new API
Tries to reserves the minimum capacity for exactly additional
more elements to
be inserted in the given Vec<T>
. After calling reserve_exact
,
capacity will be greater than or equal to self.len() + additional
.
Does nothing if the capacity is already sufficient.
Note that the allocator may give the collection more space than it
requests. Therefore, capacity can not be relied upon to be precisely
minimal. Prefer reserve
if future insertions are expected.
Errors
If the capacity overflows, or the allocator reports a failure, then an error is returned.
Examples
#![feature(try_reserve)] use std::collections::TryReserveError; fn process_data(data: &[u32]) -> Result<Vec<u32>, TryReserveError> { let mut output = Vec::new(); // Pre-reserve the memory, exiting if we can't output.try_reserve(data.len())?; // Now we know this can't OOM in the middle of our complex work output.extend(data.iter().map(|&val| { val * 2 + 5 // very complicated })); Ok(output) }Run
pub fn shrink_to_fit(&mut self)
[src]
Shrinks the capacity of the vector as much as possible.
It will drop down as close as possible to the length but the allocator may still inform the vector that there is space for a few more elements.
Examples
let mut vec = Vec::with_capacity(10); vec.extend([1, 2, 3].iter().cloned()); assert_eq!(vec.capacity(), 10); vec.shrink_to_fit(); assert!(vec.capacity() >= 3);Run
pub fn shrink_to(&mut self, min_capacity: usize)
[src]
🔬 This is a nightly-only experimental API. (shrink_to
#56431)
new API
Shrinks the capacity of the vector with a lower bound.
The capacity will remain at least as large as both the length and the supplied value.
Panics if the current capacity is smaller than the supplied minimum capacity.
Examples
#![feature(shrink_to)] let mut vec = Vec::with_capacity(10); vec.extend([1, 2, 3].iter().cloned()); assert_eq!(vec.capacity(), 10); vec.shrink_to(4); assert!(vec.capacity() >= 4); vec.shrink_to(0); assert!(vec.capacity() >= 3);Run
ⓘImportant traits for Box<I>pub fn into_boxed_slice(self) -> Box<[T]>
[src]
Converts the vector into Box<[T]>
.
Note that this will drop any excess capacity.
Examples
let v = vec![1, 2, 3]; let slice = v.into_boxed_slice();Run
Any excess capacity is removed:
let mut vec = Vec::with_capacity(10); vec.extend([1, 2, 3].iter().cloned()); assert_eq!(vec.capacity(), 10); let slice = vec.into_boxed_slice(); assert_eq!(slice.into_vec().capacity(), 3);Run
pub fn truncate(&mut self, len: usize)
[src]
Shortens the vector, keeping the first len
elements and dropping
the rest.
If len
is greater than the vector's current length, this has no
effect.
The drain
method can emulate truncate
, but causes the excess
elements to be returned instead of dropped.
Note that this method has no effect on the allocated capacity of the vector.
Examples
Truncating a five element vector to two elements:
let mut vec = vec![1, 2, 3, 4, 5]; vec.truncate(2); assert_eq!(vec, [1, 2]);Run
No truncation occurs when len
is greater than the vector's current
length:
let mut vec = vec![1, 2, 3]; vec.truncate(8); assert_eq!(vec, [1, 2, 3]);Run
Truncating when len == 0
is equivalent to calling the clear
method.
let mut vec = vec![1, 2, 3]; vec.truncate(0); assert_eq!(vec, []);Run
pub fn as_slice(&self) -> &[T]
1.7.0[src]
Extracts a slice containing the entire vector.
Equivalent to &s[..]
.
Examples
use std::io::{self, Write}; let buffer = vec![1, 2, 3, 5, 8]; io::sink().write(buffer.as_slice()).unwrap();Run
pub fn as_mut_slice(&mut self) -> &mut [T]
1.7.0[src]
Extracts a mutable slice of the entire vector.
Equivalent to &mut s[..]
.
Examples
use std::io::{self, Read}; let mut buffer = vec![0; 3]; io::repeat(0b101).read_exact(buffer.as_mut_slice()).unwrap();Run
pub fn as_ptr(&self) -> *const T
1.37.0[src]
Returns a raw pointer to the vector's buffer.
The caller must ensure that the vector outlives the pointer this function returns, or else it will end up pointing to garbage. 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 to
is never written to (except inside an UnsafeCell
) using this pointer or any pointer
derived from it. If you need to mutate the contents of the slice, use as_mut_ptr
.
Examples
let x = vec![1, 2, 4]; let x_ptr = x.as_ptr(); unsafe { for i in 0..x.len() { assert_eq!(*x_ptr.add(i), 1 << i); } }Run
pub fn as_mut_ptr(&mut self) -> *mut T
1.37.0[src]
Returns an unsafe mutable pointer to the vector's buffer.
The caller must ensure that the vector outlives the pointer this function returns, or else it will end up pointing to garbage. Modifying the vector may cause its buffer to be reallocated, which would also make any pointers to it invalid.
Examples
// Allocate vector big enough for 4 elements. let size = 4; let mut x: Vec<i32> = Vec::with_capacity(size); let x_ptr = x.as_mut_ptr(); // Initialize elements via raw pointer writes, then set length. unsafe { for i in 0..size { *x_ptr.add(i) = i as i32; } x.set_len(size); } assert_eq!(&*x, &[0,1,2,3]);Run
pub unsafe fn set_len(&mut self, new_len: usize)
[src]
Forces the length of the vector to new_len
.
This is a low-level operation that maintains none of the normal
invariants of the type. Normally changing the length of a vector
is done using one of the safe operations instead, such as
truncate
, resize
, extend
, or clear
.
Safety
new_len
must be less than or equal tocapacity()
.- The elements at
old_len..new_len
must be initialized.
Examples
This method can be useful for situations in which the vector is serving as a buffer for other code, particularly over FFI:
pub fn get_dictionary(&self) -> Option<Vec<u8>> { // Per the FFI method's docs, "32768 bytes is always enough". let mut dict = Vec::with_capacity(32_768); let mut dict_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... let r = deflateGetDictionary(self.strm, dict.as_mut_ptr(), &mut dict_length); if r == Z_OK { // ...and update the length to what was initialized. dict.set_len(dict_length); Some(dict) } else { None } } }Run
While the following example is sound, there is a memory leak since
the inner vectors were not freed prior to the set_len
call:
let mut vec = 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); }Run
Normally, here, one would use clear
instead to correctly drop
the contents and thus not leak memory.
pub fn swap_remove(&mut self, index: usize) -> T
[src]
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, but is O(1).
Panics
Panics if index
is out of bounds.
Examples
let mut v = 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"]);Run
pub fn insert(&mut self, index: usize, element: T)
[src]
Inserts an element at position index
within the vector, shifting all
elements after it to the right.
Panics
Panics if index > len
.
Examples
let mut vec = vec![1, 2, 3]; vec.insert(1, 4); assert_eq!(vec, [1, 4, 2, 3]); vec.insert(4, 5); assert_eq!(vec, [1, 4, 2, 3, 5]);Run
pub fn remove(&mut self, index: usize) -> T
[src]
Removes and returns the element at position index
within the vector,
shifting all elements after it to the left.
Panics
Panics if index
is out of bounds.
Examples
let mut v = vec![1, 2, 3]; assert_eq!(v.remove(1), 2); assert_eq!(v, [1, 3]);Run
pub fn retain<F>(&mut self, f: F) where
F: FnMut(&T) -> bool,
[src]
F: FnMut(&T) -> bool,
Retains only the elements specified by the predicate.
In other words, remove all elements e
such that f(&e)
returns false
.
This method operates in place, visiting each element exactly once in the
original order, and preserves the order of the retained elements.
Examples
let mut vec = vec![1, 2, 3, 4]; vec.retain(|&x| x%2 == 0); assert_eq!(vec, [2, 4]);Run
The exact order may be useful for tracking external state, like an index.
let mut vec = vec![1, 2, 3, 4, 5]; let keep = [false, true, true, false, true]; let mut i = 0; vec.retain(|_| (keep[i], i += 1).0); assert_eq!(vec, [2, 3, 5]);Run
pub fn dedup_by_key<F, K>(&mut self, key: F) where
F: FnMut(&mut T) -> K,
K: PartialEq<K>,
1.16.0[src]
F: FnMut(&mut T) -> K,
K: PartialEq<K>,
Removes all but the first of consecutive elements in the vector that resolve to the same key.
If the vector is sorted, this removes all duplicates.
Examples
let mut vec = vec![10, 20, 21, 30, 20]; vec.dedup_by_key(|i| *i / 10); assert_eq!(vec, [10, 20, 30, 20]);Run
pub fn dedup_by<F>(&mut self, same_bucket: F) where
F: FnMut(&mut T, &mut T) -> bool,
1.16.0[src]
F: FnMut(&mut T, &mut T) -> bool,
Removes all but the first of consecutive elements in the vector satisfying a given equality relation.
The same_bucket
function is passed references to two elements from the vector and
must determine if the elements compare equal. The elements are passed in opposite order
from their order in the slice, so if same_bucket(a, b)
returns true
, a
is removed.
If the vector is sorted, this removes all duplicates.
Examples
let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"]; vec.dedup_by(|a, b| a.eq_ignore_ascii_case(b)); assert_eq!(vec, ["foo", "bar", "baz", "bar"]);Run
pub fn push(&mut self, value: T)
[src]
Appends an element to the back of a collection.
Panics
Panics if the number of elements in the vector overflows a usize
.
Examples
let mut vec = vec![1, 2]; vec.push(3); assert_eq!(vec, [1, 2, 3]);Run
pub fn pop(&mut self) -> Option<T>
[src]
Removes the last element from a vector and returns it, or None
if it
is empty.
Examples
let mut vec = vec![1, 2, 3]; assert_eq!(vec.pop(), Some(3)); assert_eq!(vec, [1, 2]);Run
pub fn append(&mut self, other: &mut Vec<T>)
1.4.0[src]
Moves all the elements of other
into Self
, leaving other
empty.
Panics
Panics if the number of elements in the vector overflows a usize
.
Examples
let mut vec = vec![1, 2, 3]; let mut vec2 = vec![4, 5, 6]; vec.append(&mut vec2); assert_eq!(vec, [1, 2, 3, 4, 5, 6]); assert_eq!(vec2, []);Run
ⓘImportant traits for Drain<'_, T>pub fn drain<R>(&mut self, range: R) -> Drain<T> where
R: RangeBounds<usize>,
1.6.0[src]
R: RangeBounds<usize>,
Creates a draining iterator that removes the specified range in the vector and yields the removed items.
Note 1: The element range is removed even if the iterator is only partially consumed or not consumed at all.
Note 2: It is unspecified how many elements are removed from the vector
if the Drain
value is leaked.
Panics
Panics if the starting point is greater than the end point or if the end point is greater than the length of the vector.
Examples
let mut v = vec![1, 2, 3]; let u: Vec<_> = v.drain(1..).collect(); assert_eq!(v, &[1]); assert_eq!(u, &[2, 3]); // A full range clears the vector v.drain(..); assert_eq!(v, &[]);Run
pub fn clear(&mut self)
[src]
Clears the vector, removing all values.
Note that this method has no effect on the allocated capacity of the vector.
Examples
let mut v = vec![1, 2, 3]; v.clear(); assert!(v.is_empty());Run
pub fn len(&self) -> usize
[src]
Returns the number of elements in the vector, also referred to as its 'length'.
Examples
let a = vec![1, 2, 3]; assert_eq!(a.len(), 3);Run
pub fn is_empty(&self) -> bool
[src]
Returns true
if the vector contains no elements.
Examples
let mut v = Vec::new(); assert!(v.is_empty()); v.push(1); assert!(!v.is_empty());Run
pub fn split_off(&mut self, at: usize) -> Vec<T>
1.4.0[src]
Splits the collection into two at the given index.
Returns a newly allocated Self
. self
contains elements [0, at)
,
and the returned Self
contains elements [at, len)
.
Note that the capacity of self
does not change.
Panics
Panics if at > len
.
Examples
let mut vec = vec![1,2,3]; let vec2 = vec.split_off(1); assert_eq!(vec, [1]); assert_eq!(vec2, [2, 3]);Run
pub fn resize_with<F>(&mut self, new_len: usize, f: F) where
F: FnMut() -> T,
1.33.0[src]
F: FnMut() -> T,
Resizes the Vec
in-place so that len
is equal to new_len
.
If new_len
is greater than len
, the Vec
is extended by the
difference, with each additional slot filled with the result of
calling the closure f
. The return values from f
will end up
in the Vec
in the order they have been generated.
If new_len
is less than len
, the Vec
is simply truncated.
This method uses a closure to create new values on every push. If
you'd rather Clone
a given value, use resize
. If you want
to use the Default
trait to generate values, you can pass
Default::default()
as the second argument.
Examples
let mut vec = vec![1, 2, 3]; vec.resize_with(5, Default::default); assert_eq!(vec, [1, 2, 3, 0, 0]); let mut vec = vec![]; let mut p = 1; vec.resize_with(4, || { p *= 2; p }); assert_eq!(vec, [2, 4, 8, 16]);Run
pub fn leak<'a>(vec: Vec<T>) -> &'a mut [T] where
T: 'a,
[src]
T: 'a,
Consumes and leaks the Vec
, returning a mutable reference to the contents,
&'a mut [T]
. Note that the type T
must outlive the chosen lifetime
'a
. If the type has only static references, or none at all, then this
may be chosen to be 'static
.
This function is similar to the leak
function on Box
.
This function is mainly useful for data that lives for the remainder of the program's life. Dropping the returned reference will cause a memory leak.
Examples
Simple usage:
#![feature(vec_leak)] fn main() { let x = vec![1, 2, 3]; let static_ref: &'static mut [usize] = Vec::leak(x); static_ref[0] += 1; assert_eq!(static_ref, &[2, 2, 3]); }Run
impl<T> Vec<T> where
T: Clone,
[src]
T: Clone,
pub fn resize(&mut self, new_len: usize, value: T)
1.5.0[src]
Resizes the Vec
in-place so that len
is equal to new_len
.
If new_len
is greater than len
, the Vec
is extended by the
difference, with each additional slot filled with value
.
If new_len
is less than len
, the Vec
is simply truncated.
This method requires Clone
to be able clone the passed value. If
you need more flexibility (or want to rely on Default
instead of
Clone
), use resize_with
.
Examples
let mut vec = vec!["hello"]; vec.resize(3, "world"); assert_eq!(vec, ["hello", "world", "world"]); let mut vec = vec![1, 2, 3, 4]; vec.resize(2, 0); assert_eq!(vec, [1, 2]);Run
pub fn extend_from_slice(&mut self, other: &[T])
1.6.0[src]
Clones and appends all elements in a slice to the Vec
.
Iterates over the slice other
, clones each element, and then appends
it to this Vec
. The other
vector is traversed in-order.
Note that this function is same as extend
except that it is
specialized to work with slices instead. If and when Rust gets
specialization this function will likely be deprecated (but still
available).
Examples
let mut vec = vec![1]; vec.extend_from_slice(&[2, 3, 4]); assert_eq!(vec, [1, 2, 3, 4]);Run
impl<T> Vec<T> where
T: Default,
[src]
T: Default,
pub fn resize_default(&mut self, new_len: usize)
[src]
This is moving towards being removed in favor of .resize_with(Default::default)
. If you disagree, please comment in the tracking issue.
Resizes the Vec
in-place so that len
is equal to new_len
.
If new_len
is greater than len
, the Vec
is extended by the
difference, with each additional slot filled with Default::default()
.
If new_len
is less than len
, the Vec
is simply truncated.
This method uses Default
to create new values on every push. If
you'd rather Clone
a given value, use resize
.
Examples
#![feature(vec_resize_default)] let mut vec = vec![1, 2, 3]; vec.resize_default(5); assert_eq!(vec, [1, 2, 3, 0, 0]); let mut vec = vec![1, 2, 3, 4]; vec.resize_default(2); assert_eq!(vec, [1, 2]);Run
impl<T> Vec<T> where
T: PartialEq<T>,
[src]
T: PartialEq<T>,
pub fn dedup(&mut self)
[src]
Removes consecutive repeated elements in the vector according to the
PartialEq
trait implementation.
If the vector is sorted, this removes all duplicates.
Examples
let mut vec = vec![1, 2, 2, 3, 2]; vec.dedup(); assert_eq!(vec, [1, 2, 3, 2]);Run
pub fn remove_item(&mut self, item: &T) -> Option<T>
[src]
🔬 This is a nightly-only experimental API. (vec_remove_item
#40062)
recently added
impl<T> Vec<T>
[src]
ⓘImportant traits for Splice<'_, I>pub fn splice<R, I>(
&mut self,
range: R,
replace_with: I
) -> Splice<<I as IntoIterator>::IntoIter> where
I: IntoIterator<Item = T>,
R: RangeBounds<usize>,
1.21.0[src]
&mut self,
range: R,
replace_with: I
) -> Splice<<I as IntoIterator>::IntoIter> where
I: IntoIterator<Item = T>,
R: RangeBounds<usize>,
Creates a splicing iterator that replaces the specified range in the vector
with the given replace_with
iterator and yields the removed items.
replace_with
does not need to be the same length as range
.
The element range is removed even if the iterator is not consumed until the end.
It is unspecified how many elements are removed from the vector
if the Splice
value is leaked.
The input iterator replace_with
is only consumed when the Splice
value is dropped.
This is optimal if:
- The tail (elements in the vector after
range
) is empty, - or
replace_with
yields fewer elements thanrange
’s length - or the lower bound of its
size_hint()
is exact.
Otherwise, a temporary vector is allocated and the tail is moved twice.
Panics
Panics if the starting point is greater than the end point or if the end point is greater than the length of the vector.
Examples
let mut v = vec![1, 2, 3]; let new = [7, 8]; let u: Vec<_> = v.splice(..2, new.iter().cloned()).collect(); assert_eq!(v, &[7, 8, 3]); assert_eq!(u, &[1, 2]);Run
ⓘImportant traits for DrainFilter<'_, T, F>pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<T, F> where
F: FnMut(&mut T) -> bool,
[src]
F: FnMut(&mut T) -> bool,
🔬 This is a nightly-only experimental API. (drain_filter
#43244)
recently added
Creates an iterator which uses a closure to determine if an element should be removed.
If the closure returns true, then the element is removed and yielded. If the closure returns false, the element will remain in the vector and will not be yielded by the iterator.
Using this method is equivalent to the following code:
let mut i = 0; while i != vec.len() { if some_predicate(&mut vec[i]) { let val = vec.remove(i); // your code here } else { i += 1; } } Run
But drain_filter
is easier to use. drain_filter
is also more efficient,
because it can backshift the elements of the array in bulk.
Note that drain_filter
also lets you mutate every element in the filter closure,
regardless of whether you choose to keep or remove it.
Examples
Splitting an array into evens and odds, reusing the original allocation:
#![feature(drain_filter)] let mut numbers = vec![1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15]; let evens = numbers.drain_filter(|x| *x % 2 == 0).collect::<Vec<_>>(); let odds = numbers; assert_eq!(evens, vec![2, 4, 6, 8, 14]); assert_eq!(odds, vec![1, 3, 5, 9, 11, 13, 15]);Run
Methods from Deref<Target = [T]>
pub const fn len(&self) -> usize
[src]
pub const fn is_empty(&self) -> bool
[src]
pub fn first(&self) -> Option<&T>
[src]
Returns the first element of the slice, or None
if it is empty.
Examples
let v = [10, 40, 30]; assert_eq!(Some(&10), v.first()); let w: &[i32] = &[]; assert_eq!(None, w.first());Run
pub fn first_mut(&mut self) -> Option<&mut T>
[src]
Returns a mutable pointer to the first element of the slice, or None
if it is empty.
Examples
let x = &mut [0, 1, 2]; if let Some(first) = x.first_mut() { *first = 5; } assert_eq!(x, &[5, 1, 2]);Run
pub fn split_first(&self) -> Option<(&T, &[T])>
1.5.0[src]
Returns the first and all the rest of the elements of the slice, or None
if it is empty.
Examples
let x = &[0, 1, 2]; if let Some((first, elements)) = x.split_first() { assert_eq!(first, &0); assert_eq!(elements, &[1, 2]); }Run
pub fn split_first_mut(&mut self) -> Option<(&mut T, &mut [T])>
1.5.0[src]
Returns the first and all the rest of the elements of the slice, or None
if it is empty.
Examples
let x = &mut [0, 1, 2]; if let Some((first, elements)) = x.split_first_mut() { *first = 3; elements[0] = 4; elements[1] = 5; } assert_eq!(x, &[3, 4, 5]);Run
pub fn split_last(&self) -> Option<(&T, &[T])>
1.5.0[src]
Returns the last and all the rest of the elements of the slice, or None
if it is empty.
Examples
let x = &[0, 1, 2]; if let Some((last, elements)) = x.split_last() { assert_eq!(last, &2); assert_eq!(elements, &[0, 1]); }Run
pub fn split_last_mut(&mut self) -> Option<(&mut T, &mut [T])>
1.5.0[src]
Returns the last and all the rest of the elements of the slice, or None
if it is empty.
Examples
let x = &mut [0, 1, 2]; if let Some((last, elements)) = x.split_last_mut() { *last = 3; elements[0] = 4; elements[1] = 5; } assert_eq!(x, &[4, 5, 3]);Run
pub fn last(&self) -> Option<&T>
[src]
Returns the last element of the slice, or None
if it is empty.
Examples
let v = [10, 40, 30]; assert_eq!(Some(&30), v.last()); let w: &[i32] = &[]; assert_eq!(None, w.last());Run
pub fn last_mut(&mut self) -> Option<&mut T>
[src]
Returns a mutable pointer to the last item in the slice.
Examples
let x = &mut [0, 1, 2]; if let Some(last) = x.last_mut() { *last = 10; } assert_eq!(x, &[0, 1, 10]);Run
pub fn get<I>(&self, index: I) -> Option<&<I as SliceIndex<[T]>>::Output> where
I: SliceIndex<[T]>,
[src]
I: SliceIndex<[T]>,
Returns a reference to an element or subslice depending on the type of index.
- If given a position, returns a reference to the element at that
position or
None
if out of bounds. - If given a range, returns the subslice corresponding to that range,
or
None
if out of bounds.
Examples
let v = [10, 40, 30]; assert_eq!(Some(&40), v.get(1)); assert_eq!(Some(&[10, 40][..]), v.get(0..2)); assert_eq!(None, v.get(3)); assert_eq!(None, v.get(0..4));Run
pub fn get_mut<I>(
&mut self,
index: I
) -> Option<&mut <I as SliceIndex<[T]>>::Output> where
I: SliceIndex<[T]>,
[src]
&mut self,
index: I
) -> Option<&mut <I as SliceIndex<[T]>>::Output> where
I: SliceIndex<[T]>,
Returns a mutable reference to an element or subslice depending on the
type of index (see get
) or None
if the index is out of bounds.
Examples
let x = &mut [0, 1, 2]; if let Some(elem) = x.get_mut(1) { *elem = 42; } assert_eq!(x, &[0, 42, 2]);Run
pub unsafe fn get_unchecked<I>(
&self,
index: I
) -> &<I as SliceIndex<[T]>>::Output where
I: SliceIndex<[T]>,
[src]
&self,
index: I
) -> &<I as SliceIndex<[T]>>::Output where
I: SliceIndex<[T]>,
Returns a reference to an element or subslice, without doing bounds checking.
This is generally not recommended, use with caution!
Calling this method with an out-of-bounds index is undefined behavior
even if the resulting reference is not used.
For a safe alternative see get
.
Examples
let x = &[1, 2, 4]; unsafe { assert_eq!(x.get_unchecked(1), &2); }Run
pub unsafe fn get_unchecked_mut<I>(
&mut self,
index: I
) -> &mut <I as SliceIndex<[T]>>::Output where
I: SliceIndex<[T]>,
[src]
&mut self,
index: I
) -> &mut <I as SliceIndex<[T]>>::Output where
I: SliceIndex<[T]>,
Returns a mutable reference to an element or subslice, without doing bounds checking.
This is generally not recommended, use with caution!
Calling this method with an out-of-bounds index is undefined behavior
even if the resulting reference is not used.
For a safe alternative see get_mut
.
Examples
let x = &mut [1, 2, 4]; unsafe { let elem = x.get_unchecked_mut(1); *elem = 13; } assert_eq!(x, &[1, 13, 4]);Run
pub const fn as_ptr(&self) -> *const T
[src]
Returns a raw pointer to the slice's buffer.
The caller must ensure that the slice outlives the pointer this function returns, or else it will end up pointing to garbage.
The caller must also ensure that the memory the pointer (non-transitively) points to
is never written to (except inside an UnsafeCell
) using this pointer or any pointer
derived from it. If you need to mutate the contents of the slice, use as_mut_ptr
.
Modifying the container referenced by this slice may cause its buffer to be reallocated, which would also make any pointers to it invalid.
Examples
let x = &[1, 2, 4]; let x_ptr = x.as_ptr(); unsafe { for i in 0..x.len() { assert_eq!(x.get_unchecked(i), &*x_ptr.add(i)); } }Run
pub fn as_mut_ptr(&mut self) -> *mut T
[src]
Returns an unsafe mutable pointer to the slice's buffer.
The caller must ensure that the slice outlives the pointer this function returns, or else it will end up pointing to garbage.
Modifying the container referenced by this slice may cause its buffer to be reallocated, which would also make any pointers to it invalid.
Examples
let x = &mut [1, 2, 4]; let x_ptr = x.as_mut_ptr(); unsafe { for i in 0..x.len() { *x_ptr.add(i) += 2; } } assert_eq!(x, &[3, 4, 6]);Run
pub fn swap(&mut self, a: usize, b: usize)
[src]
Swaps two elements in the slice.
Arguments
- a - The index of the first element
- b - The index of the second element
Panics
Panics if a
or b
are out of bounds.
Examples
let mut v = ["a", "b", "c", "d"]; v.swap(1, 3); assert!(v == ["a", "d", "c", "b"]);Run
pub fn reverse(&mut self)
[src]
Reverses the order of elements in the slice, in place.
Examples
let mut v = [1, 2, 3]; v.reverse(); assert!(v == [3, 2, 1]);Run
ⓘImportant traits for Iter<'a, T>pub fn iter(&self) -> Iter<T>
[src]
Returns an iterator over the slice.
Examples
let x = &[1, 2, 4]; let mut iterator = x.iter(); assert_eq!(iterator.next(), Some(&1)); assert_eq!(iterator.next(), Some(&2)); assert_eq!(iterator.next(), Some(&4)); assert_eq!(iterator.next(), None);Run
ⓘImportant traits for IterMut<'a, T>pub fn iter_mut(&mut self) -> IterMut<T>
[src]
Returns an iterator that allows modifying each value.
Examples
let x = &mut [1, 2, 4]; for elem in x.iter_mut() { *elem += 2; } assert_eq!(x, &[3, 4, 6]);Run
ⓘImportant traits for Windows<'a, T>pub fn windows(&self, size: usize) -> Windows<T>
[src]
Returns an iterator over all contiguous windows of length
size
. The windows overlap. If the slice is shorter than
size
, the iterator returns no values.
Panics
Panics if size
is 0.
Examples
let slice = ['r', 'u', 's', 't']; let mut iter = slice.windows(2); assert_eq!(iter.next().unwrap(), &['r', 'u']); assert_eq!(iter.next().unwrap(), &['u', 's']); assert_eq!(iter.next().unwrap(), &['s', 't']); assert!(iter.next().is_none());Run
If the slice is shorter than size
:
let slice = ['f', 'o', 'o']; let mut iter = slice.windows(4); assert!(iter.next().is_none());Run
ⓘImportant traits for Chunks<'a, T>pub fn chunks(&self, chunk_size: usize) -> Chunks<T>
[src]
Returns an iterator over chunk_size
elements of the slice at a time, starting at the
beginning of the slice.
The chunks are slices and do not overlap. If chunk_size
does not divide the length of the
slice, then the last chunk will not have length chunk_size
.
See chunks_exact
for a variant of this iterator that returns chunks of always exactly
chunk_size
elements, and rchunks
for the same iterator but starting at the end of the
slice.
Panics
Panics if chunk_size
is 0.
Examples
let slice = ['l', 'o', 'r', 'e', 'm']; let mut iter = slice.chunks(2); assert_eq!(iter.next().unwrap(), &['l', 'o']); assert_eq!(iter.next().unwrap(), &['r', 'e']); assert_eq!(iter.next().unwrap(), &['m']); assert!(iter.next().is_none());Run
ⓘImportant traits for ChunksMut<'a, T>pub fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<T>
[src]
Returns an iterator over chunk_size
elements of the slice at a time, starting at the
beginning of the slice.
The chunks are mutable slices, and do not overlap. If chunk_size
does not divide the
length of the slice, then the last chunk will not have length chunk_size
.
See chunks_exact_mut
for a variant of this iterator that returns chunks of always
exactly chunk_size
elements, and rchunks_mut
for the same iterator but starting at
the end of the slice.
Panics
Panics if chunk_size
is 0.
Examples
let v = &mut [0, 0, 0, 0, 0]; let mut count = 1; for chunk in v.chunks_mut(2) { for elem in chunk.iter_mut() { *elem += count; } count += 1; } assert_eq!(v, &[1, 1, 2, 2, 3]);Run
ⓘImportant traits for ChunksExact<'a, T>pub fn chunks_exact(&self, chunk_size: usize) -> ChunksExact<T>
1.31.0[src]
Returns an iterator over chunk_size
elements of the slice at a time, starting at the
beginning of the slice.
The chunks are slices and do not overlap. If chunk_size
does not divide the length of the
slice, then the last up to chunk_size-1
elements will be omitted and can be retrieved
from the remainder
function of the iterator.
Due to each chunk having exactly chunk_size
elements, the compiler can often optimize the
resulting code better than in the case of chunks
.
See chunks
for a variant of this iterator that also returns the remainder as a smaller
chunk, and rchunks_exact
for the same iterator but starting at the end of the slice.
Panics
Panics if chunk_size
is 0.
Examples
let slice = ['l', 'o', 'r', 'e', 'm']; let mut iter = slice.chunks_exact(2); assert_eq!(iter.next().unwrap(), &['l', 'o']); assert_eq!(iter.next().unwrap(), &['r', 'e']); assert!(iter.next().is_none()); assert_eq!(iter.remainder(), &['m']);Run
ⓘImportant traits for ChunksExactMut<'a, T>pub fn chunks_exact_mut(&mut self, chunk_size: usize) -> ChunksExactMut<T>
1.31.0[src]
Returns an iterator over chunk_size
elements of the slice at a time, starting at the
beginning of the slice.
The chunks are mutable slices, and do not overlap. If chunk_size
does not divide the
length of the slice, then the last up to chunk_size-1
elements will be omitted and can be
retrieved from the into_remainder
function of the iterator.
Due to each chunk having exactly chunk_size
elements, the compiler can often optimize the
resulting code better than in the case of chunks_mut
.
See chunks_mut
for a variant of this iterator that also returns the remainder as a
smaller chunk, and rchunks_exact_mut
for the same iterator but starting at the end of
the slice.
Panics
Panics if chunk_size
is 0.
Examples
let v = &mut [0, 0, 0, 0, 0]; let mut count = 1; for chunk in v.chunks_exact_mut(2) { for elem in chunk.iter_mut() { *elem += count; } count += 1; } assert_eq!(v, &[1, 1, 2, 2, 0]);Run
ⓘImportant traits for RChunks<'a, T>pub fn rchunks(&self, chunk_size: usize) -> RChunks<T>
1.31.0[src]
Returns an iterator over chunk_size
elements of the slice at a time, starting at the end
of the slice.
The chunks are slices and do not overlap. If chunk_size
does not divide the length of the
slice, then the last chunk will not have length chunk_size
.
See rchunks_exact
for a variant of this iterator that returns chunks of always exactly
chunk_size
elements, and chunks
for the same iterator but starting at the beginning
of the slice.
Panics
Panics if chunk_size
is 0.
Examples
let slice = ['l', 'o', 'r', 'e', 'm']; let mut iter = slice.rchunks(2); assert_eq!(iter.next().unwrap(), &['e', 'm']); assert_eq!(iter.next().unwrap(), &['o', 'r']); assert_eq!(iter.next().unwrap(), &['l']); assert!(iter.next().is_none());Run
ⓘImportant traits for RChunksMut<'a, T>pub fn rchunks_mut(&mut self, chunk_size: usize) -> RChunksMut<T>
1.31.0[src]
Returns an iterator over chunk_size
elements of the slice at a time, starting at the end
of the slice.
The chunks are mutable slices, and do not overlap. If chunk_size
does not divide the
length of the slice, then the last chunk will not have length chunk_size
.
See rchunks_exact_mut
for a variant of this iterator that returns chunks of always
exactly chunk_size
elements, and chunks_mut
for the same iterator but starting at the
beginning of the slice.
Panics
Panics if chunk_size
is 0.
Examples
let v = &mut [0, 0, 0, 0, 0]; let mut count = 1; for chunk in v.rchunks_mut(2) { for elem in chunk.iter_mut() { *elem += count; } count += 1; } assert_eq!(v, &[3, 2, 2, 1, 1]);Run
ⓘImportant traits for RChunksExact<'a, T>pub fn rchunks_exact(&self, chunk_size: usize) -> RChunksExact<T>
1.31.0[src]
Returns an iterator over chunk_size
elements of the slice at a time, starting at the
end of the slice.
The chunks are slices and do not overlap. If chunk_size
does not divide the length of the
slice, then the last up to chunk_size-1
elements will be omitted and can be retrieved
from the remainder
function of the iterator.
Due to each chunk having exactly chunk_size
elements, the compiler can often optimize the
resulting code better than in the case of chunks
.
See rchunks
for a variant of this iterator that also returns the remainder as a smaller
chunk, and chunks_exact
for the same iterator but starting at the beginning of the
slice.
Panics
Panics if chunk_size
is 0.
Examples
let slice = ['l', 'o', 'r', 'e', 'm']; let mut iter = slice.rchunks_exact(2); assert_eq!(iter.next().unwrap(), &['e', 'm']); assert_eq!(iter.next().unwrap(), &['o', 'r']); assert!(iter.next().is_none()); assert_eq!(iter.remainder(), &['l']);Run
ⓘImportant traits for RChunksExactMut<'a, T>pub fn rchunks_exact_mut(&mut self, chunk_size: usize) -> RChunksExactMut<T>
1.31.0[src]
Returns an iterator over chunk_size
elements of the slice at a time, starting at the end
of the slice.
The chunks are mutable slices, and do not overlap. If chunk_size
does not divide the
length of the slice, then the last up to chunk_size-1
elements will be omitted and can be
retrieved from the into_remainder
function of the iterator.
Due to each chunk having exactly chunk_size
elements, the compiler can often optimize the
resulting code better than in the case of chunks_mut
.
See rchunks_mut
for a variant of this iterator that also returns the remainder as a
smaller chunk, and chunks_exact_mut
for the same iterator but starting at the beginning
of the slice.
Panics
Panics if chunk_size
is 0.
Examples
let v = &mut [0, 0, 0, 0, 0]; let mut count = 1; for chunk in v.rchunks_exact_mut(2) { for elem in chunk.iter_mut() { *elem += count; } count += 1; } assert_eq!(v, &[0, 2, 2, 1, 1]);Run
pub fn split_at(&self, mid: usize) -> (&[T], &[T])
[src]
Divides one slice into two at an index.
The first will contain all indices from [0, mid)
(excluding
the index mid
itself) and the second will contain all
indices from [mid, len)
(excluding the index len
itself).
Panics
Panics if mid > len
.
Examples
let v = [1, 2, 3, 4, 5, 6]; { let (left, right) = v.split_at(0); assert!(left == []); assert!(right == [1, 2, 3, 4, 5, 6]); } { let (left, right) = v.split_at(2); assert!(left == [1, 2]); assert!(right == [3, 4, 5, 6]); } { let (left, right) = v.split_at(6); assert!(left == [1, 2, 3, 4, 5, 6]); assert!(right == []); }Run
pub fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T])
[src]
Divides one mutable slice into two at an index.
The first will contain all indices from [0, mid)
(excluding
the index mid
itself) and the second will contain all
indices from [mid, len)
(excluding the index len
itself).
Panics
Panics if mid > len
.
Examples
let mut v = [1, 0, 3, 0, 5, 6]; // scoped to restrict the lifetime of the borrows { let (left, right) = v.split_at_mut(2); assert!(left == [1, 0]); assert!(right == [3, 0, 5, 6]); left[1] = 2; right[1] = 4; } assert!(v == [1, 2, 3, 4, 5, 6]);Run
ⓘImportant traits for Split<'a, T, P>pub fn split<F>(&self, pred: F) -> Split<T, F> where
F: FnMut(&T) -> bool,
[src]
F: FnMut(&T) -> bool,
Returns an iterator over subslices separated by elements that match
pred
. The matched element is not contained in the subslices.
Examples
let slice = [10, 40, 33, 20]; let mut iter = slice.split(|num| num % 3 == 0); assert_eq!(iter.next().unwrap(), &[10, 40]); assert_eq!(iter.next().unwrap(), &[20]); assert!(iter.next().is_none());Run
If the first element is matched, an empty slice will be the first item returned by the iterator. Similarly, if the last element in the slice is matched, an empty slice will be the last item returned by the iterator:
let slice = [10, 40, 33]; let mut iter = slice.split(|num| num % 3 == 0); assert_eq!(iter.next().unwrap(), &[10, 40]); assert_eq!(iter.next().unwrap(), &[]); assert!(iter.next().is_none());Run
If two matched elements are directly adjacent, an empty slice will be present between them:
let slice = [10, 6, 33, 20]; let mut iter = slice.split(|num| num % 3 == 0); assert_eq!(iter.next().unwrap(), &[10]); assert_eq!(iter.next().unwrap(), &[]); assert_eq!(iter.next().unwrap(), &[20]); assert!(iter.next().is_none());Run
ⓘImportant traits for SplitMut<'a, T, P>pub fn split_mut<F>(&mut self, pred: F) -> SplitMut<T, F> where
F: FnMut(&T) -> bool,
[src]
F: FnMut(&T) -> bool,
Returns an iterator over mutable subslices separated by elements that
match pred
. The matched element is not contained in the subslices.
Examples
let mut v = [10, 40, 30, 20, 60, 50]; for group in v.split_mut(|num| *num % 3 == 0) { group[0] = 1; } assert_eq!(v, [1, 40, 30, 1, 60, 1]);Run
ⓘImportant traits for RSplit<'a, T, P>pub fn rsplit<F>(&self, pred: F) -> RSplit<T, F> where
F: FnMut(&T) -> bool,
1.27.0[src]
F: FnMut(&T) -> bool,
Returns an iterator over subslices separated by elements that match
pred
, starting at the end of the slice and working backwards.
The matched element is not contained in the subslices.
Examples
let slice = [11, 22, 33, 0, 44, 55]; let mut iter = slice.rsplit(|num| *num == 0); assert_eq!(iter.next().unwrap(), &[44, 55]); assert_eq!(iter.next().unwrap(), &[11, 22, 33]); assert_eq!(iter.next(), None);Run
As with split()
, if the first or last element is matched, an empty
slice will be the first (or last) item returned by the iterator.
let v = &[0, 1, 1, 2, 3, 5, 8]; let mut it = v.rsplit(|n| *n % 2 == 0); assert_eq!(it.next().unwrap(), &[]); assert_eq!(it.next().unwrap(), &[3, 5]); assert_eq!(it.next().unwrap(), &[1, 1]); assert_eq!(it.next().unwrap(), &[]); assert_eq!(it.next(), None);Run
ⓘImportant traits for RSplitMut<'a, T, P>pub fn rsplit_mut<F>(&mut self, pred: F) -> RSplitMut<T, F> where
F: FnMut(&T) -> bool,
1.27.0[src]
F: FnMut(&T) -> bool,
Returns an iterator over mutable subslices separated by elements that
match pred
, starting at the end of the slice and working
backwards. The matched element is not contained in the subslices.
Examples
let mut v = [100, 400, 300, 200, 600, 500]; let mut count = 0; for group in v.rsplit_mut(|num| *num % 3 == 0) { count += 1; group[0] = count; } assert_eq!(v, [3, 400, 300, 2, 600, 1]);Run
ⓘImportant traits for SplitN<'a, T, P>pub fn splitn<F>(&self, n: usize, pred: F) -> SplitN<T, F> where
F: FnMut(&T) -> bool,
[src]
F: FnMut(&T) -> bool,
Returns an iterator over subslices separated by elements that match
pred
, limited to returning at most n
items. The matched element is
not contained in the subslices.
The last element returned, if any, will contain the remainder of the slice.
Examples
Print the slice split once by numbers divisible by 3 (i.e., [10, 40]
,
[20, 60, 50]
):
let v = [10, 40, 30, 20, 60, 50]; for group in v.splitn(2, |num| *num % 3 == 0) { println!("{:?}", group); }Run
ⓘImportant traits for SplitNMut<'a, T, P>pub fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<T, F> where
F: FnMut(&T) -> bool,
[src]
F: FnMut(&T) -> bool,
Returns an iterator over subslices separated by elements that match
pred
, limited to returning at most n
items. The matched element is
not contained in the subslices.
The last element returned, if any, will contain the remainder of the slice.
Examples
let mut v = [10, 40, 30, 20, 60, 50]; for group in v.splitn_mut(2, |num| *num % 3 == 0) { group[0] = 1; } assert_eq!(v, [1, 40, 30, 1, 60, 50]);Run
ⓘImportant traits for RSplitN<'a, T, P>pub fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<T, F> where
F: FnMut(&T) -> bool,
[src]
F: FnMut(&T) -> bool,
Returns an iterator over subslices separated by elements that match
pred
limited to returning at most n
items. This starts at the end of
the slice and works backwards. The matched element is not contained in
the subslices.
The last element returned, if any, will contain the remainder of the slice.
Examples
Print the slice split once, starting from the end, by numbers divisible
by 3 (i.e., [50]
, [10, 40, 30, 20]
):
let v = [10, 40, 30, 20, 60, 50]; for group in v.rsplitn(2, |num| *num % 3 == 0) { println!("{:?}", group); }Run
ⓘImportant traits for RSplitNMut<'a, T, P>pub fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<T, F> where
F: FnMut(&T) -> bool,
[src]
F: FnMut(&T) -> bool,
Returns an iterator over subslices separated by elements that match
pred
limited to returning at most n
items. This starts at the end of
the slice and works backwards. The matched element is not contained in
the subslices.
The last element returned, if any, will contain the remainder of the slice.
Examples
let mut s = [10, 40, 30, 20, 60, 50]; for group in s.rsplitn_mut(2, |num| *num % 3 == 0) { group[0] = 1; } assert_eq!(s, [1, 40, 30, 20, 60, 1]);Run
pub fn contains(&self, x: &T) -> bool where
T: PartialEq<T>,
[src]
T: PartialEq<T>,
Returns true
if the slice contains an element with the given value.
Examples
let v = [10, 40, 30]; assert!(v.contains(&30)); assert!(!v.contains(&50));Run
If you do not have an &T
, but just an &U
such that T: Borrow<U>
(e.g. String: Borrow<str>
), you can use iter().any
:
let v = [String::from("hello"), String::from("world")]; // slice of `String` assert!(v.iter().any(|e| e == "hello")); // search with `&str` assert!(!v.iter().any(|e| e == "hi"));Run
pub fn starts_with(&self, needle: &[T]) -> bool where
T: PartialEq<T>,
[src]
T: PartialEq<T>,
Returns true
if needle
is a prefix of the slice.
Examples
let v = [10, 40, 30]; assert!(v.starts_with(&[10])); assert!(v.starts_with(&[10, 40])); assert!(!v.starts_with(&[50])); assert!(!v.starts_with(&[10, 50]));Run
Always returns true
if needle
is an empty slice:
let v = &[10, 40, 30]; assert!(v.starts_with(&[])); let v: &[u8] = &[]; assert!(v.starts_with(&[]));Run
pub fn ends_with(&self, needle: &[T]) -> bool where
T: PartialEq<T>,
[src]
T: PartialEq<T>,
Returns true
if needle
is a suffix of the slice.
Examples
let v = [10, 40, 30]; assert!(v.ends_with(&[30])); assert!(v.ends_with(&[40, 30])); assert!(!v.ends_with(&[50])); assert!(!v.ends_with(&[50, 30]));Run
Always returns true
if needle
is an empty slice:
let v = &[10, 40, 30]; assert!(v.ends_with(&[])); let v: &[u8] = &[]; assert!(v.ends_with(&[]));Run
pub fn binary_search(&self, x: &T) -> Result<usize, usize> where
T: Ord,
[src]
T: Ord,
Binary searches this sorted slice for a given element.
If the value is found then Result::Ok
is returned, containing the
index of the matching element. If there are multiple matches, then any
one of the matches could be returned. If the value is not found then
Result::Err
is returned, containing the index where a matching
element could be inserted while maintaining sorted order.
Examples
Looks up a series of four elements. The first is found, with a
uniquely determined position; the second and third are not
found; the fourth could match any position in [1, 4]
.
let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]; assert_eq!(s.binary_search(&13), Ok(9)); assert_eq!(s.binary_search(&4), Err(7)); assert_eq!(s.binary_search(&100), Err(13)); let r = s.binary_search(&1); assert!(match r { Ok(1..=4) => true, _ => false, });Run
If you want to insert an item to a sorted vector, while maintaining sort order:
let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]; let num = 42; let idx = s.binary_search(&num).unwrap_or_else(|x| x); s.insert(idx, num); assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);Run
pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize> where
F: FnMut(&'a T) -> Ordering,
[src]
F: FnMut(&'a T) -> Ordering,
Binary searches this sorted slice with a comparator function.
The comparator function should implement an order consistent
with the sort order of the underlying slice, returning an
order code that indicates whether its argument is Less
,
Equal
or Greater
the desired target.
If the value is found then Result::Ok
is returned, containing the
index of the matching element. If there are multiple matches, then any
one of the matches could be returned. If the value is not found then
Result::Err
is returned, containing the index where a matching
element could be inserted while maintaining sorted order.
Examples
Looks up a series of four elements. The first is found, with a
uniquely determined position; the second and third are not
found; the fourth could match any position in [1, 4]
.
let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]; let seek = 13; assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Ok(9)); let seek = 4; assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(7)); let seek = 100; assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(13)); let seek = 1; let r = s.binary_search_by(|probe| probe.cmp(&seek)); assert!(match r { Ok(1..=4) => true, _ => false, });Run
pub fn binary_search_by_key<'a, B, F>(
&'a self,
b: &B,
f: F
) -> Result<usize, usize> where
B: Ord,
F: FnMut(&'a T) -> B,
1.10.0[src]
&'a self,
b: &B,
f: F
) -> Result<usize, usize> where
B: Ord,
F: FnMut(&'a T) -> B,
Binary searches this sorted slice with a key extraction function.
Assumes that the slice is sorted by the key, for instance with
sort_by_key
using the same key extraction function.
If the value is found then Result::Ok
is returned, containing the
index of the matching element. If there are multiple matches, then any
one of the matches could be returned. If the value is not found then
Result::Err
is returned, containing the index where a matching
element could be inserted while maintaining sorted order.
Examples
Looks up a series of four elements in a slice of pairs sorted by
their second elements. The first is found, with a uniquely
determined position; the second and third are not found; the
fourth could match any position in [1, 4]
.
let s = [(0, 0), (2, 1), (4, 1), (5, 1), (3, 1), (1, 2), (2, 3), (4, 5), (5, 8), (3, 13), (1, 21), (2, 34), (4, 55)]; assert_eq!(s.binary_search_by_key(&13, |&(a,b)| b), Ok(9)); assert_eq!(s.binary_search_by_key(&4, |&(a,b)| b), Err(7)); assert_eq!(s.binary_search_by_key(&100, |&(a,b)| b), Err(13)); let r = s.binary_search_by_key(&1, |&(a,b)| b); assert!(match r { Ok(1..=4) => true, _ => false, });Run
pub fn sort_unstable(&mut self) where
T: Ord,
1.20.0[src]
T: Ord,
Sorts the slice, but may not preserve the order of equal elements.
This sort is unstable (i.e., may reorder equal elements), in-place
(i.e., does not allocate), and O(n log n)
worst-case.
Current implementation
The current algorithm is based on pattern-defeating quicksort by Orson Peters, which combines the fast average case of randomized quicksort with the fast worst case of heapsort, while achieving linear time on slices with certain patterns. It uses some randomization to avoid degenerate cases, but with a fixed seed to always provide deterministic behavior.
It is typically faster than stable sorting, except in a few special cases, e.g., when the slice consists of several concatenated sorted sequences.
Examples
let mut v = [-5, 4, 1, -3, 2]; v.sort_unstable(); assert!(v == [-5, -3, 1, 2, 4]);Run
pub fn sort_unstable_by<F>(&mut self, compare: F) where
F: FnMut(&T, &T) -> Ordering,
1.20.0[src]
F: FnMut(&T, &T) -> Ordering,
Sorts the slice with a comparator function, but may not preserve the order of equal elements.
This sort is unstable (i.e., may reorder equal elements), in-place
(i.e., does not allocate), and O(n log n)
worst-case.
The comparator function must define a total ordering for the elements in the slice. If the ordering is not total, the order of the elements is unspecified. An order is a total order if it is (for all a, b and c):
- total and antisymmetric: exactly one of a < b, a == b or a > b is true; and
- transitive, a < b and b < c implies a < c. The same must hold for both == and >.
For example, while f64
doesn't implement Ord
because NaN != NaN
, we can use
partial_cmp
as our sort function when we know the slice doesn't contain a NaN
.
let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0]; floats.sort_by(|a, b| a.partial_cmp(b).unwrap()); assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]);Run
Current implementation
The current algorithm is based on pattern-defeating quicksort by Orson Peters, which combines the fast average case of randomized quicksort with the fast worst case of heapsort, while achieving linear time on slices with certain patterns. It uses some randomization to avoid degenerate cases, but with a fixed seed to always provide deterministic behavior.
It is typically faster than stable sorting, except in a few special cases, e.g., when the slice consists of several concatenated sorted sequences.
Examples
let mut v = [5, 4, 1, 3, 2]; v.sort_unstable_by(|a, b| a.cmp(b)); assert!(v == [1, 2, 3, 4, 5]); // reverse sorting v.sort_unstable_by(|a, b| b.cmp(a)); assert!(v == [5, 4, 3, 2, 1]);Run
pub fn sort_unstable_by_key<K, F>(&mut self, f: F) where
F: FnMut(&T) -> K,
K: Ord,
1.20.0[src]
F: FnMut(&T) -> K,
K: Ord,
Sorts the slice with a key extraction function, but may not preserve the order of equal elements.
This sort is unstable (i.e., may reorder equal elements), in-place
(i.e., does not allocate), and O(m n log(m n))
worst-case, where the key function is
O(m)
.
Current implementation
The current algorithm is based on pattern-defeating quicksort by Orson Peters, which combines the fast average case of randomized quicksort with the fast worst case of heapsort, while achieving linear time on slices with certain patterns. It uses some randomization to avoid degenerate cases, but with a fixed seed to always provide deterministic behavior.
Due to its key calling strategy, sort_unstable_by_key
is likely to be slower than sort_by_cached_key
in
cases where the key function is expensive.
Examples
let mut v = [-5i32, 4, 1, -3, 2]; v.sort_unstable_by_key(|k| k.abs()); assert!(v == [1, 2, -3, 4, -5]);Run
pub fn partition_at_index(
&mut self,
index: usize
) -> (&mut [T], &mut T, &mut [T]) where
T: Ord,
[src]
&mut self,
index: usize
) -> (&mut [T], &mut T, &mut [T]) where
T: Ord,
Reorder the slice such that the element at index
is at its final sorted position.
This reordering has the additional property that any value at position i < index
will be
less than or equal to any value at a position j > index
. Additionally, this reordering is
unstable (i.e. any number of equal elements may end up at position index
), in-place
(i.e. does not allocate), and O(n)
worst-case. This function is also/ known as "kth
element" in other libraries. It returns a triplet of the following values: all elements less
than the one at the given index, the value at the given index, and all elements greater than
the one at the given index.
Current implementation
The current algorithm is based on the quickselect portion of the same quicksort algorithm
used for sort_unstable
.
Panics
Panics when index >= len()
, meaning it always panics on empty slices.
Examples
#![feature(slice_partition_at_index)] let mut v = [-5i32, 4, 1, -3, 2]; // Find the median v.partition_at_index(2); // We are only guaranteed the slice will be one of the following, based on the way we sort // about the specified index. assert!(v == [-3, -5, 1, 2, 4] || v == [-5, -3, 1, 2, 4] || v == [-3, -5, 1, 4, 2] || v == [-5, -3, 1, 4, 2]);Run
pub fn partition_at_index_by<F>(
&mut self,
index: usize,
compare: F
) -> (&mut [T], &mut T, &mut [T]) where
F: FnMut(&T, &T) -> Ordering,
[src]
&mut self,
index: usize,
compare: F
) -> (&mut [T], &mut T, &mut [T]) where
F: FnMut(&T, &T) -> Ordering,
Reorder the slice with a comparator function such that the element at index
is at its
final sorted position.
This reordering has the additional property that any value at position i < index
will be
less than or equal to any value at a position j > index
using the comparator function.
Additionally, this reordering is unstable (i.e. any number of equal elements may end up at
position index
), in-place (i.e. does not allocate), and O(n)
worst-case. This function
is also known as "kth element" in other libraries. It returns a triplet of the following
values: all elements less than the one at the given index, the value at the given index,
and all elements greater than the one at the given index, using the provided comparator
function.
Current implementation
The current algorithm is based on the quickselect portion of the same quicksort algorithm
used for sort_unstable
.
Panics
Panics when index >= len()
, meaning it always panics on empty slices.
Examples
#![feature(slice_partition_at_index)] let mut v = [-5i32, 4, 1, -3, 2]; // Find the median as if the slice were sorted in descending order. v.partition_at_index_by(2, |a, b| b.cmp(a)); // We are only guaranteed the slice will be one of the following, based on the way we sort // about the specified index. assert!(v == [2, 4, 1, -5, -3] || v == [2, 4, 1, -3, -5] || v == [4, 2, 1, -5, -3] || v == [4, 2, 1, -3, -5]);Run
pub fn partition_at_index_by_key<K, F>(
&mut self,
index: usize,
f: F
) -> (&mut [T], &mut T, &mut [T]) where
F: FnMut(&T) -> K,
K: Ord,
[src]
&mut self,
index: usize,
f: F
) -> (&mut [T], &mut T, &mut [T]) where
F: FnMut(&T) -> K,
K: Ord,
Reorder the slice with a key extraction function such that the element at index
is at its
final sorted position.
This reordering has the additional property that any value at position i < index
will be
less than or equal to any value at a position j > index
using the key extraction function.
Additionally, this reordering is unstable (i.e. any number of equal elements may end up at
position index
), in-place (i.e. does not allocate), and O(n)
worst-case. This function
is also known as "kth element" in other libraries. It returns a triplet of the following
values: all elements less than the one at the given index, the value at the given index, and
all elements greater than the one at the given index, using the provided key extraction
function.
Current implementation
The current algorithm is based on the quickselect portion of the same quicksort algorithm
used for sort_unstable
.
Panics
Panics when index >= len()
, meaning it always panics on empty slices.
Examples
#![feature(slice_partition_at_index)] let mut v = [-5i32, 4, 1, -3, 2]; // Return the median as if the array were sorted according to absolute value. v.partition_at_index_by_key(2, |a| a.abs()); // We are only guaranteed the slice will be one of the following, based on the way we sort // about the specified index. assert!(v == [1, 2, -3, 4, -5] || v == [1, 2, -3, -5, 4] || v == [2, 1, -3, 4, -5] || v == [2, 1, -3, -5, 4]);Run
pub fn partition_dedup(&mut self) -> (&mut [T], &mut [T]) where
T: PartialEq<T>,
[src]
T: PartialEq<T>,
Moves all consecutive repeated elements to the end of the slice according to the
PartialEq
trait implementation.
Returns two slices. The first contains no consecutive repeated elements. The second contains all the duplicates in no specified order.
If the slice is sorted, the first returned slice contains no duplicates.
Examples
#![feature(slice_partition_dedup)] let mut slice = [1, 2, 2, 3, 3, 2, 1, 1]; let (dedup, duplicates) = slice.partition_dedup(); assert_eq!(dedup, [1, 2, 3, 2, 1]); assert_eq!(duplicates, [2, 3, 1]);Run
pub fn partition_dedup_by<F>(&mut self, same_bucket: F) -> (&mut [T], &mut [T]) where
F: FnMut(&mut T, &mut T) -> bool,
[src]
F: FnMut(&mut T, &mut T) -> bool,
Moves all but the first of consecutive elements to the end of the slice satisfying a given equality relation.
Returns two slices. The first contains no consecutive repeated elements. The second contains all the duplicates in no specified order.
The same_bucket
function is passed references to two elements from the slice and
must determine if the elements compare equal. The elements are passed in opposite order
from their order in the slice, so if same_bucket(a, b)
returns true
, a
is moved
at the end of the slice.
If the slice is sorted, the first returned slice contains no duplicates.
Examples
#![feature(slice_partition_dedup)] let mut slice = ["foo", "Foo", "BAZ", "Bar", "bar", "baz", "BAZ"]; let (dedup, duplicates) = slice.partition_dedup_by(|a, b| a.eq_ignore_ascii_case(b)); assert_eq!(dedup, ["foo", "BAZ", "Bar", "baz"]); assert_eq!(duplicates, ["bar", "Foo", "BAZ"]);Run
pub fn partition_dedup_by_key<K, F>(&mut self, key: F) -> (&mut [T], &mut [T]) where
F: FnMut(&mut T) -> K,
K: PartialEq<K>,
[src]
F: FnMut(&mut T) -> K,
K: PartialEq<K>,
Moves all but the first of consecutive elements to the end of the slice that resolve to the same key.
Returns two slices. The first contains no consecutive repeated elements. The second contains all the duplicates in no specified order.
If the slice is sorted, the first returned slice contains no duplicates.
Examples
#![feature(slice_partition_dedup)] let mut slice = [10, 20, 21, 30, 30, 20, 11, 13]; let (dedup, duplicates) = slice.partition_dedup_by_key(|i| *i / 10); assert_eq!(dedup, [10, 20, 30, 20, 11]); assert_eq!(duplicates, [21, 30, 13]);Run
pub fn rotate_left(&mut self, mid: usize)
1.26.0[src]
Rotates the slice in-place such that the first mid
elements of the
slice move to the end while the last self.len() - mid
elements move to
the front. After calling rotate_left
, the element previously at index
mid
will become the first element in the slice.
Panics
This function will panic if mid
is greater than the length of the
slice. Note that mid == self.len()
does not panic and is a no-op
rotation.
Complexity
Takes linear (in self.len()
) time.
Examples
let mut a = ['a', 'b', 'c', 'd', 'e', 'f']; a.rotate_left(2); assert_eq!(a, ['c', 'd', 'e', 'f', 'a', 'b']);Run
Rotating a subslice:
let mut a = ['a', 'b', 'c', 'd', 'e', 'f']; a[1..5].rotate_left(1); assert_eq!(a, ['a', 'c', 'd', 'e', 'b', 'f']);Run
pub fn rotate_right(&mut self, k: usize)
1.26.0[src]
Rotates the slice in-place such that the first self.len() - k
elements of the slice move to the end while the last k
elements move
to the front. After calling rotate_right
, the element previously at
index self.len() - k
will become the first element in the slice.
Panics
This function will panic if k
is greater than the length of the
slice. Note that k == self.len()
does not panic and is a no-op
rotation.
Complexity
Takes linear (in self.len()
) time.
Examples
let mut a = ['a', 'b', 'c', 'd', 'e', 'f']; a.rotate_right(2); assert_eq!(a, ['e', 'f', 'a', 'b', 'c', 'd']);Run
Rotate a subslice:
let mut a = ['a', 'b', 'c', 'd', 'e', 'f']; a[1..5].rotate_right(1); assert_eq!(a, ['a', 'e', 'b', 'c', 'd', 'f']);Run
pub fn clone_from_slice(&mut self, src: &[T]) where
T: Clone,
1.7.0[src]
T: Clone,
Copies the elements from src
into self
.
The length of src
must be the same as self
.
If src
implements Copy
, it can be more performant to use
copy_from_slice
.
Panics
This function will panic if the two slices have different lengths.
Examples
Cloning two elements from a slice into another:
let src = [1, 2, 3, 4]; let mut dst = [0, 0]; // Because the slices have to be the same length, // we slice the source slice from four elements // to two. It will panic if we don't do this. dst.clone_from_slice(&src[2..]); assert_eq!(src, [1, 2, 3, 4]); assert_eq!(dst, [3, 4]);Run
Rust enforces that there can only be one mutable reference with no
immutable references to a particular piece of data in a particular
scope. Because of this, attempting to use clone_from_slice
on a
single slice will result in a compile failure:
let mut slice = [1, 2, 3, 4, 5]; slice[..2].clone_from_slice(&slice[3..]); // compile fail!Run
To work around this, we can use split_at_mut
to create two distinct
sub-slices from a slice:
let mut slice = [1, 2, 3, 4, 5]; { let (left, right) = slice.split_at_mut(2); left.clone_from_slice(&right[1..]); } assert_eq!(slice, [4, 5, 3, 4, 5]);Run
pub fn copy_from_slice(&mut self, src: &[T]) where
T: Copy,
1.9.0[src]
T: Copy,
Copies all elements from src
into self
, using a memcpy.
The length of src
must be the same as self
.
If src
does not implement Copy
, use clone_from_slice
.
Panics
This function will panic if the two slices have different lengths.
Examples
Copying two elements from a slice into another:
let src = [1, 2, 3, 4]; let mut dst = [0, 0]; // Because the slices have to be the same length, // we slice the source slice from four elements // to two. It will panic if we don't do this. dst.copy_from_slice(&src[2..]); assert_eq!(src, [1, 2, 3, 4]); assert_eq!(dst, [3, 4]);Run
Rust enforces that there can only be one mutable reference with no
immutable references to a particular piece of data in a particular
scope. Because of this, attempting to use copy_from_slice
on a
single slice will result in a compile failure:
let mut slice = [1, 2, 3, 4, 5]; slice[..2].copy_from_slice(&slice[3..]); // compile fail!Run
To work around this, we can use split_at_mut
to create two distinct
sub-slices from a slice:
let mut slice = [1, 2, 3, 4, 5]; { let (left, right) = slice.split_at_mut(2); left.copy_from_slice(&right[1..]); } assert_eq!(slice, [4, 5, 3, 4, 5]);Run
pub fn copy_within<R>(&mut self, src: R, dest: usize) where
R: RangeBounds<usize>,
T: Copy,
1.37.0[src]
R: RangeBounds<usize>,
T: Copy,
Copies elements from one part of the slice to another part of itself, using a memmove.
src
is the range within self
to copy from. dest
is the starting
index of the range within self
to copy to, which will have the same
length as src
. The two ranges may overlap. The ends of the two ranges
must be less than or equal to self.len()
.
Panics
This function will panic if either range exceeds the end of the slice,
or if the end of src
is before the start.
Examples
Copying four bytes within a slice:
let mut bytes = *b"Hello, World!"; bytes.copy_within(1..5, 8); assert_eq!(&bytes, b"Hello, Wello!");Run
pub fn swap_with_slice(&mut self, other: &mut [T])
1.27.0[src]
Swaps all elements in self
with those in other
.
The length of other
must be the same as self
.
Panics
This function will panic if the two slices have different lengths.
Example
Swapping two elements across slices:
let mut slice1 = [0, 0]; let mut slice2 = [1, 2, 3, 4]; slice1.swap_with_slice(&mut slice2[2..]); assert_eq!(slice1, [3, 4]); assert_eq!(slice2, [1, 2, 0, 0]);Run
Rust enforces that there can only be one mutable reference to a
particular piece of data in a particular scope. Because of this,
attempting to use swap_with_slice
on a single slice will result in
a compile failure:
let mut slice = [1, 2, 3, 4, 5]; slice[..2].swap_with_slice(&mut slice[3..]); // compile fail!Run
To work around this, we can use split_at_mut
to create two distinct
mutable sub-slices from a slice:
let mut slice = [1, 2, 3, 4, 5]; { let (left, right) = slice.split_at_mut(2); left.swap_with_slice(&mut right[1..]); } assert_eq!(slice, [4, 5, 3, 1, 2]);Run
pub unsafe fn align_to<U>(&self) -> (&[T], &[U], &[T])
1.30.0[src]
Transmute the slice to a slice of another type, ensuring alignment of the types is maintained.
This method splits the slice into three distinct slices: prefix, correctly aligned middle slice of a new type, and the suffix slice. The method may make the middle slice the greatest length possible for a given type and input slice, but only your algorithm's performance should depend on that, not its correctness. It is permissible for all of the input data to be returned as the prefix or suffix slice.
This method has no purpose when either input element T
or output element U
are
zero-sized and will return the original slice without splitting anything.
Safety
This method is essentially a transmute
with respect to the elements in the returned
middle slice, so all the usual caveats pertaining to transmute::<T, U>
also apply here.
Examples
Basic usage:
unsafe { let bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7]; let (prefix, shorts, suffix) = bytes.align_to::<u16>(); // less_efficient_algorithm_for_bytes(prefix); // more_efficient_algorithm_for_aligned_shorts(shorts); // less_efficient_algorithm_for_bytes(suffix); }Run
pub unsafe fn align_to_mut<U>(&mut self) -> (&mut [T], &mut [U], &mut [T])
1.30.0[src]
Transmute the slice to a slice of another type, ensuring alignment of the types is maintained.
This method splits the slice into three distinct slices: prefix, correctly aligned middle slice of a new type, and the suffix slice. The method may make the middle slice the greatest length possible for a given type and input slice, but only your algorithm's performance should depend on that, not its correctness. It is permissible for all of the input data to be returned as the prefix or suffix slice.
This method has no purpose when either input element T
or output element U
are
zero-sized and will return the original slice without splitting anything.
Safety
This method is essentially a transmute
with respect to the elements in the returned
middle slice, so all the usual caveats pertaining to transmute::<T, U>
also apply here.
Examples
Basic usage:
unsafe { let mut bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7]; let (prefix, shorts, suffix) = bytes.align_to_mut::<u16>(); // less_efficient_algorithm_for_bytes(prefix); // more_efficient_algorithm_for_aligned_shorts(shorts); // less_efficient_algorithm_for_bytes(suffix); }Run
pub fn is_sorted(&self) -> bool where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
🔬 This is a nightly-only experimental API. (is_sorted
#53485)
new API
Checks if the elements of this slice are sorted.
That is, for each element a
and its following element b
, a <= b
must hold. If the
slice yields exactly zero or one element, true
is returned.
Note that if Self::Item
is only PartialOrd
, but not Ord
, the above definition
implies that this function returns false
if any two consecutive items are not
comparable.
Examples
#![feature(is_sorted)] let empty: [i32; 0] = []; assert!([1, 2, 2, 9].is_sorted()); assert!(![1, 3, 2, 4].is_sorted()); assert!([0].is_sorted()); assert!(empty.is_sorted()); assert!(![0.0, 1.0, std::f32::NAN].is_sorted());Run
pub fn is_sorted_by<F>(&self, compare: F) -> bool where
F: FnMut(&T, &T) -> Option<Ordering>,
[src]
F: FnMut(&T, &T) -> Option<Ordering>,
🔬 This is a nightly-only experimental API. (is_sorted
#53485)
new API
Checks if the elements of this slice are sorted using the given comparator function.
Instead of using PartialOrd::partial_cmp
, this function uses the given compare
function to determine the ordering of two elements. Apart from that, it's equivalent to
is_sorted
; see its documentation for more information.
pub fn is_sorted_by_key<F, K>(&self, f: F) -> bool where
F: FnMut(&T) -> K,
K: PartialOrd<K>,
[src]
F: FnMut(&T) -> K,
K: PartialOrd<K>,
🔬 This is a nightly-only experimental API. (is_sorted
#53485)
new API
Checks if the elements of this slice are sorted using the given key extraction function.
Instead of comparing the slice's elements directly, this function compares the keys of the
elements, as determined by f
. Apart from that, it's equivalent to is_sorted
; see its
documentation for more information.
Examples
#![feature(is_sorted)] assert!(["c", "bb", "aaa"].is_sorted_by_key(|s| s.len())); assert!(![-2i32, -1, 0, 3].is_sorted_by_key(|n| n.abs()));Run
pub fn is_ascii(&self) -> bool
1.23.0[src]
Checks if all bytes in this slice are within the ASCII range.
pub fn eq_ignore_ascii_case(&self, other: &[u8]) -> bool
1.23.0[src]
Checks that two slices are an ASCII case-insensitive match.
Same as to_ascii_lowercase(a) == to_ascii_lowercase(b)
,
but without allocating and copying temporaries.
pub fn make_ascii_uppercase(&mut self)
1.23.0[src]
Converts this slice to its ASCII upper case equivalent in-place.
ASCII letters 'a' to 'z' are mapped to 'A' to 'Z', but non-ASCII letters are unchanged.
To return a new uppercased value without modifying the existing one, use
to_ascii_uppercase
.
pub fn make_ascii_lowercase(&mut self)
1.23.0[src]
Converts this slice to its ASCII lower case equivalent in-place.
ASCII letters 'A' to 'Z' are mapped to 'a' to 'z', but non-ASCII letters are unchanged.
To return a new lowercased value without modifying the existing one, use
to_ascii_lowercase
.
pub fn sort(&mut self) where
T: Ord,
[src]
T: Ord,
Sorts the slice.
This sort is stable (i.e., does not reorder equal elements) and O(n log n)
worst-case.
When applicable, unstable sorting is preferred because it is generally faster than stable
sorting and it doesn't allocate auxiliary memory.
See sort_unstable
.
Current implementation
The current algorithm is an adaptive, iterative merge sort inspired by timsort. It is designed to be very fast in cases where the slice is nearly sorted, or consists of two or more sorted sequences concatenated one after another.
Also, it allocates temporary storage half the size of self
, but for short slices a
non-allocating insertion sort is used instead.
Examples
let mut v = [-5, 4, 1, -3, 2]; v.sort(); assert!(v == [-5, -3, 1, 2, 4]);Run
pub fn sort_by<F>(&mut self, compare: F) where
F: FnMut(&T, &T) -> Ordering,
[src]
F: FnMut(&T, &T) -> Ordering,
Sorts the slice with a comparator function.
This sort is stable (i.e., does not reorder equal elements) and O(n log n)
worst-case.
The comparator function must define a total ordering for the elements in the slice. If
the ordering is not total, the order of the elements is unspecified. An order is a
total order if it is (for all a
, b
and c
):
- total and antisymmetric: exactly one of
a < b
,a == b
ora > b
is true, and - transitive,
a < b
andb < c
impliesa < c
. The same must hold for both==
and>
.
For example, while f64
doesn't implement Ord
because NaN != NaN
, we can use
partial_cmp
as our sort function when we know the slice doesn't contain a NaN
.
let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0]; floats.sort_by(|a, b| a.partial_cmp(b).unwrap()); assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]);Run
When applicable, unstable sorting is preferred because it is generally faster than stable
sorting and it doesn't allocate auxiliary memory.
See sort_unstable_by
.
Current implementation
The current algorithm is an adaptive, iterative merge sort inspired by timsort. It is designed to be very fast in cases where the slice is nearly sorted, or consists of two or more sorted sequences concatenated one after another.
Also, it allocates temporary storage half the size of self
, but for short slices a
non-allocating insertion sort is used instead.
Examples
let mut v = [5, 4, 1, 3, 2]; v.sort_by(|a, b| a.cmp(b)); assert!(v == [1, 2, 3, 4, 5]); // reverse sorting v.sort_by(|a, b| b.cmp(a)); assert!(v == [5, 4, 3, 2, 1]);Run
pub fn sort_by_key<K, F>(&mut self, f: F) where
F: FnMut(&T) -> K,
K: Ord,
1.7.0[src]
F: FnMut(&T) -> K,
K: Ord,
Sorts the slice with a key extraction function.
This sort is stable (i.e., does not reorder equal elements) and O(m n log(m n))
worst-case, where the key function is O(m)
.
For expensive key functions (e.g. functions that are not simple property accesses or
basic operations), sort_by_cached_key
is likely to be
significantly faster, as it does not recompute element keys.
When applicable, unstable sorting is preferred because it is generally faster than stable
sorting and it doesn't allocate auxiliary memory.
See sort_unstable_by_key
.
Current implementation
The current algorithm is an adaptive, iterative merge sort inspired by timsort. It is designed to be very fast in cases where the slice is nearly sorted, or consists of two or more sorted sequences concatenated one after another.
Also, it allocates temporary storage half the size of self
, but for short slices a
non-allocating insertion sort is used instead.
Examples
let mut v = [-5i32, 4, 1, -3, 2]; v.sort_by_key(|k| k.abs()); assert!(v == [1, 2, -3, 4, -5]);Run
pub fn sort_by_cached_key<K, F>(&mut self, f: F) where
F: FnMut(&T) -> K,
K: Ord,
1.34.0[src]
F: FnMut(&T) -> K,
K: Ord,
Sorts the slice with a key extraction function.
During sorting, the key function is called only once per element.
This sort is stable (i.e., does not reorder equal elements) and O(m n + n log n)
worst-case, where the key function is O(m)
.
For simple key functions (e.g., functions that are property accesses or
basic operations), sort_by_key
is likely to be
faster.
Current implementation
The current algorithm is based on pattern-defeating quicksort by Orson Peters, which combines the fast average case of randomized quicksort with the fast worst case of heapsort, while achieving linear time on slices with certain patterns. It uses some randomization to avoid degenerate cases, but with a fixed seed to always provide deterministic behavior.
In the worst case, the algorithm allocates temporary storage in a Vec<(K, usize)>
the
length of the slice.
Examples
let mut v = [-5i32, 4, 32, -3, 2]; v.sort_by_cached_key(|k| k.to_string()); assert!(v == [-3, -5, 2, 32, 4]);Run
pub fn to_vec(&self) -> Vec<T> where
T: Clone,
[src]
T: Clone,
Copies self
into a new Vec
.
Examples
let s = [10, 40, 30]; let x = s.to_vec(); // Here, `s` and `x` can be modified independently.Run
pub fn repeat(&self, n: usize) -> Vec<T> where
T: Copy,
[src]
T: Copy,
🔬 This is a nightly-only experimental API. (repeat_generic_slice
#48784)
it's on str, why not on slice?
Creates a vector by repeating a slice n
times.
Panics
This function will panic if the capacity would overflow.
Examples
Basic usage:
#![feature(repeat_generic_slice)] fn main() { assert_eq!([1, 2].repeat(3), vec![1, 2, 1, 2, 1, 2]); }Run
A panic upon overflow:
#![feature(repeat_generic_slice)] fn main() { // this will panic at runtime b"0123456789abcdef".repeat(usize::max_value()); }Run
pub fn concat<Item>(&self) -> <[T] as Concat<Item>>::Output where
Item: ?Sized,
[T]: Concat<Item>,
[src]
Item: ?Sized,
[T]: Concat<Item>,
Flattens a slice of T
into a single value Self::Output
.
Examples
assert_eq!(["hello", "world"].concat(), "helloworld"); assert_eq!([[1, 2], [3, 4]].concat(), [1, 2, 3, 4]);Run
pub fn join<Separator>(
&self,
sep: Separator
) -> <[T] as Join<Separator>>::Output where
[T]: Join<Separator>,
1.3.0[src]
&self,
sep: Separator
) -> <[T] as Join<Separator>>::Output where
[T]: Join<Separator>,
Flattens a slice of T
into a single value Self::Output
, placing a
given separator between each.
Examples
assert_eq!(["hello", "world"].join(" "), "hello world"); assert_eq!([[1, 2], [3, 4]].join(&0), [1, 2, 0, 3, 4]); assert_eq!([[1, 2], [3, 4]].join(&[0, 0][..]), [1, 2, 0, 0, 3, 4]);Run
pub fn connect<Separator>(
&self,
sep: Separator
) -> <[T] as Join<Separator>>::Output where
[T]: Join<Separator>,
[src]
&self,
sep: Separator
) -> <[T] as Join<Separator>>::Output where
[T]: Join<Separator>,
renamed to join
pub fn to_ascii_uppercase(&self) -> Vec<u8>
1.23.0[src]
Returns a vector containing a copy of this slice where each byte is mapped to its ASCII upper case equivalent.
ASCII letters 'a' to 'z' are mapped to 'A' to 'Z', but non-ASCII letters are unchanged.
To uppercase the value in-place, use make_ascii_uppercase
.
pub fn to_ascii_lowercase(&self) -> Vec<u8>
1.23.0[src]
Returns a vector containing a copy of this slice where each byte is mapped to its ASCII lower case equivalent.
ASCII letters 'A' to 'Z' are mapped to 'a' to 'z', but non-ASCII letters are unchanged.
To lowercase the value in-place, use make_ascii_lowercase
.
Trait Implementations
impl<T> Eq for Vec<T> where
T: Eq,
[src]
T: Eq,
impl<T> AsMut<Vec<T>> for Vec<T>
1.5.0[src]
impl<T> AsMut<[T]> for Vec<T>
1.5.0[src]
impl<'a, T> IntoIterator for &'a Vec<T>
[src]
type Item = &'a T
The type of the elements being iterated over.
type IntoIter = Iter<'a, T>
Which kind of iterator are we turning this into?
ⓘImportant traits for Iter<'a, T>fn into_iter(self) -> Iter<'a, T>
[src]
impl<'a, T> IntoIterator for &'a mut Vec<T>
[src]
type Item = &'a mut T
The type of the elements being iterated over.
type IntoIter = IterMut<'a, T>
Which kind of iterator are we turning this into?
ⓘImportant traits for IterMut<'a, T>fn into_iter(self) -> IterMut<'a, T>
[src]
impl<T> IntoIterator for Vec<T>
[src]
type Item = T
The type of the elements being iterated over.
type IntoIter = IntoIter<T>
Which kind of iterator are we turning this into?
ⓘImportant traits for IntoIter<T>fn into_iter(self) -> IntoIter<T>
[src]
impl<T> Deref for Vec<T>
[src]
impl<'a, T> From<Cow<'a, [T]>> for Vec<T> where
[T]: ToOwned,
<[T] as ToOwned>::Owned == Vec<T>,
1.14.0[src]
[T]: ToOwned,
<[T] as ToOwned>::Owned == Vec<T>,
impl<T> From<VecDeque<T>> for Vec<T>
1.10.0[src]
fn from(other: VecDeque<T>) -> Vec<T>
[src]
Turn a VecDeque<T>
into a Vec<T>
.
This never needs to re-allocate, but does need to do O(n) data movement if the circular buffer doesn't happen to be at the beginning of the allocation.
Examples
use std::collections::VecDeque; // This one is O(1). let deque: VecDeque<_> = (1..5).collect(); let ptr = deque.as_slices().0.as_ptr(); let vec = Vec::from(deque); assert_eq!(vec, [1, 2, 3, 4]); assert_eq!(vec.as_ptr(), ptr); // This one needs data rearranging. let mut deque: VecDeque<_> = (1..5).collect(); deque.push_front(9); deque.push_front(8); let ptr = deque.as_slices().1.as_ptr(); let vec = Vec::from(deque); assert_eq!(vec, [8, 9, 1, 2, 3, 4]); assert_eq!(vec.as_ptr(), ptr);Run
impl<T> From<Vec<T>> for Arc<[T]>
1.21.0[src]
impl<T> From<Vec<T>> for VecDeque<T>
1.10.0[src]
fn from(other: Vec<T>) -> VecDeque<T>
[src]
Turn a Vec<T>
into a VecDeque<T>
.
This avoids reallocating where possible, but the conditions for that are
strict, and subject to change, and so shouldn't be relied upon unless the
Vec<T>
came from From<VecDeque<T>>
and hasn't been reallocated.
impl<T> From<Box<[T]>> for Vec<T>
1.18.0[src]
impl<'_, T> From<&'_ [T]> for Vec<T> where
T: Clone,
[src]
T: Clone,
impl<T> From<BinaryHeap<T>> for Vec<T>
1.5.0[src]
impl<T> From<Vec<T>> for BinaryHeap<T> where
T: Ord,
1.5.0[src]
T: Ord,
fn from(vec: Vec<T>) -> BinaryHeap<T>
[src]
Converts a Vec<T>
into a BinaryHeap<T>
.
This conversion happens in-place, and has O(n)
time complexity.
impl<'a, T> From<Vec<T>> for Cow<'a, [T]> where
T: Clone,
1.8.0[src]
T: Clone,
impl From<String> for Vec<u8>
1.14.0[src]
impl<T> From<Vec<T>> for Rc<[T]>
1.21.0[src]
impl<'_, T> From<&'_ mut [T]> for Vec<T> where
T: Clone,
1.19.0[src]
T: Clone,
impl<'a, T> From<&'a Vec<T>> for Cow<'a, [T]> where
T: Clone,
1.28.0[src]
T: Clone,
impl<T> From<Vec<T>> for Box<[T]>
1.20.0[src]
impl<'_> From<&'_ str> for Vec<u8>
[src]
impl<T> Hash for Vec<T> where
T: Hash,
[src]
T: Hash,
fn hash<H>(&self, state: &mut H) where
H: Hasher,
[src]
H: Hasher,
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<'_, A, B> PartialEq<&'_ mut [B]> for Vec<A> where
A: PartialEq<B>,
[src]
A: PartialEq<B>,
impl<const N: usize, A, B> PartialEq<[B; N]> for Vec<A> where
A: PartialEq<B>,
[B; N]: LengthAtMost32,
[src]
A: PartialEq<B>,
[B; N]: LengthAtMost32,
impl<'_, const N: usize, A, B> PartialEq<&'_ [B; N]> for Vec<A> where
A: PartialEq<B>,
[B; N]: LengthAtMost32,
[src]
A: PartialEq<B>,
[B; N]: LengthAtMost32,
impl<'_, A, B> PartialEq<&'_ [B]> for Vec<A> where
A: PartialEq<B>,
[src]
A: PartialEq<B>,
impl<A, B> PartialEq<Vec<B>> for Vec<A> where
A: PartialEq<B>,
[src]
A: PartialEq<B>,
impl<A, B> PartialEq<Vec<B>> for VecDeque<A> where
A: PartialEq<B>,
1.17.0[src]
A: PartialEq<B>,
impl<'_, A, B> PartialEq<Vec<B>> for Cow<'_, [A]> where
A: PartialEq<B> + Clone,
[src]
A: PartialEq<B> + Clone,
impl<T, I> IndexMut<I> for Vec<T> where
I: SliceIndex<[T]>,
[src]
I: SliceIndex<[T]>,
impl<T> AsRef<Vec<T>> for Vec<T>
[src]
impl<T> AsRef<[T]> for Vec<T>
[src]
impl<T> FromIterator<T> for Vec<T>
[src]
fn from_iter<I>(iter: I) -> Vec<T> where
I: IntoIterator<Item = T>,
[src]
I: IntoIterator<Item = T>,
impl<T, I> Index<I> for Vec<T> where
I: SliceIndex<[T]>,
[src]
I: SliceIndex<[T]>,
type Output = <I as SliceIndex<[T]>>::Output
The returned type after indexing.
fn index(&self, index: I) -> &<Vec<T> as Index<I>>::Output
[src]
impl<T> Borrow<[T]> for Vec<T>
[src]
impl<T> Ord for Vec<T> where
T: Ord,
[src]
T: Ord,
Implements ordering of vectors, lexicographically.
fn cmp(&self, other: &Vec<T>) -> Ordering
[src]
fn max(self, other: Self) -> Self
1.21.0[src]
fn min(self, other: Self) -> Self
1.21.0[src]
fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<T> Clone for Vec<T> where
T: Clone,
[src]
T: Clone,
impl<T> BorrowMut<[T]> for Vec<T>
[src]
impl<T> Drop for Vec<T>
[src]
impl<T> Debug for Vec<T> where
T: Debug,
[src]
T: Debug,
impl<T> PartialOrd<Vec<T>> for Vec<T> where
T: PartialOrd<T>,
[src]
T: PartialOrd<T>,
Implements comparison of vectors, lexicographically.
fn partial_cmp(&self, other: &Vec<T>) -> Option<Ordering>
[src]
#[must_use]
fn lt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn le(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn gt(&self, other: &Rhs) -> bool
[src]
#[must_use]
fn ge(&self, other: &Rhs) -> bool
[src]
impl<T> Default for Vec<T>
[src]
impl<T> DerefMut for Vec<T>
[src]
impl<T> Extend<T> for Vec<T>
[src]
fn extend<I>(&mut self, iter: I) where
I: IntoIterator<Item = T>,
[src]
I: IntoIterator<Item = T>,
impl<'a, T> Extend<&'a T> for Vec<T> where
T: 'a + Copy,
1.2.0[src]
T: 'a + Copy,
Extend implementation that copies elements out of references before pushing them onto the Vec.
This implementation is specialized for slice iterators, where it uses copy_from_slice
to
append the entire slice at once.
fn extend<I>(&mut self, iter: I) where
I: IntoIterator<Item = &'a T>,
[src]
I: IntoIterator<Item = &'a T>,
impl Write for Vec<u8>
[src]
Write is implemented for Vec<u8>
by appending to the vector.
The vector will grow as needed.
fn write(&mut self, buf: &[u8]) -> Result<usize>
[src]
fn write_vectored(&mut self, bufs: &[IoSlice]) -> Result<usize>
[src]
fn write_all(&mut self, buf: &[u8]) -> Result<()>
[src]
fn flush(&mut self) -> Result<()>
[src]
fn write_fmt(&mut self, fmt: Arguments) -> Result<()>
[src]
ⓘImportant traits for &'_ mut Ffn by_ref(&mut self) -> &mut Self where
Self: Sized,
[src]
Self: Sized,
impl From<CString> for Vec<u8>
1.7.0[src]
Auto Trait Implementations
impl<T> UnwindSafe for Vec<T> where
T: UnwindSafe,
T: UnwindSafe,
impl<T> RefUnwindSafe for Vec<T> where
T: RefUnwindSafe,
T: RefUnwindSafe,
impl<T> Unpin for Vec<T> where
T: Unpin,
T: Unpin,
impl<T> Send for Vec<T> where
T: Send,
T: Send,
impl<T> Sync for Vec<T> where
T: Sync,
T: Sync,
Blanket Implementations
impl<T> From<T> for T
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<I> IntoIterator for I where
I: Iterator,
[src]
I: Iterator,
type Item = <I as Iterator>::Item
The type of the elements being iterated over.
type IntoIter = I
Which kind of iterator are we turning this into?
fn into_iter(self) -> I
[src]
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
ⓘImportant traits for &'_ mut Ffn borrow_mut(&mut self) -> &mut T
[src]
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,