# tinyvec::ArrayVec - Rust
API documentation for the Rust `ArrayVec` struct in crate `tinyvec`.
Keywords: rust, rustlang, rust-lang, ArrayVec

# Struct tinyvec::ArrayVec [−] [src]

    #[repr(C)]pub struct ArrayVec<A> { /* fields omitted */ }

An array-backed, vector-like data structure.

- `ArrayVec` has a fixed capacity, equal to the array size.
- `ArrayVec` has a variable length, as you add and remove elements. Attempts to fill the vec beyond its capacity will cause a panic.
- All of the vec's array slots are always initialized in terms of Rust's memory model. When you remove a element from a location, the old value at that location is replaced with the type's default value.

The overall API of this type is intended to, as much as possible, emulate the API of the `Vec` type.

## Construction

You can use the `array_vec!` macro similarly to how you might use the `vec!` macro. Specify the array type, then optionally give all the initial values you want to have.

    let some_ints = array_vec!([i32; 4] => 1, 2, 3);
    assert_eq!(some_ints.len(), 3);

The `default` for an `ArrayVec` is to have a default array with length 0. The `new` method is the same as calling `default`

    let some_ints = ArrayVec::<[i32; 7]>::default();
    assert_eq!(some_ints.len(), 0);

    let more_ints = ArrayVec::<[i32; 7]>::new();
    assert_eq!(some_ints, more_ints);

If you have an array and want the whole thing so count as being "in" the new `ArrayVec` you can use one of the `from` implementations. If you want part of the array then you can use `from_array_len`:

    let some_ints = ArrayVec::from([5, 6, 7, 8]);
    assert_eq!(some_ints.len(), 4);

    let more_ints = ArrayVec::from_array_len([5, 6, 7, 8], 2);
    assert_eq!(more_ints.len(), 2);

    let no_ints: ArrayVec<[u8; 5]> = ArrayVec::from_array_empty([1, 2, 3, 4, 5]);
    assert_eq!(no_ints.len(), 0);

## Implementations

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

#### `pub fn append(&mut self, other: &mut Self)` [src]

Move all values from `other` into this vec.

## Panics

- If the vec overflows its capacity

## Example

    let mut av = array_vec!([i32; 10] => 1, 2, 3);
    let mut av2 = array_vec!([i32; 10] => 4, 5, 6);
    av.append(&mut av2);
    assert_eq!(av, &[1, 2, 3, 4, 5, 6][..]);
    assert_eq!(av2, &[][..]);

#### `pub fn try_append<'other>(
&mut self,
other: &'other mut Self
) -> Option<&'other mut Self>` [src]

Move all values from `other` into this vec. If appending would overflow the capacity, Some(other) is returned.

## Example

    let mut av = array_vec!([i32; 7] => 1, 2, 3);
    let mut av2 = array_vec!([i32; 7] => 4, 5, 6);
    av.append(&mut av2);
    assert_eq!(av, &[1, 2, 3, 4, 5, 6][..]);
    assert_eq!(av2, &[][..]);

    let mut av3 = array_vec!([i32; 7] => 7, 8, 9);
    assert!(av.try_append(&mut av3).is_some());
    assert_eq!(av, &[1, 2, 3, 4, 5, 6][..]);
    assert_eq!(av3, &[7, 8, 9][..]);

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

A `*mut` pointer to the backing array.

## Safety

This pointer has provenance over the entire backing array.

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

Performs a `deref_mut`, into unique slice form.

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

A `*const` pointer to the backing array.

## Safety

This pointer has provenance over the entire backing array.

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

Performs a `deref`, into shared slice form.

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

The capacity of the `ArrayVec`.

This is fixed based on the array type, but can't yet be made a `const fn` on Stable Rust.

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

Truncates the `ArrayVec` down to length 0.

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

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

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

Creates a draining iterator that removes the specified range in the vector and yields the removed items.

## Panics

