# Struct smallvec::SmallVec [−] [src]

    pub struct SmallVec<A: Array> { /* fields omitted */ }

A `Vec`-like container that can store a small number of elements inline.

`SmallVec` acts like a vector, but can store a limited amount of data inline within the `SmallVec` struct rather than in a separate allocation. If the data exceeds this limit, the `SmallVec` will “spill” its data onto the heap, allocating a new buffer to hold it.

The amount of data that a `SmallVec` can store inline depends on its backing store. The backing store can be any type that implements the `Array` trait; usually it is a small fixed-sized array. For example a `SmallVec<[u64; 8]>` can hold up to eight 64-bit integers inline.

## Example

    use smallvec::SmallVec;
    let mut v = SmallVec::<[u8; 4]>::new(); // initialize an empty vector

    // The vector can hold up to 4 items without spilling onto the heap.
    v.extend(0..4);
    assert_eq!(v.len(), 4);
    assert!(!v.spilled());

    // Pushing another element will force the buffer to spill:
    v.push(4);
    assert_eq!(v.len(), 5);
    assert!(v.spilled());

## Implementations

### `impl<A: Array> SmallVec<A>` [src]

#### `pub fn new() -> SmallVec<A>` [src]

Construct an empty vector

#### `pub fn with_capacity(n: usize) -> Self` [src]

Construct an empty vector with enough capacity pre-allocated to store at least `n` elements.

Will create a heap allocation only if `n` is larger than the inline capacity.

    let v: SmallVec<[u8; 3]> = SmallVec::with_capacity(100);

    assert!(v.is_empty());
    assert!(v.capacity() >= 100);

#### `pub fn from_vec(vec: Vec<A::Item>) -> SmallVec<A>` [src]

Construct a new `SmallVec` from a `Vec<A::Item>`.

Elements will be copied to the inline buffer if vec.capacity() <= Self::inline_capacity().

    use smallvec::SmallVec;

    let vec = vec![1, 2, 3, 4, 5];
    let small_vec: SmallVec<[_; 3]> = SmallVec::from_vec(vec);

    assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);

#### `pub fn from_buf(buf: A) -> SmallVec<A>` [src]

Constructs a new `SmallVec` on the stack from an `A` without copying elements.

    use smallvec::SmallVec;

    let buf = [1, 2, 3, 4, 5];
    let small_vec: SmallVec<_> = SmallVec::from_buf(buf);

    assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);

#### `pub fn from_buf_and_len(buf: A, len: usize) -> SmallVec<A>` [src]

Constructs a new `SmallVec` on the stack from an `A` without copying elements. Also sets the length, which must be less or equal to the size of `buf`.

    use smallvec::SmallVec;

    let buf = [1, 2, 3, 4, 5, 0, 0, 0];
    let small_vec: SmallVec<_> = SmallVec::from_buf_and_len(buf, 5);

    assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);

#### `pub unsafe fn from_buf_and_len_unchecked(
buf: MaybeUninit<A>,
len: usize
) -> SmallVec<A>` [src]

Constructs a new `SmallVec` on the stack from an `A` without copying elements. Also sets the length. The user is responsible for ensuring that `len <= A::size()`.

    use smallvec::SmallVec;
    use std::mem::MaybeUninit;

    let buf = [1, 2, 3, 4, 5, 0, 0, 0];
    let small_vec: SmallVec<_> = unsafe {
        SmallVec::from_buf_and_len_unchecked(MaybeUninit::new(buf), 5)
    };

    assert_eq!(&*small_vec, &[1, 2, 3, 4, 5]);

#### `pub unsafe fn set_len(&mut self, new_len: usize)` [src]

Sets the length of a vector.

This will explicitly set the size of the vector, without actually modifying its buffers, so it is up to the caller to ensure that the vector is actually the specified size.

#### `pub fn inline_size(&self) -> usize` [src]

The maximum number of elements this vector can hold inline

#### `pub fn len(&self) -> usize` [src]

The number of elements stored in the vector

#### `pub fn is_empty(&self) -> bool` [src]

Returns `true` if the vector is empty

#### `pub fn capacity(&self) -> usize` [src]

The number of items the vector can hold without reallocating

#### `pub fn spilled(&self) -> bool` [src]

Returns `true` if the data has spilled into a separate heap-allocated buffer.

#### `pub fn drain<R>(&mut self, range: R) -> Drain<'_, A>ⓘ

### Notable traits for Drain<'a, T>

