`pub struct Vector<A> { /* private fields */ }`

## Expand description

A persistent vector.

This is a sequence of elements in insertion order - if you need a list of things, any kind of list of things, this is what you’re looking for.

It’s implemented as an RRB vector with smart head/tail
chunking. In performance terms, this means that practically
every operation is O(log n), except push/pop on both sides, which will be
O(1) amortised, and O(log n) in the worst case. In practice, the push/pop
operations will be blindingly fast, nearly on par with the native
`VecDeque`

, and other operations will have decent, if not high,
performance, but they all have more or less the same O(log n) complexity, so
you don’t need to keep their performance characteristics in mind -
everything, even splitting and merging, is safe to use and never too slow.

### Performance Notes

Because of the head/tail chunking technique, until you push a number of
items above double the tree’s branching factor (that’s `self.len()`

= 2 ×
*k* (where *k* = 64) = 128) on either side, the data structure is still just
a handful of arrays, not yet an RRB tree, so you’ll see performance and
memory characteristics similar to `Vec`

or `VecDeque`

.

This means that the structure always preallocates four chunks of size *k*
(*k* being the tree’s branching factor), equivalent to a `Vec`

with
an initial capacity of 256. Beyond that, it will allocate tree nodes of
capacity *k* as needed.

In addition, vectors start out as single chunks, and only expand into the
full data structure once you go past the chunk size. This makes them
perform identically to `Vec`

at small sizes.

## Implementations

source### impl<A: Clone> Vector<A>

### impl<A: Clone> Vector<A>

source#### pub fn is_empty(&self) -> bool

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

Test whether a vector is empty.

Time: O(1)

##### Examples

```
let vec = vector!["Joe", "Mike", "Robert"];
assert_eq!(false, vec.is_empty());
assert_eq!(true, Vector::<i32>::new().is_empty());
```

source#### pub fn is_inline(&self) -> bool

#### pub fn is_inline(&self) -> bool

Test whether a vector is currently inlined.

Vectors small enough that their contents could be stored entirely inside
the space of `std::mem::size_of::<Vector<A>>()`

bytes are stored inline on
the stack instead of allocating any chunks. This method returns `true`

if
this vector is currently inlined, or `false`

if it currently has chunks allocated
on the heap.

This may be useful in conjunction with `ptr_eq()`

, which checks if
two vectors’ heap allocations are the same, and thus will never return `true`

for inlined vectors.

Time: O(1)

source#### pub fn ptr_eq(&self, other: &Self) -> bool

#### pub fn ptr_eq(&self, other: &Self) -> bool

Test whether two vectors refer to the same content in memory.

This uses the following rules to determine equality:

- If the two sides are references to the same vector, return true.
- If the two sides are single chunk vectors pointing to the same chunk, return true.
- If the two sides are full trees pointing to the same chunks, return true.

This would return true if you’re comparing a vector to itself, or
if you’re comparing a vector to a fresh clone of itself. The exception to this is
if you’ve cloned an inline array (ie. an array with so few elements they can fit
inside the space a `Vector`

allocates for its pointers, so there are no heap allocations
to compare).

Time: O(1)

source#### pub fn iter(&self) -> Iter<'_, A>ⓘNotable traits for Iter<'a, A>`impl<'a, A: Clone> Iterator for Iter<'a, A> type Item = &'a A;`

#### pub fn iter(&self) -> Iter<'_, A>ⓘNotable traits for Iter<'a, A>`impl<'a, A: Clone> Iterator for Iter<'a, A> type Item = &'a A;`

Get an iterator over a vector.

Time: O(1)

source#### pub fn iter_mut(&mut self) -> IterMut<'_, A>ⓘNotable traits for IterMut<'a, A>`impl<'a, A> Iterator for IterMut<'a, A> where`

A: 'a + Clone, type Item = &'a mut A;

#### pub fn iter_mut(&mut self) -> IterMut<'_, A>ⓘNotable traits for IterMut<'a, A>`impl<'a, A> Iterator for IterMut<'a, A> where`

A: 'a + Clone, type Item = &'a mut A;

A: 'a + Clone, type Item = &'a mut A;

Get a mutable iterator over a vector.

Time: O(1)

source#### pub fn leaves(&self) -> Chunks<'_, A>ⓘNotable traits for Chunks<'a, A>`impl<'a, A: Clone> Iterator for Chunks<'a, A> type Item = &'a [A];`

