# tinyvec::TinyVec - Rust
API documentation for the Rust `TinyVec` enum in crate `tinyvec`.
Keywords: rust, rustlang, rust-lang, TinyVec

# Enum tinyvec::TinyVec [−] [src]

    pub enum TinyVec<A: Array> {
        Inline(ArrayVec<A>),
        Heap(Vec<A::Item>),
    }

A vector that starts inline, but can automatically move to the heap.

- Requires the `alloc` feature

A `TinyVec` is either an Inline(`ArrayVec`) or Heap(`Vec`). The interface for the type as a whole is a bunch of methods that just match on the enum variant and then call the same method on the inner vec.

## Construction

Because it's an enum, you can construct a `TinyVec` simply by making an `ArrayVec` or `Vec` and then putting it into the enum.

There is also a macro

    let empty_tv = tiny_vec!([u8; 16]);
    let some_ints = tiny_vec!([i32; 4] => 1, 2, 3);

## Variants

`Inline(ArrayVec<A>)`
`Heap(Vec<A::Item>)`

## Implementations

### `impl<A: Array> TinyVec<A>` [src]

#### `#[must_use]pub fn is_heap(&self) -> bool` [src]

Returns whether elements are on heap

#### `#[must_use]pub fn is_inline(&self) -> bool` [src]

Returns whether elements are on stack

#### `pub fn shrink_to_fit(&mut self)` [src]

Shrinks the capacity of the vector as much as possible.
It is inlined if length is less than `A::CAPACITY`.

    use tinyvec::*;
    let mut tv = tiny_vec!([i32; 2] => 1, 2, 3);
    assert!(tv.is_heap());
    let _ = tv.pop();
    assert!(tv.is_heap());
    tv.shrink_to_fit();
    assert!(tv.is_inline());

#### `pub fn move_to_the_heap(&mut self)` [src]

Moves the content of the TinyVec to the heap, if it's inline.

    use tinyvec::*;
    let mut tv = tiny_vec!([i32; 4] => 1, 2, 3);
    assert!(tv.is_inline());
    tv.move_to_the_heap();
    assert!(tv.is_heap());

#### `pub fn move_to_the_heap_and_reserve(&mut self, n: usize)` [src]

If TinyVec is inline, moves the content of it to the heap. Also reserves additional space.

    use tinyvec::*;
    let mut tv = tiny_vec!([i32; 4] => 1, 2, 3);
    assert!(tv.is_inline());
    tv.move_to_the_heap_and_reserve(32);
    assert!(tv.is_heap());
    assert!(tv.capacity() >= 35);

#### `pub fn reserve(&mut self, n: usize)` [src]

Reserves additional space. Moves to the heap if array can't hold `n` more items

    use tinyvec::*;
    let mut tv = tiny_vec!([i32; 4] => 1, 2, 3, 4);
    assert!(tv.is_inline());
    tv.reserve(1);
    assert!(tv.is_heap());
    assert!(tv.capacity() >= 5);

#### `pub fn reserve_exact(&mut self, n: usize)` [src]

Reserves additional space. Moves to the heap if array can't hold `n` more items

From Vec::reserve_exact

    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.

    use tinyvec::*;
    let mut tv = tiny_vec!([i32; 4] => 1, 2, 3, 4);
    assert!(tv.is_inline());
    tv.reserve_exact(1);
    assert!(tv.is_heap());
    assert!(tv.capacity() >= 5);

#### `#[must_use]pub fn with_capacity(cap: usize) -> Self` [src]

Makes a new TinyVec with at least the given capacity.

If the requested capacity is less than or equal to the array capacity you get an inline vec. If it's greater than you get a heap vec.

    let t = TinyVec::<[u8; 10]>::with_capacity(5);
    assert!(t.is_inline());
    assert!(t.capacity() >= 5);

    let t = TinyVec::<[u8; 10]>::with_capacity(20);
    assert!(t.is_heap());
    assert!(t.capacity() >= 20);

### `impl<A: Array> TinyVec<A>` [src]

#### `pub fn append(&mut self, other: &mut Self)` [src]

Move all values from `other` into this vec.

#### `pub fn swap_remove(&mut self, index: usize) -> A::Item` [src]

Remove an element, swapping the end of the vec into its place.

## Panics

- If the index is out of bounds.

## Example

    use tinyvec::*;
    let mut tv = tiny_vec!([&str; 4] => "foo", "bar", "quack", "zap");

    assert_eq!(tv.swap_remove(1), "bar");
    assert_eq!(tv.as_slice(), &["foo", "zap", "quack"][..]);

    assert_eq!(tv.swap_remove(0), "foo");
    assert_eq!(tv.as_slice(), &["quack", "zap"][..]);