`impl<'a, T: 'a + Array> Iterator for Drain<'a, T> type Item = T::Item;`
where
R: RangeBounds<usize>,` [src]

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.

#### `pub fn push(&mut self, value: A::Item)` [src]

Append an item to the vector.

#### `pub fn pop(&mut self) -> Option<A::Item>` [src]

Remove an item from the end of the vector and return it, or None if empty.

#### `pub fn append<B>(&mut self, other: &mut SmallVec<B>) where
B: Array<Item = A::Item>,` [src]

Moves all the elements of `other` into `self`, leaving `other` empty.

# Example

    let mut v0: SmallVec<[u8; 16]> = smallvec![1, 2, 3];
    let mut v1: SmallVec<[u8; 32]> = smallvec![4, 5, 6];
    v0.append(&mut v1);
    assert_eq!(*v0, [1, 2, 3, 4, 5, 6]);
    assert_eq!(*v1, []);

#### `pub fn grow(&mut self, new_cap: usize)` [src]

Re-allocate to set the capacity to `max(new_cap, inline_size())`.

Panics if `new_cap` is less than the vector’s length or if the capacity computation overflows `usize`.

#### `pub fn try_grow(&mut self, new_cap: usize) -> Result<(), CollectionAllocErr>` [src]

Re-allocate to set the capacity to `max(new_cap, inline_size())`.

Panics if `new_cap` is less than the vector’s length

#### `pub fn reserve(&mut self, additional: usize)` [src]

Reserve capacity for `additional` more elements to be inserted.

May reserve more space to avoid frequent reallocations.

Panics if the capacity computation overflows `usize`.

#### `pub fn try_reserve(
&mut self,
additional: usize
) -> Result<(), CollectionAllocErr>` [src]

Reserve capacity for `additional` more elements to be inserted.

May reserve more space to avoid frequent reallocations.

#### `pub fn reserve_exact(&mut self, additional: usize)` [src]

Reserve the minimum capacity for `additional` more elements to be inserted.

Panics if the new capacity overflows `usize`.

#### `pub fn try_reserve_exact(
&mut self,
additional: usize
) -> Result<(), CollectionAllocErr>` [src]

Reserve the minimum capacity for `additional` more elements to be inserted.

#### `pub fn shrink_to_fit(&mut self)` [src]

Shrink the capacity of the vector as much as possible.

When possible, this will move data from an external heap buffer to the vector’s inline storage.

#### `pub fn truncate(&mut self, len: usize)` [src]

Shorten the vector, keeping the first `len` elements and dropping the rest.

If `len` is greater than or equal to the vector’s current length, this has no effect.

This does not re-allocate. If you want the vector’s capacity to shrink, call `shrink_to_fit` after truncating.

#### `pub fn as_slice(&self) -> &[A::Item]` [src]

Extracts a slice containing the entire vector.

Equivalent to `&s[..]`.

#### `pub fn as_mut_slice(&mut self) -> &mut [A::Item]` [src]

Extracts a mutable slice of the entire vector.

Equivalent to `&mut s[..]`.

#### `pub fn swap_remove(&mut self, index: usize) -> A::Item` [src]

Remove the element at position `index`, replacing it with the last element.

This does not preserve ordering, but is O(1).

Panics if `index` is out of bounds.

#### `pub fn clear(&mut self)` [src]

Remove all elements from the vector.

#### `pub fn remove(&mut self, index: usize) -> A::Item` [src]

Remove and return the element at position `index`, shifting all elements after it to the left.

Panics if `index` is out of bounds.

#### `pub fn insert(&mut self, index: usize, element: A::Item)` [src]

Insert an element at position `index`, shifting all elements after it to the right.

Panics if `index` is out of bounds.

#### `pub fn insert_many<I: IntoIterator<Item = A::Item>>(
&mut self,
index: usize,
iterable: I
)` [src]

Insert multiple elements at position `index`, shifting all following elements toward the back.

#### `pub fn into_vec(self) -> Vec<A::Item>` [src]

Convert a SmallVec to a Vec, without reallocating if the SmallVec has already spilled onto the heap.

#### `pub fn into_boxed_slice(self) -> Box<[A::Item]>` [src]

Converts a `SmallVec` into a `Box<[T]>` without reallocating if the `SmallVec` has already spilled onto the heap.

Note that this will drop any excess capacity.

#### `pub fn into_inner(self) -> Result<A, Self>` [src]

Convert the SmallVec into an `A` if possible. Otherwise return `Err(Self)`.

This method returns `Err(Self)` if the SmallVec is too short (and the `A` contains uninitialized elements), or if the SmallVec is too long (and all the elements were spilled to the heap).

#### `pub fn retain<F: FnMut(&mut A::Item) -> bool>(&mut self, f: F)` [src]

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 and preserves the order of the retained elements.

#### `pub fn dedup(&mut self) where
A::Item: PartialEq<A::Item>,` [src]

Removes consecutive duplicate elements.

#### `pub fn dedup_by<F>(&mut self, same_bucket: F) where
F: FnMut(&mut A::Item, &mut A::Item) -> bool,` [src]

Removes consecutive duplicate elements using the given equality relation.

#### `pub fn dedup_by_key<F, K>(&mut self, key: F) where
F: FnMut(&mut A::Item) -> K,
K: PartialEq<K>,` [src]

Removes consecutive elements that map to the same key.

#### `pub fn resize_with<F>(&mut self, new_len: usize, f: F) where
F: FnMut() -> A::Item,` [src]

Resizes the `SmallVec` in-place so that `len` is equal to `new_len`.

If `new_len` is greater than `len`, the `SmallVec` is extended by the difference, with each additional slot filled with the result of calling the closure `f`. The return values from `f`

If `new_len` is less than `len`, the `SmallVec` 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.

Added for std::vec::Vec compatibility (added in Rust 1.33.0)

    let mut vec : SmallVec<[_; 4]> = smallvec![1, 2, 3];
    vec.resize_with(5, Default::default);
    assert_eq!(&*vec, &[1, 2, 3, 0, 0]);

    let mut vec : SmallVec<[_; 4]> = smallvec![];
    let mut p = 1;
    vec.resize_with(4, || { p *= 2; p });
    assert_eq!(&*vec, &[2, 4, 8, 16]);

#### `pub unsafe fn from_raw_parts(
ptr: *mut A::Item,
length: usize,
capacity: usize
) -> SmallVec<A>` [src]

Creates a `SmallVec` directly from the raw components of another `SmallVec`.

# Safety

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

- `ptr` needs to have been previously allocated via `SmallVec` for its spilled storage (at least, it’s highly likely to be incorrect if it wasn’t).
- `ptr`’s `A::Item` type needs to be the same size and alignment that it was allocated with
- `length` needs to be less than or equal to `capacity`.
- `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.