#### pub fn leaves(&self) -> Chunks<'_, A>ⓘNotable traits for Chunks<'a, A>`impl<'a, A: Clone> Iterator for Chunks<'a, A> type Item = &'a [A];`

Get an iterator over the leaf nodes of a vector.

This returns an iterator over the `Chunk`

s at the leaves of the
RRB tree. These are useful for efficient parallelisation of work on
the vector, but should not be used for basic iteration.

Time: O(1)

source#### pub fn leaves_mut(&mut self) -> ChunksMut<'_, A>ⓘNotable traits for ChunksMut<'a, A>`impl<'a, A: Clone> Iterator for ChunksMut<'a, A> type Item = &'a mut [A];`

#### pub fn leaves_mut(&mut self) -> ChunksMut<'_, A>ⓘNotable traits for ChunksMut<'a, A>`impl<'a, A: Clone> Iterator for ChunksMut<'a, A> type Item = &'a mut [A];`

Get a mutable iterator over the leaf nodes of a vector.
This returns an iterator over the `Chunk`

s at the leaves of the
RRB tree. These are useful for efficient parallelisation of work on
the vector, but should not be used for basic iteration.

Time: O(1)

source#### pub fn get(&self, index: usize) -> Option<&A>

#### pub fn get(&self, index: usize) -> Option<&A>

Get a reference to the value at index `index`

in a vector.

Returns `None`

if the index is out of bounds.

Time: O(log n)

##### Examples

```
let vec = vector!["Joe", "Mike", "Robert"];
assert_eq!(Some(&"Robert"), vec.get(2));
assert_eq!(None, vec.get(5));
```

source#### pub fn get_mut(&mut self, index: usize) -> Option<&mut A>

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

Get a mutable reference to the value at index `index`

in a
vector.

Returns `None`

if the index is out of bounds.

Time: O(log n)

##### Examples

```
let mut vec = vector!["Joe", "Mike", "Robert"];
{
let robert = vec.get_mut(2).unwrap();
assert_eq!(&mut "Robert", robert);
*robert = "Bjarne";
}
assert_eq!(vector!["Joe", "Mike", "Bjarne"], vec);
```

source#### pub fn front(&self) -> Option<&A>

#### pub fn front(&self) -> Option<&A>

Get the first element of a vector.

If the vector is empty, `None`

is returned.

Time: O(log n)

source#### pub fn front_mut(&mut self) -> Option<&mut A>

#### pub fn front_mut(&mut self) -> Option<&mut A>

Get a mutable reference to the first element of a vector.

If the vector is empty, `None`

is returned.

Time: O(log n)

source#### pub fn head(&self) -> Option<&A>

#### pub fn head(&self) -> Option<&A>

Get the first element of a vector.

If the vector is empty, `None`

is returned.

This is an alias for the `front`

method.

Time: O(log n)

source#### pub fn back(&self) -> Option<&A>

#### pub fn back(&self) -> Option<&A>

Get the last element of a vector.

If the vector is empty, `None`

is returned.

Time: O(log n)

source#### pub fn back_mut(&mut self) -> Option<&mut A>

#### pub fn back_mut(&mut self) -> Option<&mut A>

Get a mutable reference to the last element of a vector.

If the vector is empty, `None`

is returned.

Time: O(log n)

source#### pub fn last(&self) -> Option<&A>

#### pub fn last(&self) -> Option<&A>

Get the last element of a vector.

If the vector is empty, `None`

is returned.

This is an alias for the `back`

method.

Time: O(log n)

source#### pub fn index_of(&self, value: &A) -> Option<usize> where

A: PartialEq,

#### pub fn index_of(&self, value: &A) -> Option<usize> where

A: PartialEq,

Get the index of a given element in the vector.

Searches the vector for the first occurrence of a given value,
and returns the index of the value if it’s there. Otherwise,
it returns `None`

.

Time: O(n)

##### Examples

```
let mut vec = vector![1, 2, 3, 4, 5];
assert_eq!(Some(2), vec.index_of(&3));
assert_eq!(None, vec.index_of(&31337));
```

source#### pub fn contains(&self, value: &A) -> bool where

A: PartialEq,

#### pub fn contains(&self, value: &A) -> bool where

