collections::vec_deque::VecDeque - Rust
Description: API documentation for the Rust `VecDeque` struct in crate `collections`.
Keywords: rust, rustlang, rust-lang, VecDeque

# Struct collections::vec_deque::VecDeque 1.0.0 [−] [src]

    pub struct VecDeque<T> { /* fields omitted */ }

A double-ended queue implemented with a growable ring buffer.

The "default" usage of this type as a queue is to use `push_back` to add to the queue, and `pop_front` to remove from the queue. `extend` and `append` push onto the back in this manner, and iterating over `VecDeque` goes front to back.

## Methods

### `impl<T> VecDeque<T>`
[src]

#### `fn new() -> VecDeque<T>`

Creates an empty `VecDeque`.

# Examples

    use std::collections::VecDeque;

    let vector: VecDeque<u32> = VecDeque::new();

#### `fn with_capacity(n: usize) -> VecDeque<T>`

Creates an empty `VecDeque` with space for at least `n` elements.

# Examples

    use std::collections::VecDeque;

    let vector: VecDeque<u32> = VecDeque::with_capacity(10);

#### `fn get(&self, index: usize) -> Option<&T>`

Retrieves an element in the `VecDeque` by index.

Element at index 0 is the front of the queue.

# Examples

    use std::collections::VecDeque;

    let mut buf = VecDeque::new();
    buf.push_back(3);
    buf.push_back(4);
    buf.push_back(5);
    assert_eq!(buf.get(1), Some(&4));

#### `fn get_mut(&mut self, index: usize) -> Option<&mut T>`

Retrieves an element in the `VecDeque` mutably by index.

Element at index 0 is the front of the queue.

# Examples

    use std::collections::VecDeque;

    let mut buf = VecDeque::new();
    buf.push_back(3);
    buf.push_back(4);
    buf.push_back(5);
    if let Some(elem) = buf.get_mut(1) {
        *elem = 7;
    }

    assert_eq!(buf[1], 7);

#### `fn swap(&mut self, i: usize, j: usize)`

Swaps elements at indices `i` and `j`.

`i` and `j` may be equal.

Fails if there is no element with either index.

Element at index 0 is the front of the queue.

# Examples

    use std::collections::VecDeque;

    let mut buf = VecDeque::new();
    buf.push_back(3);
    buf.push_back(4);
    buf.push_back(5);
    assert_eq!(buf, [3, 4, 5]);
    buf.swap(0, 2);
    assert_eq!(buf, [5, 4, 3]);

#### `fn capacity(&self) -> usize`

Returns the number of elements the `VecDeque` can hold without reallocating.

# Examples

    use std::collections::VecDeque;

    let buf: VecDeque<i32> = VecDeque::with_capacity(10);
    assert!(buf.capacity() >= 10);

#### `fn reserve_exact(&mut self, additional: usize)`

Reserves the minimum capacity for exactly `additional` more elements to be inserted in the given `VecDeque`. Does nothing if the capacity is already sufficient.

Note that the allocator may give the collection more space than it requests. Therefore capacity can not be relied upon to be precisely minimal. Prefer `reserve` if future insertions are expected.

# Panics

Panics if the new capacity overflows `usize`.

# Examples

    use std::collections::VecDeque;

    let mut buf: VecDeque<i32> = vec![1].into_iter().collect();
    buf.reserve_exact(10);
    assert!(buf.capacity() >= 11);

#### `fn reserve(&mut self, additional: usize)`

Reserves capacity for at least `additional` more elements to be inserted in the given `VecDeque`. The collection may reserve more space to avoid frequent reallocations.

# Panics

Panics if the new capacity overflows `usize`.

# Examples

    use std::collections::VecDeque;

    let mut buf: VecDeque<i32> = vec![1].into_iter().collect();
    buf.reserve(10);
    assert!(buf.capacity() >= 11);

#### `fn shrink_to_fit(&mut self)`
1.5.0

Shrinks the capacity of the `VecDeque` as much as possible.

It will drop down as close as possible to the length but the allocator may still inform the `VecDeque` that there is space for a few more elements.

# Examples

    use std::collections::VecDeque;

    let mut buf = VecDeque::with_capacity(15);
    buf.extend(0..4);
    assert_eq!(buf.capacity(), 15);
    buf.shrink_to_fit();
    assert!(buf.capacity() >= 4);

#### `fn truncate(&mut self, len: usize)`
1.16.0

Shortens the `VecDeque`, dropping excess elements from the back.

If `len` is greater than the `VecDeque`'s current length, this has no effect.