Additionally, `capacity` must be greater than the amount of inline storage `A` has; that is, the new `SmallVec` must need to spill over into heap allocated storage. This condition is asserted against.

The ownership of `ptr` is effectively transferred to the `SmallVec` 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::mem;
    use std::ptr;

    fn main() {
        let mut v: SmallVec<[_; 1]> = smallvec![1, 2, 3];

        // Pull out the important parts of `v`.
        let p = v.as_mut_ptr();
        let len = v.len();
        let cap = v.capacity();
        let spilled = v.spilled();

        unsafe {
            // Forget all about `v`. The heap allocation that stored the
            // three values won't be deallocated.
            mem::forget(v);

            // Overwrite memory with [4, 5, 6].
            //
            // This is only safe if `spilled` is true! Otherwise, we are
            // writing into the old `SmallVec`'s inline storage on the
            // stack.
            assert!(spilled);
            for i in 0..len {
                ptr::write(p.add(i), 4 + i);
            }

            // Put everything back together into a SmallVec with a different
            // amount of inline storage, but which is still less than `cap`.
            let rebuilt = SmallVec::<[_; 2]>::from_raw_parts(p, len, cap);
            assert_eq!(&*rebuilt, &[4, 5, 6]);
        }
    }

#### `pub fn as_ptr(&self) -> *const A::Item` [src]

Returns a raw pointer to the vector’s buffer.

#### `pub fn as_mut_ptr(&mut self) -> *mut A::Item` [src]

Returns a raw mutable pointer to the vector’s buffer.