A: PartialEq,

Test if a given element is in the vector.

Searches the vector for the first occurrence of a given value,
and returns `true`

if it’s there. If it’s nowhere to be found
in the vector, it returns `false`

.

Time: O(n)

##### Examples

```
let mut vec = vector![1, 2, 3, 4, 5];
assert_eq!(true, vec.contains(&3));
assert_eq!(false, vec.contains(&31337));
```

source#### pub fn clear(&mut self)

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

Discard all elements from the vector.

This leaves you with an empty vector, and all elements that were previously inside it are dropped.

Time: O(n)

source#### pub fn binary_search_by<F>(&self, f: F) -> Result<usize, usize> where

F: FnMut(&A) -> Ordering,

#### pub fn binary_search_by<F>(&self, f: F) -> Result<usize, usize> where

F: FnMut(&A) -> Ordering,

Binary search a sorted vector for a given element using a comparator function.

Assumes the vector has already been sorted using the same comparator
function, eg. by using `sort_by`

.

If the value is found, it returns `Ok(index)`

where `index`

is the index
of the element. If the value isn’t found, it returns `Err(index)`

where
`index`

is the index at which the element would need to be inserted to
maintain sorted order.

Time: O(log n)

source#### pub fn binary_search(&self, value: &A) -> Result<usize, usize> where

A: Ord,

#### pub fn binary_search(&self, value: &A) -> Result<usize, usize> where

A: Ord,

Binary search a sorted vector for a given element.

If the value is found, it returns `Ok(index)`

where `index`

is the index
of the element. If the value isn’t found, it returns `Err(index)`

where
`index`

is the index at which the element would need to be inserted to
maintain sorted order.

Time: O(log n)

source#### pub fn binary_search_by_key<B, F>(&self, b: &B, f: F) -> Result<usize, usize> where

F: FnMut(&A) -> B,

B: Ord,

#### pub fn binary_search_by_key<B, F>(&self, b: &B, f: F) -> Result<usize, usize> where

F: FnMut(&A) -> B,

B: Ord,

Binary search a sorted vector for a given element with a key extract function.

Assumes the vector has already been sorted using the same key extract
function, eg. by using `sort_by_key`

.

If the value is found, it returns `Ok(index)`

where `index`

is the index
of the element. If the value isn’t found, it returns `Err(index)`

where
`index`

is the index at which the element would need to be inserted to
maintain sorted order.

Time: O(log n)

source### impl<A: Clone> Vector<A>

### impl<A: Clone> Vector<A>

source#### pub fn unit(a: A) -> Self

#### pub fn unit(a: A) -> Self

Construct a vector with a single value.

##### Examples

```
let vec = Vector::unit(1337);
assert_eq!(1, vec.len());
assert_eq!(
vec.get(0),
Some(&1337)
);
```

source#### pub fn update(&self, index: usize, value: A) -> Self

#### pub fn update(&self, index: usize, value: A) -> Self

Create a new vector with the value at index `index`

updated.

Panics if the index is out of bounds.

Time: O(log n)

##### Examples

```
let mut vec = vector![1, 2, 3];
assert_eq!(vector![1, 5, 3], vec.update(1, 5));
```

source#### pub fn set(&mut self, index: usize, value: A) -> A

#### pub fn set(&mut self, index: usize, value: A) -> A

Update the value at index `index`

in a vector.

Returns the previous value at the index.

Panics if the index is out of bounds.

Time: O(log n)

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

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

Swap the elements at indices `i`

and `j`

.

Time: O(log n)

source#### pub fn push_front(&mut self, value: A)

#### pub fn push_front(&mut self, value: A)

Push a value to the front of a vector.

Time: O(1)*

##### Examples

```
let mut vec = vector![5, 6, 7];
vec.push_front(4);
assert_eq!(vector![4, 5, 6, 7], vec);
```

source#### pub fn push_back(&mut self, value: A)

#### pub fn push_back(&mut self, value: A)

Push a value to the back of a vector.

Time: O(1)*

##### Examples

```
let mut vec = vector![1, 2, 3];
vec.push_back(4);
assert_eq!(vector![1, 2, 3, 4], vec);
```

source#### pub fn pop_front(&mut self) -> Option<A>

#### pub fn pop_front(&mut self) -> Option<A>