# Examples

    use std::collections::VecDeque;

    let mut buf = VecDeque::new();
    buf.push_back(5);
    buf.push_back(10);
    buf.push_back(15);
    assert_eq!(buf, [5, 10, 15]);
    buf.truncate(1);
    assert_eq!(buf, [5]);

#### `fn iter(&self) -> Iter<T>`

Returns a front-to-back iterator.

# Examples

    use std::collections::VecDeque;

    let mut buf = VecDeque::new();
    buf.push_back(5);
    buf.push_back(3);
    buf.push_back(4);
    let b: &[_] = &[&5, &3, &4];
    let c: Vec<&i32> = buf.iter().collect();
    assert_eq!(&c[..], b);

#### `fn iter_mut(&mut self) -> IterMut<T>`

Returns a front-to-back iterator that returns mutable references.

# Examples

    use std::collections::VecDeque;

    let mut buf = VecDeque::new();
    buf.push_back(5);
    buf.push_back(3);
    buf.push_back(4);
    for num in buf.iter_mut() {
        *num = *num - 2;
    }
    let b: &[_] = &[&mut 3, &mut 1, &mut 2];
    assert_eq!(&buf.iter_mut().collect::<Vec<&mut i32>>()[..], b);

#### `fn as_slices(&self) -> (&[T], &[T])`
1.5.0

Returns a pair of slices which contain, in order, the contents of the `VecDeque`.

# Examples

    use std::collections::VecDeque;

    let mut vector = VecDeque::new();

    vector.push_back(0);
    vector.push_back(1);
    vector.push_back(2);

    assert_eq!(vector.as_slices(), (&[0, 1, 2][..], &[][..]));

    vector.push_front(10);
    vector.push_front(9);

    assert_eq!(vector.as_slices(), (&[9, 10][..], &[0, 1, 2][..]));

#### `fn as_mut_slices(&mut self) -> (&mut [T], &mut [T])`
1.5.0

Returns a pair of slices which contain, in order, the contents of the `VecDeque`.

# Examples

    use std::collections::VecDeque;

    let mut vector = VecDeque::new();

    vector.push_back(0);
    vector.push_back(1);

    vector.push_front(10);
    vector.push_front(9);

    vector.as_mut_slices().0[0] = 42;
    vector.as_mut_slices().1[0] = 24;
    assert_eq!(vector.as_slices(), (&[42, 10][..], &[24, 1][..]));

#### `fn len(&self) -> usize`

Returns the number of elements in the `VecDeque`.

# Examples

    use std::collections::VecDeque;

    let mut v = VecDeque::new();
    assert_eq!(v.len(), 0);
    v.push_back(1);
    assert_eq!(v.len(), 1);

#### `fn is_empty(&self) -> bool`

Returns `true` if the `VecDeque` is empty.

# Examples

    use std::collections::VecDeque;

    let mut v = VecDeque::new();
    assert!(v.is_empty());
    v.push_front(1);
    assert!(!v.is_empty());