### `impl<A: Array> SmallVec<A> where
A::Item: Copy,` [src]

#### `pub fn from_slice(slice: &[A::Item]) -> Self` [src]

Copy the elements from a slice into a new `SmallVec`.

For slices of `Copy` types, this is more efficient than `SmallVec::from(slice)`.

#### `pub fn insert_from_slice(&mut self, index: usize, slice: &[A::Item])` [src]

Copy elements from a slice into the vector at position `index`, shifting any following elements toward the back.

For slices of `Copy` types, this is more efficient than `insert`.

#### `pub fn extend_from_slice(&mut self, slice: &[A::Item])` [src]

Copy elements from a slice and append them to the vector.

For slices of `Copy` types, this is more efficient than `extend`.

### `impl<A: Array> SmallVec<A> where
A::Item: Clone,` [src]

#### `pub fn resize(&mut self, len: usize, value: A::Item)` [src]

Resizes the vector so that its length is equal to `len`.

If `len` is less than the current length, the vector simply truncated.

If `len` is greater than the current length, `value` is appended to the vector until its length equals `len`.

#### `pub fn from_elem(elem: A::Item, n: usize) -> Self` [src]

Creates a `SmallVec` with `n` copies of `elem`.

    use smallvec::SmallVec;

    let v = SmallVec::<[char; 128]>::from_elem('d', 2);
    assert_eq!(v, SmallVec::from_buf(['d', 'd']));

## Trait Implementations

### `impl<A: Array> AsMut<[<A as Array>::Item]> for SmallVec<A>` [src]

#### `fn as_mut(&mut self) -> &mut [A::Item]` [src]

Performs the conversion.

### `impl<A: Array> AsRef<[<A as Array>::Item]> for SmallVec<A>` [src]

#### `fn as_ref(&self) -> &[A::Item]` [src]

Performs the conversion.

### `impl<A: Array> Borrow<[<A as Array>::Item]> for SmallVec<A>` [src]

#### `fn borrow(&self) -> &[A::Item]` [src]

Immutably borrows from an owned value. Read more

### `impl<A: Array> BorrowMut<[<A as Array>::Item]> for SmallVec<A>` [src]

#### `fn borrow_mut(&mut self) -> &mut [A::Item]` [src]

Mutably borrows from an owned value. Read more

### `impl<A: Array> Clone for SmallVec<A> where
A::Item: Clone,` [src]

#### `fn clone(&self) -> SmallVec<A>` [src]

Returns a copy of the value. Read more

#### `pub fn clone_from(&mut self, source: &Self)`1.0.0 [src]

Performs copy-assignment from `source`. Read more

### `impl<A: Array> Debug for SmallVec<A> where
A::Item: Debug,` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl<A: Array> Default for SmallVec<A>` [src]

#### `fn default() -> SmallVec<A>` [src]

Returns the “default value” for a type. Read more

### `impl<A: Array> Deref for SmallVec<A>` [src]

#### `type Target = [A::Item]`

The resulting type after dereferencing.

#### `fn deref(&self) -> &[A::Item]` [src]

Dereferences the value.

### `impl<A: Array> DerefMut for SmallVec<A>` [src]

#### `fn deref_mut(&mut self) -> &mut [A::Item]` [src]

Mutably dereferences the value.

### `impl<A: Array> Drop for SmallVec<A>` [src]

#### `fn drop(&mut self)` [src]

Executes the destructor for this type. Read more