Remove the first element from a vector and return it.

Time: O(1)*

##### Examples

```
let mut vec = vector![1, 2, 3];
assert_eq!(Some(1), vec.pop_front());
assert_eq!(vector![2, 3], vec);
```

source#### pub fn pop_back(&mut self) -> Option<A>

#### pub fn pop_back(&mut self) -> Option<A>

Remove the last element from a vector and return it.

Time: O(1)*

##### Examples

```
let mut vec = vector![1, 2, 3];
assert_eq!(Some(3), vec.pop_back());
assert_eq!(vector![1, 2], vec);
```

source#### pub fn append(&mut self, other: Self)

#### pub fn append(&mut self, other: Self)

Append the vector `other`

to the end of the current vector.

Time: O(log n)

##### Examples

```
let mut vec = vector![1, 2, 3];
vec.append(vector![7, 8, 9]);
assert_eq!(vector![1, 2, 3, 7, 8, 9], vec);
```

source#### pub fn retain<F>(&mut self, f: F) where

F: FnMut(&A) -> bool,

#### pub fn retain<F>(&mut self, f: F) where

F: FnMut(&A) -> bool,

Retain only the elements specified by the predicate.

Remove all elements for which the provided function `f`

returns false from the vector.

Time: O(n)

source#### pub fn split_at(self, index: usize) -> (Self, Self)

#### pub fn split_at(self, index: usize) -> (Self, Self)

Split a vector at a given index.

Split a vector at a given index, consuming the vector and returning a pair of the left hand side and the right hand side of the split.

Time: O(log n)

##### Examples

```
let mut vec = vector![1, 2, 3, 7, 8, 9];
let (left, right) = vec.split_at(3);
assert_eq!(vector![1, 2, 3], left);
assert_eq!(vector![7, 8, 9], right);
```

source#### pub fn split_off(&mut self, index: usize) -> Self

#### pub fn split_off(&mut self, index: usize) -> Self

Split a vector at a given index.

Split a vector at a given index, leaving the left hand side in the current vector and returning a new vector containing the right hand side.

Time: O(log n)

##### Examples

```
let mut left = vector![1, 2, 3, 7, 8, 9];
let right = left.split_off(3);
assert_eq!(vector![1, 2, 3], left);
assert_eq!(vector![7, 8, 9], right);
```

source#### pub fn skip(&self, count: usize) -> Self

#### pub fn skip(&self, count: usize) -> Self

Construct a vector with `count`

elements removed from the
start of the current vector.

Time: O(log n)

source#### pub fn take(&self, count: usize) -> Self

#### pub fn take(&self, count: usize) -> Self

Construct a vector of the first `count`

elements from the
current vector.

Time: O(log n)

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

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

Truncate a vector to the given size.

Discards all elements in the vector beyond the given length.

Panics if the new length is greater than the current length.

Time: O(log n)

source#### pub fn slice<R>(&mut self, range: R) -> Self where

R: RangeBounds<usize>,

#### pub fn slice<R>(&mut self, range: R) -> Self where

R: RangeBounds<usize>,

Extract a slice from a vector.

Remove the elements from `start_index`

until `end_index`

in
the current vector and return the removed slice as a new
vector.

Time: O(log n)

source#### pub fn insert(&mut self, index: usize, value: A)

#### pub fn insert(&mut self, index: usize, value: A)

Insert an element into a vector.

Insert an element at position `index`

, shifting all elements
after it to the right.

###### Performance Note

While `push_front`

and `push_back`

are heavily optimised
operations, `insert`

in the middle of a vector requires a
split, a push, and an append. Thus, if you want to insert
many elements at the same location, instead of `insert`

ing
them one by one, you should rather create a new vector
containing the elements to insert, split the vector at the
insertion point, and append the left hand, the new vector and
the right hand in order.

Time: O(log n)

source#### pub fn remove(&mut self, index: usize) -> A

#### pub fn remove(&mut self, index: usize) -> A

Remove an element from a vector.

Remove the element from position ‘index’, shifting all elements after it to the left, and return the removed element.

###### Performance Note

While `pop_front`

and `pop_back`

are heavily optimised
operations, `remove`

in the middle of a vector requires a
split, a pop, and an append. Thus, if you want to remove many
elements from the same location, instead of `remove`

ing them
one by one, it is much better to use `slice`