#### `fn drain<R>(&mut self, range: R) -> Drain<T> where
R: RangeArgument<usize>,`
1.6.0

Create a draining iterator that removes the specified range in the `VecDeque` and yields the removed items.

Note 1: The element range is removed even if the iterator is not consumed until the end.

Note 2: It is unspecified how many elements are removed from the deque, if the `Drain` value is not dropped, but the borrow it holds expires (eg. due to mem::forget).

# Panics

Panics if the starting point is greater than the end point or if the end point is greater than the length of the vector.

# Examples

    use std::collections::VecDeque;

    let mut v: VecDeque<_> = vec![1, 2, 3].into_iter().collect();
    let drained = v.drain(2..).collect::<VecDeque<_>>();
    assert_eq!(drained, [3]);
    assert_eq!(v, [1, 2]);

    // A full range clears all contents
    v.drain(..);
    assert!(v.is_empty());

#### `fn clear(&mut self)`

Clears the buffer, removing all values.

# Examples

    use std::collections::VecDeque;

    let mut v = VecDeque::new();
    v.push_back(1);
    v.clear();
    assert!(v.is_empty());

#### `fn contains(&self, x: &T) -> bool where
T: PartialEq<T>,`
1.12.0

Returns `true` if the `VecDeque` contains an element equal to the given value.

# Examples

    use std::collections::VecDeque;

    let mut vector: VecDeque<u32> = VecDeque::new();

    vector.push_back(0);
    vector.push_back(1);

    assert_eq!(vector.contains(&1), true);
    assert_eq!(vector.contains(&10), false);

#### `fn front(&self) -> Option<&T>`

Provides a reference to the front element, or `None` if the `VecDeque` is empty.

# Examples

    use std::collections::VecDeque;

    let mut d = VecDeque::new();
    assert_eq!(d.front(), None);

    d.push_back(1);
    d.push_back(2);
    assert_eq!(d.front(), Some(&1));

#### `fn front_mut(&mut self) -> Option<&mut T>`

Provides a mutable reference to the front element, or `None` if the `VecDeque` is empty.

# Examples

    use std::collections::VecDeque;

    let mut d = VecDeque::new();
    assert_eq!(d.front_mut(), None);

    d.push_back(1);
    d.push_back(2);
    match d.front_mut() {
        Some(x) => *x = 9,
        None => (),
    }
    assert_eq!(d.front(), Some(&9));

#### `fn back(&self) -> Option<&T>`

Provides a reference to the back element, or `None` if the `VecDeque` is empty.

# Examples

    use std::collections::VecDeque;

    let mut d = VecDeque::new();
    assert_eq!(d.back(), None);

    d.push_back(1);
    d.push_back(2);
    assert_eq!(d.back(), Some(&2));

#### `fn back_mut(&mut self) -> Option<&mut T>`

Provides a mutable reference to the back element, or `None` if the `VecDeque` is empty.

# Examples

    use std::collections::VecDeque;

    let mut d = VecDeque::new();
    assert_eq!(d.back(), None);

    d.push_back(1);
    d.push_back(2);
    match d.back_mut() {
        Some(x) => *x = 9,
        None => (),
    }
    assert_eq!(d.back(), Some(&9));

#### `fn pop_front(&mut self) -> Option<T>`

Removes the first element and returns it, or `None` if the `VecDeque` is empty.

# Examples

    use std::collections::VecDeque;

    let mut d = VecDeque::new();
    d.push_back(1);
    d.push_back(2);

    assert_eq!(d.pop_front(), Some(1));
    assert_eq!(d.pop_front(), Some(2));
    assert_eq!(d.pop_front(), None);

#### `fn push_front(&mut self, value: T)`

Prepends an element to the `VecDeque`.

# Examples

    use std::collections::VecDeque;

    let mut d = VecDeque::new();
    d.push_front(1);
    d.push_front(2);
    assert_eq!(d.front(), Some(&2));

#### `fn push_back(&mut self, value: T)`

Appends an element to the back of the `VecDeque`.

# Examples

    use std::collections::VecDeque;

    let mut buf = VecDeque::new();
    buf.push_back(1);
    buf.push_back(3);
    assert_eq!(3, *buf.back().unwrap());

#### `fn pop_back(&mut self) -> Option<T>`

Removes the last element from the `VecDeque` and returns it, or `None` if it is empty.

# Examples

    use std::collections::VecDeque;

    let mut buf = VecDeque::new();
    assert_eq!(buf.pop_back(), None);
    buf.push_back(1);
    buf.push_back(3);
    assert_eq!(buf.pop_back(), Some(3));

#### `fn swap_remove_back(&mut self, index: usize) -> Option<T>`
1.5.0

Removes an element from anywhere in the `VecDeque` and returns it, replacing it with the last element.

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

Returns `None` if `index` is out of bounds.

Element at index 0 is the front of the queue.

# Examples

    use std::collections::VecDeque;

    let mut buf = VecDeque::new();
    assert_eq!(buf.swap_remove_back(0), None);
    buf.push_back(1);
    buf.push_back(2);
    buf.push_back(3);
    assert_eq!(buf, [1, 2, 3]);

    assert_eq!(buf.swap_remove_back(0), Some(1));
    assert_eq!(buf, [3, 2]);

#### `fn swap_remove_front(&mut self, index: usize) -> Option<T>`
1.5.0

Removes an element from anywhere in the `VecDeque` and returns it, replacing it with the first element.

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

Returns `None` if `index` is out of bounds.

Element at index 0 is the front of the queue.

# Examples

    use std::collections::VecDeque;

    let mut buf = VecDeque::new();
    assert_eq!(buf.swap_remove_front(0), None);
    buf.push_back(1);
    buf.push_back(2);
    buf.push_back(3);
    assert_eq!(buf, [1, 2, 3]);

    assert_eq!(buf.swap_remove_front(2), Some(3));
    assert_eq!(buf, [2, 1]);

#### `fn insert(&mut self, index: usize, value: T)`
1.5.0

Inserts an element at `index` within the `VecDeque`, shifting all elements with indices greater than or equal to `index` towards the back.

Element at index 0 is the front of the queue.

# Panics

Panics if `index` is greater than `VecDeque`'s length

# Examples

    use std::collections::VecDeque;

    let mut vec_deque = VecDeque::new();
    vec_deque.push_back('a');
    vec_deque.push_back('b');
    vec_deque.push_back('c');
    assert_eq!(vec_deque, &['a', 'b', 'c']);

    vec_deque.insert(1, 'd');
    assert_eq!(vec_deque, &['a', 'd', 'b', 'c']);

#### `fn remove(&mut self, index: usize) -> Option<T>`

Removes and returns the element at `index` from the `VecDeque`. Whichever end is closer to the removal point will be moved to make room, and all the affected elements will be moved to new positions. Returns `None` if `index` is out of bounds.

Element at index 0 is the front of the queue.

# Examples

    use std::collections::VecDeque;

    let mut buf = VecDeque::new();
    buf.push_back(1);
    buf.push_back(2);
    buf.push_back(3);
    assert_eq!(buf, [1, 2, 3]);

    assert_eq!(buf.remove(1), Some(2));
    assert_eq!(buf, [1, 3]);

#### `fn split_off(&mut self, at: usize) -> VecDeque<T>`
1.4.0

Splits the collection into two at the given index.

Returns a newly allocated `Self`. `self` contains elements `[0, at)`, and the returned `Self` contains elements `[at, len)`.

Note that the capacity of `self` does not change.

Element at index 0 is the front of the queue.

# Panics

Panics if `at > len`

# Examples

    use std::collections::VecDeque;

    let mut buf: VecDeque<_> = vec![1,2,3].into_iter().collect();
    let buf2 = buf.split_off(1);
    assert_eq!(buf, [1]);
    assert_eq!(buf2, [2, 3]);

#### `fn append(&mut self, other: &mut VecDeque<T>)`
1.4.0

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

# Panics

Panics if the new number of elements in self overflows a `usize`.

# Examples

    use std::collections::VecDeque;

    let mut buf: VecDeque<_> = vec![1, 2].into_iter().collect();
    let mut buf2: VecDeque<_> = vec![3, 4].into_iter().collect();
    buf.append(&mut buf2);
    assert_eq!(buf, [1, 2, 3, 4]);
    assert_eq!(buf2, []);

#### `fn retain<F>(&mut self, f: F) where
F: FnMut(&T) -> bool,`
1.4.0

Retains only the elements specified by the predicate.

In other words, remove all elements `e` such that `f(&e)` returns false. This method operates in place and preserves the order of the retained elements.

# Examples

    use std::collections::VecDeque;

    let mut buf = VecDeque::new();
    buf.extend(1..5);
    buf.retain(|&x| x%2 == 0);
    assert_eq!(buf, [2, 4]);

#### `fn place_back(&mut self) -> PlaceBack<T>`

🔬 This is a nightly-only experimental API. (`collection_placement` #30172)

placement protocol is subject to change

Returns a place for insertion at the back of the `VecDeque`.

Using this method with placement syntax is equivalent to `push_back`, but may be more efficient.

# Examples

    #![feature(collection_placement)]
    #![feature(placement_in_syntax)]

    use std::collections::VecDeque;

    let mut buf = VecDeque::new();
    buf.place_back() <- 3;
    buf.place_back() <- 4;
    assert_eq!(&buf, &[3, 4]);

#### `fn place_front(&mut self) -> PlaceFront<T>`

🔬 This is a nightly-only experimental API. (`collection_placement` #30172)

placement protocol is subject to change

Returns a place for insertion at the front of the `VecDeque`.

Using this method with placement syntax is equivalent to `push_front`, but may be more efficient.

# Examples

    #![feature(collection_placement)]
    #![feature(placement_in_syntax)]

    use std::collections::VecDeque;

    let mut buf = VecDeque::new();
    buf.place_front() <- 3;
    buf.place_front() <- 4;
    assert_eq!(&buf, &[4, 3]);

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

#### `fn resize(&mut self, new_len: usize, value: T)`
1.16.0

Modifies the `VecDeque` in-place so that `len()` is equal to new_len, either by removing excess elements or by appending clones of `value` to the back.

# Examples

    use std::collections::VecDeque;

    let mut buf = VecDeque::new();
    buf.push_back(5);
    buf.push_back(10);
    buf.push_back(15);
    assert_eq!(buf, [5, 10, 15]);

    buf.resize(2, 0);
    assert_eq!(buf, [5, 10]);

    buf.resize(5, 20);
    assert_eq!(buf, [5, 10, 20, 20, 20]);

## Trait Implementations

### `impl<A> Eq for VecDeque<A> where
A: Eq,`
[src]

### `impl<T> Default for VecDeque<T>`
[src]

#### `fn default() -> VecDeque<T>`

Creates an empty `VecDeque<T>`.

### `impl<A> PartialOrd<VecDeque<A>> for VecDeque<A> where
A: PartialOrd<A>,`
[src]

#### `fn partial_cmp(&self, other: &VecDeque<A>) -> Option<Ordering>`

### `impl<A> Extend<A> for VecDeque<A>`
[src]

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

### `impl<'a, T> Extend<&'a T> for VecDeque<T> where
T: 'a + Copy,`
1.2.0
[src]

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