#### `pub fn pop(&mut self) -> Option<A::Item>` [src]

Remove and return the last element of the vec, if there is one.

## Failure

- If the vec is empty you get `None`.

#### `pub fn remove(&mut self, index: usize) -> A::Item` [src]

Removes the item at `index`, shifting all others down by one index.

Returns the removed element.

## Panics

If the index is out of bounds.

## Example

    use tinyvec::*;
    let mut tv = tiny_vec!([i32; 4] => 1, 2, 3);
    assert_eq!(tv.remove(1), 2);
    assert_eq!(tv.as_slice(), &[1, 3][..]);

#### `#[must_use]pub fn len(&self) -> usize` [src]

The length of the vec (in elements).

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

The capacity of the `TinyVec`.

When not heap allocated this is fixed based on the array type. Otherwise its the result of the underlying Vec::capacity.

#### `pub fn truncate(&mut self, new_len: usize)` [src]

Reduces the vec's length to the given value.

If the vec is already shorter than the input, nothing happens.

#### `#[must_use]pub fn as_mut_ptr(&mut self) -> *mut A::Item` [src]

A mutable pointer to the backing array.

## Safety

This pointer has provenance over the entire backing array/buffer.

#### `#[must_use]pub fn as_ptr(&self) -> *const A::Item` [src]

A const pointer to the backing array.

## Safety

This pointer has provenance over the entire backing array/buffer.

#### `pub fn retain<F: FnMut(&A::Item) -> bool>(&mut self, acceptable: F)` [src]

Walk the vec and keep only the elements that pass the predicate given.

## Example

    use tinyvec::*;

    let mut tv = tiny_vec!([i32; 10] => 1, 2, 3, 4);
    tv.retain(|&x| x % 2 == 0);
    assert_eq!(tv.as_slice(), &[2, 4][..]);

#### `#[must_use]pub fn as_mut_slice(&mut self) -> &mut [A::Item]` [src]

Helper for getting the mut slice.

#### `#[must_use]pub fn as_slice(&self) -> &[A::Item]` [src]

Helper for getting the shared slice.

#### `pub fn clear(&mut self)` [src]

Removes all elements from the vec.

#### `pub fn drain<R: RangeBounds<usize>>(&mut self, range: R) -> TinyVecDrain<'_, A>ⓘ

### Notable traits for TinyVecDrain<'p, A>

`impl<'p, A: Array> Iterator for TinyVecDrain<'p, A> type Item = A::Item;`
` [src]

Creates a draining iterator that removes the specified range in the vector and yields the removed items.

Note: This method has significant performance issues compared to matching on the TinyVec and then calling drain on the Inline or Heap value inside. The draining iterator has to branch on every single access. It is provided for simplicity and compatability only.

## Panics

- If the start is greater than the end
- If the end is past the edge of the vec.

## Example

    use tinyvec::*;
    let mut tv = tiny_vec!([i32; 4] => 1, 2, 3);
    let tv2: TinyVec<[i32; 4]> = tv.drain(1..).collect();
    assert_eq!(tv.as_slice(), &[1][..]);
    assert_eq!(tv2.as_slice(), &[2, 3][..]);

    tv.drain(..);
    assert_eq!(tv.as_slice(), &[]);

#### `pub fn extend_from_slice(&mut self, sli: &[A::Item]) where
A::Item: Clone,` [src]

Clone each element of the slice into this vec.

    use tinyvec::*;
    let mut tv = tiny_vec!([i32; 4] => 1, 2);
    tv.extend_from_slice(&[3, 4]);
    assert_eq!(tv.as_slice(), [1, 2, 3, 4]);

#### `#[must_use]pub fn from_array_len(data: A, len: usize) -> Self` [src]

Wraps up an array and uses the given length as the initial length.

Note that the `From` impl for arrays assumes the full length is used.

## Panics

The length must be less than or equal to the capacity of the array.

#### `pub fn insert(&mut self, index: usize, item: A::Item)` [src]

Inserts an item at the position given, moving all following elements +1 index.

## Panics

- If `index` > `len`

## Example

    use tinyvec::*;
    let mut tv = tiny_vec!([i32; 10] => 1, 2, 3);
    tv.insert(1, 4);
    assert_eq!(tv.as_slice(), &[1, 4, 2, 3]);
    tv.insert(4, 5);
    assert_eq!(tv.as_slice(), &[1, 4, 2, 3, 5]);

#### `#[must_use]pub fn is_empty(&self) -> bool` [src]

If the vec is empty.

#### `#[must_use]pub fn new() -> Self` [src]