- If the start is greater than the end
- If the end is past the edge of the vec.

## Example

    let mut av = array_vec!([i32; 4] => 1, 2, 3);
    let av2: ArrayVec<[i32; 4]> = av.drain(1..).collect();
    assert_eq!(av.as_slice(), &[1][..]);
    assert_eq!(av2.as_slice(), &[2, 3][..]);

    av.drain(..);
    assert_eq!(av.as_slice(), &[]);

#### `pub fn into_inner(self) -> A` [src]

Returns the inner array of the `ArrayVec`.

This returns the full array, even if the `ArrayVec` length is currently less than that.

## Example

    let mut favorite_numbers = array_vec!([i32; 5] => 87, 48, 33, 9, 26);
    assert_eq!(favorite_numbers.clone().into_inner(), [87, 48, 33, 9, 26]);

    favorite_numbers.pop();
    assert_eq!(favorite_numbers.into_inner(), [87, 48, 33, 9, 0]);

A use for this function is to build an array from an iterator by first collecting it into an `ArrayVec`.

    let arr_vec: ArrayVec<[i32; 10]> = (1..=3).cycle().take(10).collect();
    let inner = arr_vec.into_inner();
    assert_eq!(inner, [1, 2, 3, 1, 2, 3, 1, 2, 3, 1]);

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

Clone each element of the slice into this `ArrayVec`.

## Panics

- If the `ArrayVec` would overflow, this will panic.

#### `pub fn fill<I: IntoIterator<Item = A::Item>>(&mut self, iter: I) -> I::IntoIter` [src]

Fill the vector until its capacity has been reached.

Successively fills unused space in the spare slice of the vector with elements from the iterator. It then returns the remaining iterator without exhausting it. This also allows appending the head of an infinite iterator.

This is an alternative to `Extend::extend` method for cases where the length of the iterator can not be checked. Since this vector can not reallocate to increase its capacity, it is unclear what to do with remaining elements in the iterator and the iterator itself. The interface also provides no way to communicate this to the caller.

## Panics

- If the `next` method of the provided iterator panics.

## Example

    let mut av = array_vec!([i32; 4]);
    let mut to_inf = av.fill(0..);
    assert_eq!(&av[..], [0, 1, 2, 3]);
    assert_eq!(to_inf.next(), Some(4));

#### `#[must_use]pub fn from_array_len(data: A, len: usize) -> Self` [src]

Wraps up an array and uses the given length as the initial length.

If you want to simply use the full array, use `from` instead.

## Panics

- The length specified must be less than or equal to the capacity of the array.

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

Inserts an item at the position given, moving all following elements +1 index.

## Panics

- If `index` > `len`
- If the capacity is exhausted

## Example

    use tinyvec::*;
    let mut av = array_vec!([i32; 10] => 1, 2, 3);
    av.insert(1, 4);
    assert_eq!(av.as_slice(), &[1, 4, 2, 3]);
    av.insert(4, 5);
    assert_eq!(av.as_slice(), &[1, 4, 2, 3, 5]);

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

Tries to insert an item at the position given, moving all following elements +1 index. Returns back the element if the capacity is exhausted, otherwise returns None.

## Panics

- If `index` > `len`