.

Time: O(log n)

source#### pub fn insert_ord(&mut self, item: A) where

A: Ord,

#### pub fn insert_ord(&mut self, item: A) where

A: Ord,

Insert an element into a sorted vector.

Insert an element into a vector in sorted order, assuming the vector is already in sorted order.

Time: O(log n)

##### Examples

```
let mut vec = vector![1, 2, 3, 7, 8, 9];
vec.insert_ord(5);
assert_eq!(vector![1, 2, 3, 5, 7, 8, 9], vec);
```

source#### pub fn sort(&mut self) where

A: Ord,

#### pub fn sort(&mut self) where

A: Ord,

Sort a vector.

Time: O(n log n)

##### Examples

```
let mut vec = vector![3, 2, 5, 4, 1];
vec.sort();
assert_eq!(vector![1, 2, 3, 4, 5], vec);
```

source#### pub fn sort_by<F>(&mut self, cmp: F) where

F: Fn(&A, &A) -> Ordering,

#### pub fn sort_by<F>(&mut self, cmp: F) where

F: Fn(&A, &A) -> Ordering,

Sort a vector using a comparator function.

Time: O(n log n)

##### Examples

```
let mut vec = vector![3, 2, 5, 4, 1];
vec.sort_by(|left, right| left.cmp(right));
assert_eq!(vector![1, 2, 3, 4, 5], vec);
```

source#### pub fn assert_invariants(&self)

#### pub fn assert_invariants(&self)

Verify the internal consistency of a vector.

This method walks the RRB tree making up the current `Vector`

(if it has one) and verifies that all the invariants hold.
If something is wrong, it will panic.

This method requires the `debug`

feature flag.

## Trait Implementations

source### impl<'a, A: Arbitrary<'a> + Clone> Arbitrary<'a> for Vector<A>

### impl<'a, A: Arbitrary<'a> + Clone> Arbitrary<'a> for Vector<A>

source#### fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

#### fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of `Self`

from the given unstructured data. Read more

source#### fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self>

#### fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self>

Generate an arbitrary value of `Self`

from the entirety of the given unstructured data. Read more

source### impl<'de, A: Clone + Deserialize<'de>> Deserialize<'de> for Vector<A>

### impl<'de, A: Clone + Deserialize<'de>> Deserialize<'de> for Vector<A>

source#### fn deserialize<D>(des: D) -> Result<Self, D::Error> where

D: Deserializer<'de>,

#### fn deserialize<D>(des: D) -> Result<Self, D::Error> where

D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more

source### impl<A: Clone> Extend<A> for Vector<A>

### impl<A: Clone> Extend<A> for Vector<A>

source#### fn extend<I>(&mut self, iter: I) where

I: IntoIterator<Item = A>,

#### fn extend<I>(&mut self, iter: I) where

I: IntoIterator<Item = A>,

Add values to the end of a vector by consuming an iterator.

Time: O(n)

source#### fn extend_one(&mut self, item: A)

#### fn extend_one(&mut self, item: A)

`extend_one`

)Extends a collection with exactly one element.

source#### fn extend_reserve(&mut self, additional: usize)

#### fn extend_reserve(&mut self, additional: usize)

`extend_one`

)Reserves capacity in a collection for the given number of additional elements. Read more

source### impl<'a, A: Clone> From<&'a Vec<A, Global>> for Vector<A>

### impl<'a, A: Clone> From<&'a Vec<A, Global>> for Vector<A>

source#### fn from(vec: &Vec<A>) -> Self

#### fn from(vec: &Vec<A>) -> Self

Create a vector from a `std::vec::Vec`

.

Time: O(n)

source### impl<'a, A, S> From<&'a Vector<A>> for HashSet<A, S> where

A: Hash + Eq + Clone,

S: BuildHasher + Default,

### impl<'a, A, S> From<&'a Vector<A>> for HashSet<A, S> where

A: Hash + Eq + Clone,

S: BuildHasher + Default,

source### impl<'s, 'a, A, OA> From<&'s Vector<&'a A>> for Vector<OA> where

A: ToOwned<Owned = OA>,

OA: Borrow<A> + Clone,

### impl<'s, 'a, A, OA> From<&'s Vector<&'a A>> for Vector<OA> where

A: ToOwned<Owned = OA>,