### `impl<A> IndexMut<usize> for VecDeque<A>`
[src]

#### `fn index_mut(&mut self, index: usize) -> &mut A`

### `impl<'a, T> IntoIterator for &'a mut VecDeque<T>`
[src]

#### `type Item = &'a mut T`

#### `type IntoIter = IterMut<'a, T>`

#### `fn into_iter(self) -> IterMut<'a, T>`

### `impl<T> IntoIterator for VecDeque<T>`
[src]

#### `type Item = T`

#### `type IntoIter = IntoIter<T>`

#### `fn into_iter(self) -> IntoIter<T>`

Consumes the list into a front-to-back iterator yielding elements by value.

### `impl<'a, T> IntoIterator for &'a VecDeque<T>`
[src]

#### `type Item = &'a T`

#### `type IntoIter = Iter<'a, T>`

#### `fn into_iter(self) -> Iter<'a, T>`

### `impl<A> Hash for VecDeque<A> where
A: Hash,`
[src]

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

### `impl<A> Ord for VecDeque<A> where
A: Ord,`
[src]

#### `fn cmp(&self, other: &VecDeque<A>) -> Ordering`

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

#### `fn clone(&self) -> VecDeque<T>`

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 9]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 9]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 27]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 27]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 21]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 21]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 25]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 6]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 6]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<[B; 13]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 10]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 10]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 16]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 23]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 23]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<[B; 7]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 32]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 1]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 15]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 18]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 23]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 22]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 2]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 9]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b [B]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 17]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 17]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 7]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 19]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 20]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 5]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 5]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 10]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 18]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 18]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<[B; 17]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 8]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 1]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 29]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 29]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 3]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 4]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 12]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 28]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 0]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 28]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 28]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 27]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 9]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 25]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 25]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 13]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 13]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 4]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<Vec<B>> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 11]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 11]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 6]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 12]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 12]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<[B; 32]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 25]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 23]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 20]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 20]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<[B; 16]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 3]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 30]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 16]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 16]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<[B; 0]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 30]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 30]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 4]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 4]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 31]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 31]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 14]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 14]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 24]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 7]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 7]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 13]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 26]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 26]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 5]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 26]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 27]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 14]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<A> PartialEq<VecDeque<A>> for VecDeque<A> where
A: PartialEq<A>,`
[src]