## Example

    use tinyvec::*;
    let mut av = array_vec!([&'static str; 4] => "one", "two", "three");
    av.insert(1, "four");
    assert_eq!(av.as_slice(), &["one", "four", "two", "three"]);
    assert_eq!(av.try_insert(4, "five"), Some("five"));

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

Checks if the length is 0.

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

The length of the `ArrayVec` (in elements).

#### `#[must_use]pub fn new() -> Self` [src]

Makes a new, empty `ArrayVec`.

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

Remove and return the last element of the vec, if there is one.

## Failure

- If the vec is empty you get `None`.

## Example

    let mut av = array_vec!([i32; 10] => 1, 2);
    assert_eq!(av.pop(), Some(2));
    assert_eq!(av.pop(), Some(1));
    assert_eq!(av.pop(), None);

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

Place an element onto the end of the vec.

## Panics

- If the length of the vec would overflow the capacity.

## Example

    let mut av = array_vec!([i32; 2]);
    assert_eq!(&av[..], []);
    av.push(1);
    assert_eq!(&av[..], [1]);
    av.push(2);
    assert_eq!(&av[..], [1, 2]);
    // av.push(3); this would overflow the ArrayVec and panic!

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

Tries to place an element onto the end of the vec.
Returns back the element if the capacity is exhausted, otherwise returns None.

    let mut av = array_vec!([i32; 2]);
    assert_eq!(av.as_slice(), []);
    assert_eq!(av.try_push(1), None);
    assert_eq!(&av[..], [1]);
    assert_eq!(av.try_push(2), None);
    assert_eq!(&av[..], [1, 2]);
    assert_eq!(av.try_push(3), Some(3));

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

Removes the item at `index`, shifting all others down by one index.

Returns the removed element.

## Panics

- If the index is out of bounds.

## Example

    let mut av = array_vec!([i32; 4] => 1, 2, 3);
    assert_eq!(av.remove(1), 2);
    assert_eq!(&av[..], [1, 3]);

#### `pub fn resize(&mut self, new_len: usize, new_val: A::Item) where
A::Item: Clone,` [src]

As `resize_with` and it clones the value as the closure.

## Example

    let mut av = array_vec!([&str; 10] => "hello");
    av.resize(3, "world");
    assert_eq!(&av[..], ["hello", "world", "world"]);

    let mut av = array_vec!([i32; 10] => 1, 2, 3, 4);
    av.resize(2, 0);
    assert_eq!(&av[..], [1, 2]);

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

Resize the vec to the new length.

If it needs to be longer, it's filled with repeated calls to the provided function. If it needs to be shorter, it's truncated.

## Example

    let mut av = array_vec!([i32; 10] => 1, 2, 3);
    av.resize_with(5, Default::default);
    assert_eq!(&av[..], [1, 2, 3, 0, 0]);

    let mut av = array_vec!([i32; 10]);
    let mut p = 1;
    av.resize_with(4, || {
      p *= 2;
      p
    });
    assert_eq!(&av[..], [2, 4, 8, 16]);

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

Walk the vec and keep only the elements that pass the predicate given.

## Example

    let mut av = array_vec!([i32; 10] => 1, 1, 2, 3, 3, 4);
    av.retain(|&x| x % 2 == 0);
    assert_eq!(&av[..], [2, 4]);

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

Forces the length of the vector to `new_len`.

## Panics

- If `new_len` is greater than the vec's capacity.

## Safety

- This is a fully safe operation! The inactive memory already counts as "initialized" by Rust's rules.
- Other than "the memory is initialized" there are no other guarantees regarding what you find in the inactive portion of the vec.

#### `pub fn split_off(&mut self, at: usize) -> Self` [src]

Splits the collection at the point given.

- `[0, at)` stays in this vec
- `[at, len)` ends up in the new vec.

## Panics

- if at > len

## Example

    let mut av = array_vec!([i32; 4] => 1, 2, 3);
    let av2 = av.split_off(1);
    assert_eq!(&av[..], [1]);
    assert_eq!(&av2[..], [2, 3]);

#### `pub fn splice<R, I>(
&mut self,
range: R,
replacement: I
) -> ArrayVecSplice<'_, A, Fuse<I::IntoIter>>ⓘ

### Notable traits for ArrayVecSplice<'p, A, I>

`impl<'p, A: Array, I: Iterator<Item = A::Item>> Iterator for ArrayVecSplice<'p, A, I> type Item = A::Item;`
where
R: RangeBounds<usize>,
I: IntoIterator<Item = A::Item>,` [src]

Creates a splicing iterator that removes the specified range in the vector, yields the removed items, and replaces them with elements from the provided iterator.

`splice` fuses the provided iterator, so elements after the first `None` are ignored.

## Panics

- If the start is greater than the end.
- If the end is past the edge of the vec.
- If the provided iterator panics.
- If the new length would overflow the capacity of the array. Because `ArrayVecSplice` adds elements to this vec in its destructor when necessary, this panic would occur when it is dropped.

## Example

    use tinyvec::*;
    let mut av = array_vec!([i32; 4] => 1, 2, 3);
    let av2: ArrayVec<[i32; 4]> = av.splice(1.., 4..=6).collect();
    assert_eq!(av.as_slice(), &[1, 4, 5, 6][..]);
    assert_eq!(av2.as_slice(), &[2, 3][..]);

    av.splice(.., None);
    assert_eq!(av.as_slice(), &[]);

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

Remove an element, swapping the end of the vec into its place.

## Panics

- If the index is out of bounds.

## Example

    let mut av = array_vec!([&str; 4] => "foo", "bar", "quack", "zap");

    assert_eq!(av.swap_remove(1), "bar");
    assert_eq!(&av[..], ["foo", "zap", "quack"]);

    assert_eq!(av.swap_remove(0), "foo");
    assert_eq!(&av[..], ["quack", "zap"]);

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

Reduces the vec's length to the given value.

If the vec is already shorter than the input, nothing happens.

#### `pub fn try_from_array_len(data: A, len: usize) -> Result<Self, A>` [src]

Wraps an array, using the given length as the starting length.

If you want to use the whole length of the array, you can just use the `From` impl.

## Failure

If the given length is greater than the capacity of the array this will error, and you'll get the array back in the `Err`.

### `impl<A> ArrayVec<A>` [src]

#### `#[must_use]pub const fn from_array_empty(data: A) -> Self` [src]

Wraps up an array as a new empty `ArrayVec`.

If you want to simply use the full array, use `from` instead.

## Examples

This method in particular allows to create values for statics:

    static DATA: ArrayVec<[u8; 5]> = ArrayVec::from_array_empty([0; 5]);
    assert_eq!(DATA.len(), 0);

But of course it is just an normal empty `ArrayVec`:

    let mut data = ArrayVec::from_array_empty([1, 2, 3, 4]);
    assert_eq!(&data[..], &[]);
    data.push(42);
    assert_eq!(&data[..], &[42]);

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

#### `pub fn drain_to_vec_and_reserve(&mut self, n: usize) -> Vec<A::Item>` [src]

Drains all elements to a Vec, but reserves additional space

    let mut av = array_vec!([i32; 7] => 1, 2, 3);
    let v = av.drain_to_vec_and_reserve(10);
    assert_eq!(v, &[1, 2, 3]);
    assert_eq!(v.capacity(), 13);

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

Drains all elements to a Vec

    let mut av = array_vec!([i32; 7] => 1, 2, 3);
    let v = av.drain_to_vec();
    assert_eq!(v, &[1, 2, 3]);
    assert_eq!(v.capacity(), 3);

## Trait Implementations

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

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

Performs the conversion.

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

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

Performs the conversion.

### `impl<A: Array> Binary for ArrayVec<A> where
A::Item: Binary,` [src]

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

Formats the value using the given formatter.

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

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

Immutably borrows from an owned value. Read more

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

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

Mutably borrows from an owned value. Read more

### `impl<A: Clone> Clone for ArrayVec<A>` [src]

#### `fn clone(&self) -> ArrayVec<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: Copy> Copy for ArrayVec<A>` [src]

### `impl<A: Array> Debug for ArrayVec<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 ArrayVec<A>` [src]

#### `fn default() -> Self` [src]

Returns the "default value" for a type. Read more

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

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

The resulting type after dereferencing.

#### `#[must_use]fn deref(&self) -> &Self::Target` [src]

Dereferences the value.

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

#### `#[must_use]fn deref_mut(&mut self) -> &mut Self::Target` [src]

Mutably dereferences the value.

### `impl<A: Array> Display for ArrayVec<A> where
A::Item: Display,` [src]

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

Formats the value using the given formatter. Read more

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

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

#### `fn extend<T: IntoIterator<Item = A::Item>>(&mut self, iter: T)` [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: Array> From<A> for ArrayVec<A>` [src]

#### `#[must_use]fn from(data: A) -> Self` [src]

The output has a length equal to the full array.

If you want to select a length, use `from_array_len`

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

#### `#[must_use]fn from(arr: ArrayVec<A>) -> Self` [src]

Performs the conversion.

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

#### `#[must_use]fn from_iter<T: IntoIterator<Item = A::Item>>(iter: T) -> Self` [src]

Creates a value from an iterator. Read more

### `impl<A: Array> Hash for ArrayVec<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 ArrayVec<A>` [src]

#### `type Output = <I as SliceIndex<[A::Item]>>::Output`

The returned type after indexing.

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

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

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

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

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

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

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

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

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

Creates an iterator from a value. Read more

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

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

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

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

Creates an iterator from a value. Read more

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

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

The type of the elements being iterated over.

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

Which kind of iterator are we turning this into?

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

Creates an iterator from a value. Read more

### `impl<A: Array> LowerExp for ArrayVec<A> where
A::Item: LowerExp,` [src]

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

Formats the value using the given formatter.

### `impl<A: Array> LowerHex for ArrayVec<A> where
A::Item: LowerHex,` [src]

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

Formats the value using the given formatter.

### `impl<A: Array> Octal for ArrayVec<A> where
A::Item: Octal,` [src]

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

Formats the value using the given formatter.

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

#### `#[must_use]fn cmp(&self, other: &Self) -> 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> PartialEq<&'_ [<A as Array>::Item]> for ArrayVec<A> where
A::Item: PartialEq,` [src]

#### `#[must_use]fn eq(&self, other: &&[A::Item]) -> 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> PartialEq<&'_ A> for ArrayVec<A> where
A::Item: PartialEq,` [src]

#### `#[must_use]fn eq(&self, other: &&A) -> 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> PartialEq<ArrayVec<A>> for ArrayVec<A> where
A::Item: PartialEq,` [src]

#### `#[must_use]fn eq(&self, other: &Self) -> 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<ArrayVec<A>> for ArrayVec<A> where
A::Item: PartialOrd,` [src]

#### `#[must_use]fn partial_cmp(&self, other: &Self) -> 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> Pointer for ArrayVec<A> where
A::Item: Pointer,` [src]

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

Formats the value using the given formatter.

### `impl<T, A> TryFrom<&'_ [T]> for ArrayVec<A> where
T: Clone + Default,
A: Array<Item = T>,` [src]

#### `type Error = TryFromSliceError`

The type returned in the event of a conversion error.

#### `#[must_use]fn try_from(slice: &[T]) -> Result<Self, Self::Error>` [src]

The output has a length equal to that of the slice, with the same capacity as `A`.

### `impl<A: Array> UpperExp for ArrayVec<A> where
A::Item: UpperExp,` [src]

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

Formats the value using the given formatter.

### `impl<A: Array> UpperHex for ArrayVec<A> where
A::Item: UpperHex,` [src]

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

Formats the value using the given formatter.

## Auto Trait Implementations

### `impl<A> Send for ArrayVec<A> where
A: Send,` [src]

### `impl<A> Sync for ArrayVec<A> where
A: Sync,` [src]

### `impl<A> Unpin for ArrayVec<A> where
A: Unpin,` [src]

## 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<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> ToString for T where
T: Display + ?Sized,` [src]

#### `pub default fn to_string(&self) -> String` [src]

Converts the given value to a `String`. 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.