Makes a new, empty vec.

#### `pub fn push(&mut self, val: A::Item)` [src]

Place an element onto the end of the vec.

## Panics

- If the length of the vec would overflow the capacity.

    use tinyvec::*;
    let mut tv = tiny_vec!([i32; 10] => 1, 2, 3);
    tv.push(4);
    assert_eq!(tv.as_slice(), &[1, 2, 3, 4]);

#### `pub fn resize(&mut self, new_len: usize, new_val: A::Item) where
A::Item: Clone,` [src]

Resize the vec to the new length.

If it needs to be longer, it's filled with clones of the provided value. If it needs to be shorter, it's truncated.

## Example

    use tinyvec::*;

    let mut tv = tiny_vec!([&str; 10] => "hello");
    tv.resize(3, "world");
    assert_eq!(tv.as_slice(), &["hello", "world", "world"][..]);

    let mut tv = tiny_vec!([i32; 10] => 1, 2, 3, 4);
    tv.resize(2, 0);
    assert_eq!(tv.as_slice(), &[1, 2][..]);

#### `pub fn resize_with<F: FnMut() -> A::Item>(&mut self, new_len: usize, f: F)` [src]

Resize the vec to the new length.

If it needs to be longer, it's filled with repeated calls to the provided function. If it needs to be shorter, it's truncated.

## Example

    use tinyvec::*;

    let mut tv = tiny_vec!([i32; 3] => 1, 2, 3);
    tv.resize_with(5, Default::default);
    assert_eq!(tv.as_slice(), &[1, 2, 3, 0, 0][..]);

    let mut tv = tiny_vec!([i32; 2]);
    let mut p = 1;
    tv.resize_with(4, || {
      p *= 2;
      p
    });
    assert_eq!(tv.as_slice(), &[2, 4, 8, 16][..]);

#### `pub fn split_off(&mut self, at: usize) -> Self` [src]

Splits the collection at the point given.

- `[0, at)` stays in this vec
- `[at, len)` ends up in the new vec.

## Panics

- if at > len

## Example

    use tinyvec::*;
    let mut tv = tiny_vec!([i32; 4] => 1, 2, 3);
    let tv2 = tv.split_off(1);
    assert_eq!(tv.as_slice(), &[1][..]);
    assert_eq!(tv2.as_slice(), &[2, 3][..]);

#### `pub fn splice<R, I>(
&mut self,
range: R,
replacement: I
) -> TinyVecSplice<'_, A, Fuse<I::IntoIter>>ⓘ

### Notable traits for TinyVecSplice<'p, A, I>

`impl<'p, A, I> Iterator for TinyVecSplice<'p, A, I> where
A: Array,
I: Iterator<Item = A::Item>, type Item = A::Item;`
where
R: RangeBounds<usize>,
I: IntoIterator<Item = A::Item>,` [src]

Creates a splicing iterator that removes the specified range in the vector, yields the removed items, and replaces them with elements from the provided iterator.

`splice` fuses the provided iterator, so elements after the first `None` are ignored.

## Panics

- If the start is greater than the end.
- If the end is past the edge of the vec.
- If the provided iterator panics.

## Example

    use tinyvec::*;
    let mut tv = tiny_vec!([i32; 4] => 1, 2, 3);
    let tv2: TinyVec<[i32; 4]> = tv.splice(1.., 4..=6).collect();
    assert_eq!(tv.as_slice(), &[1, 4, 5, 6][..]);
    assert_eq!(tv2.as_slice(), &[2, 3][..]);

    tv.splice(.., None);
    assert_eq!(tv.as_slice(), &[]);

#### `pub fn try_from_array_len(data: A, len: usize) -> Result<Self, A>` [src]

Wraps an array, using the given length as the starting length.

If you want to use the whole length of the array, you can just use the `From` impl.

## Failure

If the given length is greater than the capacity of the array this will error, and you'll get the array back in the `Err`.

## Trait Implementations

### `impl<A: Array> AsMut<[<A as Array>::Item]> for TinyVec<A>` [src]

#### `#[must_use]fn as_mut(&mut self) -> &mut [A::Item]` [src]

Performs the conversion.

### `impl<A: Array> AsRef<[<A as Array>::Item]> for TinyVec<A>` [src]

#### `#[must_use]fn as_ref(&self) -> &[A::Item]` [src]

Performs the conversion.

### `impl<A: Array> Binary for TinyVec<A> where
A::Item: Binary,` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter.

### `impl<A: Array> Borrow<[<A as Array>::Item]> for TinyVec<A>` [src]

#### `#[must_use]fn borrow(&self) -> &[A::Item]` [src]