OA: Borrow<A> + Clone,

source### impl<A: Clone> From<Vec<A, Global>> for Vector<A>

### impl<A: Clone> From<Vec<A, Global>> for Vector<A>

source#### fn from(vec: Vec<A>) -> Self

#### fn from(vec: Vec<A>) -> Self

Create a vector from a `std::vec::Vec`

.

Time: O(n)

source### impl<A, S> From<Vector<A>> for HashSet<A, S> where

A: Hash + Eq + Clone,

S: BuildHasher + Default,

### impl<A, S> From<Vector<A>> for HashSet<A, S> where

A: Hash + Eq + Clone,

S: BuildHasher + Default,

source### impl<A: Clone> FromIterator<A> for Vector<A>

### impl<A: Clone> FromIterator<A> for Vector<A>

source#### fn from_iter<I>(iter: I) -> Self where

I: IntoIterator<Item = A>,

#### fn from_iter<I>(iter: I) -> Self where

I: IntoIterator<Item = A>,

Create a vector from an iterator.

Time: O(n)

source### impl<'a, A: Clone> IntoIterator for &'a Vector<A>

### impl<'a, A: Clone> IntoIterator for &'a Vector<A>

source### impl<A: Clone> IntoIterator for Vector<A>

### impl<A: Clone> IntoIterator for Vector<A>

source### impl<'a, A> IntoParallelRefIterator<'a> for Vector<A> where

A: Clone + Send + Sync + 'a,

### impl<'a, A> IntoParallelRefIterator<'a> for Vector<A> where

A: Clone + Send + Sync + 'a,

source### impl<'a, A> IntoParallelRefMutIterator<'a> for Vector<A> where

A: Clone + Send + Sync + 'a,

### impl<'a, A> IntoParallelRefMutIterator<'a> for Vector<A> where

A: Clone + Send + Sync + 'a,

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

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

The type of item that will be produced; this is typically an
`&'data mut T`

reference. Read more

#### type Iter = ParIterMut<'a, A>

#### type Iter = ParIterMut<'a, A>

The type of iterator that will be created.

source#### fn par_iter_mut(&'a mut self) -> Self::Iter

#### fn par_iter_mut(&'a mut self) -> Self::Iter

Creates the parallel iterator from `self`

. Read more

source### impl<A: Clone + Ord> Ord for Vector<A>

### impl<A: Clone + Ord> Ord for Vector<A>

source### impl<A: Clone + PartialOrd> PartialOrd<Vector<A>> for Vector<A>

### impl<A: Clone + PartialOrd> PartialOrd<Vector<A>> for Vector<A>

source#### fn partial_cmp(&self, other: &Self) -> Option<Ordering>

#### fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between `self`

and `other`

values if one exists. Read more

1.0.0 · source#### fn lt(&self, other: &Rhs) -> bool

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

This method tests less than (for `self`

and `other`

) and is used by the `<`

operator. Read more

1.0.0 · source#### fn le(&self, other: &Rhs) -> bool

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

This method tests less than or equal to (for `self`

and `other`

) and is used by the `<=`

operator. Read more

### impl<A: Clone + Eq> Eq for Vector<A>

## Auto Trait Implementations

### impl<A> RefUnwindSafe for Vector<A> where

A: RefUnwindSafe,

### impl<A> Send for Vector<A> where

A: Send + Sync,

### impl<A> Sync for Vector<A> where

A: Send + Sync,

### impl<A> Unpin for Vector<A> where

A: Unpin,

### impl<A> UnwindSafe for Vector<A> where

A: UnwindSafe + RefUnwindSafe,

## Blanket Implementations

source### impl<T> BorrowMut<T> for T where

T: ?Sized,

### impl<T> BorrowMut<T> for T where

T: ?Sized,

const: unstable · source#### fn borrow_mut(&mut self) -> &mut T

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

### impl<T> Pointable for T

### impl<T> Pointable for T

source### impl<T> ToOwned for T where

T: Clone,

### impl<T> ToOwned for T where

T: Clone,

#### type Owned = T

#### type Owned = T

The resulting type after obtaining ownership.

source#### fn clone_into(&self, target: &mut T)

#### fn clone_into(&self, target: &mut T)

`toowned_clone_into`

)Uses borrowed data to replace owned data, usually by cloning. Read more