Struct heapless::Vec

pub struct Vec<T, N>(_)
 where
    N: ArrayLength<T>;

A fixed capacity Vec

Examples

use heapless::Vec;
use heapless::consts::*;

// A vector with a fixed capacity of 8 elements allocated on the stack
let mut vec = Vec::<_, U8>::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]);

Methods

impl<T, N> Vec<T, N> where
    N: ArrayLength<T>, 

pub fn new() -> Self

Constructs a new, empty vector with a fixed capacity of N

Examples

use heapless::Vec;
use heapless::consts::*;

// allocate the vector on the stack
let mut x: Vec<u8, U16> = Vec::new();

// allocate the vector in a static variable
static mut X: Vec<u8, U16> = Vec(heapless::i::Vec::new());

pub fn capacity(&self) -> usize

Returns the maximum number of elements the vector can hold

pub fn clear(&mut self)

Clears the vector, removing all values.

pub fn extend_from_slice(&mut self, other: &[T]) -> Result<(), ()> where
    T: Clone, 

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.

Examples

use heapless::Vec;
use heapless::consts::*;

let mut vec = Vec::<u8, U8>::new();
vec.push(1).unwrap();
vec.extend_from_slice(&[2, 3, 4]).unwrap();
assert_eq!(*vec, [1, 2, 3, 4]);

pub fn pop(&mut self) -> Option<T>

Removes the last element from a vector and return it, or None if it's empty

pub fn push(&mut self, item: T) -> Result<(), T>

Appends an item to the back of the collection

Returns back the item if the vector is full

pub fn truncate(&mut self, len: usize)

Shortens the vector, keeping the first len elements and dropping the rest.

pub fn resize(&mut self, new_len: usize, value: T) -> Result<(), ()> where
    T: Clone, 

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.

See also resize_default.

pub fn resize_default(&mut self, new_len: usize) -> Result<(), ()> where
    T: Clone + Default, 

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.

See also resize.

pub fn swap_remove(&mut self, index: usize) -> T

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

use heapless::Vec;
use heapless::consts::*;

let mut v: Vec<_, U8> = Vec::new();
v.push("foo").unwrap();
v.push("bar").unwrap();
v.push("baz").unwrap();
v.push("qux").unwrap();

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"]);

Trait Implementations

impl<A, B, N1, N2> PartialEq<Vec<B, N2>> for Vec<A, N1> where
    N1: ArrayLength<A>,
    N2: ArrayLength<B>,
    A: PartialEq<B>, 

fn eq(&self, other: &Vec<B, N2>) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a mut [B]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a mut [B]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 0]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 0]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 0]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 0]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 1]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 1]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 1]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 1]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 2]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 2]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 2]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 2]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 3]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 3]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 3]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 3]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 4]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 4]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 4]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 4]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 5]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 5]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 5]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 5]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 6]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 6]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 6]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 6]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 7]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 7]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 7]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 7]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 8]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 8]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 8]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 8]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 9]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 9]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 9]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 9]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 10]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 10]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 10]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 10]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 11]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 11]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 11]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 11]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 12]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 12]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 12]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 12]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 13]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 13]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 13]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 13]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 14]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 14]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 14]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 14]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 15]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 15]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 15]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 15]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 16]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 16]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 16]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 16]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 17]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 17]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 17]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 17]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 18]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 18]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 18]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 18]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 19]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 19]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 19]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 19]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 20]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 20]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 20]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 20]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 21]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 21]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 21]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 21]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 22]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 22]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 22]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 22]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 23]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 23]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 23]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 23]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 24]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 24]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 24]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 24]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 25]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 25]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 25]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 25]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 26]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 26]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 26]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 26]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 27]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 27]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 27]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 27]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 28]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 28]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 28]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 28]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 29]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 29]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 29]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 29]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 30]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 30]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 30]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 30]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 31]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 31]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 31]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 31]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<[B; 32]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &[B; 32]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'a, 'b, A, B, N> PartialEq<&'a [B; 32]> for Vec<A, N> where
    A: PartialEq<B>,
    N: ArrayLength<A>, 

fn eq(&self, other: &&'a [B; 32]) -> bool

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

#[must_use]

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T, N> Eq for Vec<T, N> where
    N: ArrayLength<T>,
    T: Eq, 

impl<T, N> Debug for Vec<T, N> where
    T: Debug,
    N: ArrayLength<T>, 

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T, N> Deref for Vec<T, N> where
    N: ArrayLength<T>, 

type Target = [T]

The resulting type after dereferencing.

fn deref(&self) -> &[T]

Dereferences the value.

impl<T, N> DerefMut for Vec<T, N> where
    N: ArrayLength<T>, 

fn deref_mut(&mut self) -> &mut [T]

Mutably dereferences the value.

impl<T, N> Drop for Vec<T, N> where
    N: ArrayLength<T>, 

fn drop(&mut self)

Executes the destructor for this type.

impl<T, N> Hash for Vec<T, N> where
    T: Hash,
    N: ArrayLength<T>, 

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<T, N> Extend<T> for Vec<T, N> where
    N: ArrayLength<T>, 

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = T>, 

Extends a collection with the contents of an iterator.

impl<'a, T, N> Extend<&'a T> for Vec<T, N> where
    T: 'a + Copy,
    N: ArrayLength<T>, 

fn extend<I>(&mut self, iter: I) where
    I: IntoIterator<Item = &'a T>, 

Extends a collection with the contents of an iterator.

impl<T, N> FromIterator<T> for Vec<T, N> where
    N: ArrayLength<T>, 

fn from_iter<I>(iter: I) -> Self where
    I: IntoIterator<Item = T>, 

Creates a value from an iterator.

impl<'a, T, N> IntoIterator for &'a Vec<T, N> where
    N: ArrayLength<T>, 

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?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, N> IntoIterator for &'a mut Vec<T, N> where
    N: ArrayLength<T>, 

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?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, N> IntoIterator for Vec<T, N> where
    N: ArrayLength<T>, 

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, N> AsRef<Vec<T, N>> for Vec<T, N> where
    N: ArrayLength<T>, 

fn as_ref(&self) -> &Self

Performs the conversion.

impl<T, N> AsRef<[T]> for Vec<T, N> where
    N: ArrayLength<T>, 

fn as_ref(&self) -> &[T]

Performs the conversion.

impl<T, N> AsMut<Vec<T, N>> for Vec<T, N> where
    N: ArrayLength<T>, 

fn as_mut(&mut self) -> &mut Self

Performs the conversion.

impl<T, N> AsMut<[T]> for Vec<T, N> where
    N: ArrayLength<T>, 

fn as_mut(&mut self) -> &mut [T]

Performs the conversion.

impl<T, N> Clone for Vec<T, N> where
    N: ArrayLength<T>,
    T: Clone, 

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, N> Default for Vec<T, N> where
    N: ArrayLength<T>, 

fn default() -> Self

Returns the "default value" for a type.

impl<T, N> Hash for Vec<T, N> where
    T: Hash,
    N: ArrayLength<T>, 

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.