Immutably borrows from an owned value. Read more

### `impl<A: Array> BorrowMut<[<A as Array>::Item]> for TinyVec<A>` [src]

#### `#[must_use]fn borrow_mut(&mut self) -> &mut [A::Item]` [src]

Mutably borrows from an owned value. Read more

### `impl<A: Clone + Array> Clone for TinyVec<A> where
A::Item: Clone,` [src]

#### `fn clone(&self) -> TinyVec<A>` [src]

Returns a copy of the value. Read more

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

Performs copy-assignment from `source`. Read more

### `impl<A: Array> Debug for TinyVec<A> where
A::Item: Debug,` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl<A: Array> Default for TinyVec<A>` [src]

#### `#[must_use]fn default() -> Self` [src]

Returns the "default value" for a type. Read more

### `impl<A: Array> Deref for TinyVec<A>` [src]

#### `type Target = [A::Item]`

The resulting type after dereferencing.

#### `#[must_use]fn deref(&self) -> &Self::Target` [src]

Dereferences the value.

### `impl<A: Array> DerefMut for TinyVec<A>` [src]

#### `#[must_use]fn deref_mut(&mut self) -> &mut Self::Target` [src]

Mutably dereferences the value.

### `impl<A: Array> Display for TinyVec<A> where
A::Item: Display,` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter. Read more

### `impl<A: Array> Eq for TinyVec<A> where
A::Item: Eq,` [src]

### `impl<A: Array> Extend<<A as Array>::Item> for TinyVec<A>` [src]

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

Extends a collection with the contents of an iterator. Read more

#### `pub fn extend_one(&mut self, item: A)` [src]

🔬 This is a nightly-only experimental API. (`extend_one`)

Extends a collection with exactly one element.

#### `pub fn extend_reserve(&mut self, additional: usize)` [src]

🔬 This is a nightly-only experimental API. (`extend_one`)

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

### `impl<T, A> From<&'_ [T]> for TinyVec<A> where
T: Clone + Default,
A: Array<Item = T>,` [src]

#### `#[must_use]fn from(slice: &[T]) -> Self` [src]

Performs the conversion.

### `impl<T, A> From<&'_ mut [T]> for TinyVec<A> where
T: Clone + Default,
A: Array<Item = T>,` [src]

#### `#[must_use]fn from(slice: &mut [T]) -> Self` [src]

Performs the conversion.

### `impl<A: Array> From<A> for TinyVec<A>` [src]

#### `fn from(array: A) -> Self` [src]

Performs the conversion.

### `impl<A: Array> From<ArrayVec<A>> for TinyVec<A>` [src]

#### `#[must_use]fn from(arr: ArrayVec<A>) -> Self` [src]

Performs the conversion.

### `impl<A: Array> FromIterator<<A as Array>::Item> for TinyVec<A>` [src]

#### `#[must_use]fn from_iter<T: IntoIterator<Item = A::Item>>(iter: T) -> Self` [src]

Creates a value from an iterator. Read more

### `impl<A: Array> Hash for TinyVec<A> where
A::Item: Hash,` [src]

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

Feeds this value into the given `Hasher`. Read more

#### `pub 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<A: Array, I: SliceIndex<[A::Item]>> Index<I> for TinyVec<A>` [src]

#### `type Output = <I as SliceIndex<[A::Item]>>::Output`

The returned type after indexing.

#### `#[must_use]fn index(&self, index: I) -> &Self::Output` [src]

Performs the indexing (`container[index]`) operation.

### `impl<A: Array, I: SliceIndex<[A::Item]>> IndexMut<I> for TinyVec<A>` [src]

#### `#[must_use]fn index_mut(&mut self, index: I) -> &mut Self::Output` [src]

Performs the mutable indexing (`container[index]`) operation.

### `impl<A: Array> IntoIterator for TinyVec<A>` [src]

#### `type Item = A::Item`

The type of the elements being iterated over.

#### `type IntoIter = TinyVecIterator<A>`

Which kind of iterator are we turning this into?

#### `#[must_use]fn into_iter(self) -> Self::IntoIter` [src]

Creates an iterator from a value. Read more

### `impl<'a, A: Array> IntoIterator for &'a mut TinyVec<A>` [src]

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

The type of the elements being iterated over.

#### `type IntoIter = IterMut<'a, A::Item>`

Which kind of iterator are we turning this into?

#### `#[must_use]fn into_iter(self) -> Self::IntoIter` [src]

Creates an iterator from a value. Read more

### `impl<'a, A: Array> IntoIterator for &'a TinyVec<A>` [src]

#### `type Item = &'a A::Item`

The type of the elements being iterated over.