### `impl<A: Array> Eq for SmallVec<A> where
A::Item: Eq,` [src]

### `impl<A: Array> Extend<<A as Array>::Item> for SmallVec<A>` [src]

#### `fn extend<I: IntoIterator<Item = A::Item>>(&mut self, iterable: I)` [src]

Extends a collection with the contents of an iterator. Read more

#### `pub fn extend_one(&mut self, item: A)` [src]

🔬 This is a nightly-only experimental API. (`extend_one`)

Extends a collection with exactly one element.

#### `pub fn extend_reserve(&mut self, additional: usize)` [src]

🔬 This is a nightly-only experimental API. (`extend_one`)

Reserves capacity in a collection for the given number of additional elements. Read more

### `impl<'a, A: Array> From<&'a [<A as Array>::Item]> for SmallVec<A> where
A::Item: Clone,` [src]

#### `fn from(slice: &'a [A::Item]) -> SmallVec<A>` [src]

Performs the conversion.

### `impl<A: Array> From<A> for SmallVec<A>` [src]

#### `fn from(array: A) -> SmallVec<A>` [src]

Performs the conversion.

### `impl<A: Array> From<Vec<<A as Array>::Item, Global>> for SmallVec<A>` [src]

#### `fn from(vec: Vec<A::Item>) -> SmallVec<A>` [src]

Performs the conversion.

### `impl<A: Array> FromIterator<<A as Array>::Item> for SmallVec<A>` [src]

#### `fn from_iter<I: IntoIterator<Item = A::Item>>(iterable: I) -> SmallVec<A>` [src]

Creates a value from an iterator. Read more

### `impl<A: Array> Hash for SmallVec<A> where
A::Item: Hash,` [src]

#### `fn hash<H: Hasher>(&self, state: &mut H)` [src]

Feeds this value into the given `Hasher`. Read more

#### `pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,` 1.3.0 [src]

Feeds a slice of this type into the given `Hasher`. Read more

### `impl<A: Array, I: SliceIndex<[A::Item]>> Index<I> for SmallVec<A>` [src]

#### `type Output = I::Output`

The returned type after indexing.

#### `fn index(&self, index: I) -> &I::Output` [src]

Performs the indexing (`container[index]`) operation.

### `impl<A: Array, I: SliceIndex<[A::Item]>> IndexMut<I> for SmallVec<A>` [src]

#### `fn index_mut(&mut self, index: I) -> &mut I::Output` [src]

Performs the mutable indexing (`container[index]`) operation.

### `impl<A: Array> IntoIterator for SmallVec<A>` [src]

#### `type IntoIter = IntoIter<A>`

Which kind of iterator are we turning this into?

#### `type Item = A::Item`

The type of the elements being iterated over.

#### `fn into_iter(self) -> Self::IntoIter` [src]

Creates an iterator from a value. Read more

### `impl<'a, A: Array> IntoIterator for &'a SmallVec<A>` [src]

#### `type IntoIter = Iter<'a, A::Item>`

Which kind of iterator are we turning this into?

#### `type Item = &'a A::Item`

The type of the elements being iterated over.

#### `fn into_iter(self) -> Self::IntoIter` [src]

Creates an iterator from a value. Read more

### `impl<'a, A: Array> IntoIterator for &'a mut SmallVec<A>` [src]

#### `type IntoIter = IterMut<'a, A::Item>`

Which kind of iterator are we turning this into?

#### `type Item = &'a mut A::Item`

The type of the elements being iterated over.

#### `fn into_iter(self) -> Self::IntoIter` [src]

Creates an iterator from a value. Read more

### `impl<A: Array> Ord for SmallVec<A> where
A::Item: Ord,` [src]

#### `fn cmp(&self, other: &SmallVec<A>) -> Ordering` [src]

This method returns an `Ordering` between `self` and `other`. Read more

#### `#[must_use]pub fn max(self, other: Self) -> Self` 1.21.0 [src]

Compares and returns the maximum of two values. Read more

#### `#[must_use]pub fn min(self, other: Self) -> Self` 1.21.0 [src]

Compares and returns the minimum of two values. Read more

#### `#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self` 1.50.0 [src]

Restrict a value to a certain interval. Read more

### `impl<A: Array, B: Array> PartialEq<SmallVec<B>> for SmallVec<A> where
A::Item: PartialEq<B::Item>,` [src]

#### `fn eq(&self, other: &SmallVec<B>) -> bool` [src]

This method tests for `self` and `other` values to be equal, and is used by `==`. Read more

#### `#[must_use]pub fn ne(&self, other: &Rhs) -> bool` 1.0.0 [src]

This method tests for `!=`.

### `impl<A: Array> PartialOrd<SmallVec<A>> for SmallVec<A> where
A::Item: PartialOrd,` [src]

#### `fn partial_cmp(&self, other: &SmallVec<A>) -> Option<Ordering>` [src]

This method returns an ordering between `self` and `other` values if one exists. Read more

#### `#[must_use]pub fn lt(&self, other: &Rhs) -> bool` 1.0.0 [src]

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

#### `#[must_use]pub fn le(&self, other: &Rhs) -> bool` 1.0.0 [src]

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

#### `#[must_use]pub fn gt(&self, other: &Rhs) -> bool` 1.0.0 [src]

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

#### `#[must_use]pub fn ge(&self, other: &Rhs) -> bool` 1.0.0 [src]

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<A: Array> Send for SmallVec<A> where
A::Item: Send,` [src]

## Auto Trait Implementations

### `impl<A> Sync for SmallVec<A> where
A: Sync,`

### `impl<A> Unpin for SmallVec<A> where
A: Unpin,`

## Blanket Implementations

### `impl<T> Any for T where
T: 'static + ?Sized,` [src]

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

### `impl<T> Borrow<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

### `impl<T> BorrowMut<T> for T where
T: ?Sized,` [src]

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<!> for T` [src]

#### `pub fn from(t: !) -> T` [src]

Performs the conversion.

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

### `impl<T, U> Into<U> for T where
U: From<T>,` [src]

#### `pub fn into(self) -> U` [src]

Performs the conversion.

### `impl<T> ToOwned for T where
T: Clone,` [src]

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `pub fn to_owned(&self) -> T` [src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `pub fn clone_into(&self, target: &mut T)` [src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into`)

recently added

Uses borrowed data to replace owned data, usually by cloning. Read more

### `impl<T, U> TryFrom<U> for T where
U: Into<T>,` [src]

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

### `impl<T, U> TryInto<U> for T where
U: TryFrom<T>,` [src]

#### `type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.