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 from_slice(other: &[T]) -> Result<Self, ()> where
    T: Clone, 

Constructs a new vector with a fixed capacity of N and fills it with the provided slice.

This is equivalent to the following code:

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

let mut v: Vec<u8, U16> = Vec::new();
v.extend_from_slice(&[1, 2, 3]).unwrap();

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

pub fn starts_with(&self, needle: &[T]) -> bool where
    T: PartialEq, 

Returns true if needle is a prefix of the Vec.

Always returns true if needle is an empty slice.

Examples

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

let v: Vec<_, U8> = Vec::from_slice(b"abc").unwrap();
assert_eq!(v.starts_with(b""), true);
assert_eq!(v.starts_with(b"ab"), true);
assert_eq!(v.starts_with(b"bc"), false);

pub fn ends_with(&self, needle: &[T]) -> bool where
    T: PartialEq, 

Returns true if needle is a suffix of the Vec.

Always returns true if needle is an empty slice.

Examples

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

let v: Vec<_, U8> = Vec::from_slice(b"abc").unwrap();
assert_eq!(v.ends_with(b""), true);
assert_eq!(v.ends_with(b"ab"), false);
assert_eq!(v.ends_with(b"bc"), true);

Trait Implementations

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> 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> AsRef<[T]> for Vec<T, N> where
    N: ArrayLength<T>, 

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

Performs the conversion.

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> 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> 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> Default for Vec<T, N> where
    N: ArrayLength<T>, 

fn default() -> Self

Returns the "default value" for a type.

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> Eq for Vec<T, N> where
    N: ArrayLength<T>,
    T: Eq, 

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> 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<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<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> 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<'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<'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<&'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<&'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<&'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<&'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<&'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<&'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<&'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<&'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<&'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<&'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<&'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<&'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<&'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<&'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<&'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<&'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<&'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<&'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<&'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<&'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<&'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<&'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<&'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<&'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<&'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<&'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<'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<&'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<&'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<&'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<&'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<&'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<&'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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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<[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, 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<N> Write for Vec<u8, N> where
    N: ArrayLength<u8>, 

fn write_str(&mut self, s: &str) -> Result

Writes a string slice into this writer, returning whether the write succeeded.

fn write_char(&mut self, c: char) -> Result<(), Error>

Writes a [char] into this writer, returning whether the write succeeded.

fn write_fmt(&mut self, args: Arguments) -> Result<(), Error>

Glue for usage of the [write!] macro with implementors of this trait.