#### `fn eq(&self, other: &VecDeque<A>) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 30]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 29]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 22]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 22]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 19]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 19]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 20]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 21]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 24]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 10]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 17]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 24]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 24]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 2]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 31]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 11]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 26]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 5]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 12]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 21]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 1]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 1]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 15]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 15]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 32]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 32]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<[B; 8]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 29]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 19]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 11]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 0]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 0]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 15]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 18]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 6]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<[B; 28]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b [B; 14]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 3]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 3]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 8]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 8]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<[B; 31]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<'a, 'b, A, B> PartialEq<&'b mut [B; 2]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

#### `fn eq(&self, other: &&'b mut [B; 2]) -> bool`

### `impl<'a, 'b, A, B> PartialEq<[B; 22]> for VecDeque<A> where
A: PartialEq<B>,`
1.17.0
[src]

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

### `impl<T> Drop for VecDeque<T>`
[src]

#### `fn drop(&mut self)`

### `impl<T> From<Vec<T>> for VecDeque<T>`
1.10.0
[src]

#### `fn from(other: Vec<T>) -> VecDeque<T>`

### `impl<A> Index<usize> for VecDeque<A>`
[src]

#### `type Output = A`

#### `fn index(&self, index: usize) -> &A`

### `impl<A> FromIterator<A> for VecDeque<A>`
[src]

#### `fn from_iter<T>(iter: T) -> VecDeque<A> where
T: IntoIterator<Item = A>,`

### `impl<T> Debug for VecDeque<T> where
T: Debug,`
[src]

#### `fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

Formats the value using the given formatter.

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)