[][src]Struct heapless::Vec

pub struct Vec<T, N> where
    N: ArrayLength<T>, 
{ /* fields omitted */ }

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>, 
[src]

pub fn new() -> Self[src]

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

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

Returns the maximum number of elements the vector can hold

pub fn clear(&mut self)[src]

Clears the vector, removing all values.

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

Clones and appends all elements in a slice to the Vec.

Iterates over the slice other, clones each element, and then appends it to this Vec. The other vector is traversed in-order.

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>[src]

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>[src]

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)[src]

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
[src]

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

If new_len is greater than len, the Vec is extended by the difference, with each additional slot filled with value. If new_len is less than len, the Vec is simply truncated.

See also resize_default.

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

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

If new_len is greater than len, the Vec is extended by the difference, with each additional slot filled with 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[src]

Removes an element from the vector and returns it.

The removed element is replaced by the last element of the vector.

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

Panics

Panics if index is out of bounds.

Examples

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

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

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

This method tests for !=.

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

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

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>, 
[src]

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

This method tests for !=.

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

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

type Target = [T]

The resulting type after dereferencing.

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

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

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

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

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

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

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

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

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

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?

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

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

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

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

Performs copy-assignment from source. Read more

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

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

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

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

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

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

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

Feeds a slice of this type into the given Hasher.

Auto Trait Implementations

impl<T, N> Send for Vec<T, N> where
    T: Send

impl<T, N> Sync for Vec<T, N> where
    T: Sync

Blanket Implementations

impl<T> From for T[src]

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

type Error = Infallible

The type returned in the event of a conversion error.

impl<I> IntoIterator for I where
    I: Iterator
[src]

type Item = <I as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = I

Which kind of iterator are we turning this into?

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

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

The type returned in the event of a conversion error.

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

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

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

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

impl<T> Same for T[src]

type Output = T

Should always be Self