#### `type IntoIter = Iter<'a, A::Item>`

Which kind of iterator are we turning this into?

#### `#[must_use]fn into_iter(self) -> Self::IntoIter` [src]

Creates an iterator from a value. Read more

### `impl<A: Array> LowerExp for TinyVec<A> where
A::Item: LowerExp,` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter.

### `impl<A: Array> LowerHex for TinyVec<A> where
A::Item: LowerHex,` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter.

### `impl<A: Array> Octal for TinyVec<A> where
A::Item: Octal,` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter.

### `impl<A: Array> Ord for TinyVec<A> where
A::Item: Ord,` [src]

#### `#[must_use]fn cmp(&self, other: &Self) -> Ordering` [src]

This method returns an `Ordering` between `self` and `other`. Read more

#### `#[must_use]pub fn max(self, other: Self) -> Self` 1.21.0 [src]

Compares and returns the maximum of two values. Read more

#### `#[must_use]pub fn min(self, other: Self) -> Self` 1.21.0 [src]

Compares and returns the minimum of two values. Read more

#### `#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self` 1.50.0 [src]

Restrict a value to a certain interval. Read more

### `impl<A: Array> PartialEq<&'_ [<A as Array>::Item]> for TinyVec<A> where
A::Item: PartialEq,` [src]

#### `#[must_use]fn eq(&self, other: &&[A::Item]) -> bool` [src]

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

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

This method tests for `!=`.

### `impl<A: Array> PartialEq<&'_ A> for TinyVec<A> where
A::Item: PartialEq,` [src]

#### `#[must_use]fn eq(&self, other: &&A) -> bool` [src]

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

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

This method tests for `!=`.

### `impl<A: Array> PartialEq<TinyVec<A>> for TinyVec<A> where
A::Item: PartialEq,` [src]

#### `#[must_use]fn eq(&self, other: &Self) -> bool` [src]

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

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

This method tests for `!=`.

### `impl<A: Array> PartialOrd<TinyVec<A>> for TinyVec<A> where
A::Item: PartialOrd,` [src]

#### `#[must_use]fn partial_cmp(&self, other: &Self) -> Option<Ordering>` [src]

This method returns an ordering between `self` and `other` values if one exists. Read more

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

This method tests less than (for `self` and `other`) and is used by the `<` operator. Read more

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

This method tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more

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

This method tests greater than (for `self` and `other`) and is used by the `>` operator. Read more

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

This method tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more

### `impl<A: Array> Pointer for TinyVec<A> where
A::Item: Pointer,` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter.

### `impl<A: Array> UpperExp for TinyVec<A> where
A::Item: UpperExp,` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter.

### `impl<A: Array> UpperHex for TinyVec<A> where
A::Item: UpperHex,` [src]

#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result` [src]

Formats the value using the given formatter.

## Auto Trait Implementations

### `impl<A> Send for TinyVec<A> where
A: Send,
<A as Array>::Item: Send,` [src]

### `impl<A> Sync for TinyVec<A> where
A: Sync,
<A as Array>::Item: Sync,` [src]

### `impl<A> Unpin for TinyVec<A> where
A: Unpin,
<A as Array>::Item: Unpin,` [src]

## Blanket Implementations

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

#### `pub fn type_id(&self) -> TypeId` [src]

Gets the `TypeId` of `self`. Read more

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

#### `pub fn borrow(&self) -> &T` [src]

Immutably borrows from an owned value. Read more

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

#### `pub fn borrow_mut(&mut self) -> &mut T` [src]

Mutably borrows from an owned value. Read more

### `impl<T> From<!> for T` [src]

#### `pub fn from(t: !) -> T` [src]

Performs the conversion.

### `impl<T> From<T> for T` [src]

#### `pub fn from(t: T) -> T` [src]

Performs the conversion.

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

#### `pub fn into(self) -> U` [src]

Performs the conversion.

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

#### `type Owned = T`

The resulting type after obtaining ownership.

#### `pub fn to_owned(&self) -> T` [src]

Creates owned data from borrowed data, usually by cloning. Read more

#### `pub fn clone_into(&self, target: &mut T)` [src]

🔬 This is a nightly-only experimental API. (`toowned_clone_into`)

recently added

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

### `impl<T> ToString for T where
T: Display + ?Sized,` [src]

#### `pub default fn to_string(&self) -> String` [src]

Converts the given value to a `String`. Read more

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

#### `type Error = Infallible`

The type returned in the event of a conversion error.

#### `pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>` [src]

Performs the conversion.

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

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

The type returned in the event of a conversion error.

#### `pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>` [src]

Performs the conversion.