Struct minivec::MiniVec

#[repr(transparent)]
pub struct MiniVec<T> { /* fields omitted */ }

MiniVec is a space-optimized implementation of alloc::vec::Vec that is only the size of a single pointer and also extends portions of its API, including support for over-aligned allocations. MiniVec also aims to bring as many Nightly features from Vec to stable toolchains as is possible. In many cases, it is a drop-in replacement for the “real” Vec.

Implementations

impl<T> MiniVec<T>

pub fn append(&mut self, other: &mut MiniVec<T>)

append moves every element from other to the back of self. other.is_empty() is true once this operation completes and its capacity is unaffected.

Example

let mut vec = minivec::mini_vec![1, 2, 3];
let mut vec2 = minivec::mini_vec![4, 5, 6];
vec.append(&mut vec2);
assert_eq!(vec, [1, 2, 3, 4, 5, 6]);
assert_eq!(vec2, []);

pub fn as_mut_ptr(&mut self) -> *mut T

as_mut_ptr returns a *mut T to the underlying array.

• May return a null pointer.
• May be invalidated by calls to reserve()
• Can outlive its backing MiniVec

Example

let mut vec = minivec::mini_vec![1, 2, 3, 4];
let mut p = vec.as_mut_ptr();

for idx in 0..vec.len() {
    unsafe {
        *p.add(idx) = *p.add(idx) + 3;
    }
}

assert_eq!(vec, [4, 5, 6, 7]);

pub fn as_mut_slice(&mut self) -> &mut [T]

as_mut_slice obtains a mutable reference to a slice that’s attached to the backing array.

Example

let mut vec = minivec::mini_vec![1, 2, 3];
{
    let as_slice: &mut [_] = vec.as_mut_slice();
    as_slice[0] = 1337;
}
assert_eq!(vec[0], 1337);

pub fn as_ptr(&self) -> *const T

as_ptr obtains a *const T to the underlying allocation.

• May return a null pointer.
• May be invalidated by calls to reserve()
• Can outlive its backing MiniVec
• May allow access to unitialized memory/non-existent objects
• May create out-of-bounds memory access

Example

let mut vec = minivec::mini_vec![1, 2, 3, 4];
let mut p = vec.as_mut_ptr();

let mut sum = 0;
for idx in 0..vec.len() {
    unsafe {
        sum += *p.add(idx);
    }
}

assert_eq!(sum, 1 + 2 + 3 + 4);

pub fn as_slice(&self) -> &[T]

as_slice obtains a reference to the backing array as an immutable slice of T.

Example

let vec = minivec::mini_vec![1, 2, 3, 4];
let mut sum = 0;

let as_slice : &[_] = vec.as_slice();

for idx in 0..vec.len() {
    sum += as_slice[idx];
}

assert_eq!(sum, 1 + 2 + 3 + 4);

pub fn capacity(&self) -> usize

capacity obtains the number of elements that can be inserted into the MiniVec before a reallocation will be required.

Note: MiniVec aims to use the same reservation policy as alloc::vec::Vec.

Example

let vec = minivec::MiniVec::<i32>::with_capacity(128);

assert_eq!(vec.len(), 0);
assert_eq!(vec.capacity(), 128);

pub fn clear(&mut self)

clear clears the current contents of the MiniVec. Afterwards, len() will return 0. capacity() is not affected.

Logically equivalent to calling minivec::MiniVec::truncate(0).

Note: destruction order of the contained elements is not guaranteed.

Example

let mut vec = minivec::mini_vec![-1; 256];

let cap = vec.capacity();

assert_eq!(vec.len(), 256);

vec.clear();

assert_eq!(vec.len(), 0);
assert_eq!(vec.capacity(), cap);

pub fn dedup(&mut self) where
    T: PartialEq, 

dedeup “de-duplicates” all adjacent identical values in the vector.

Logically equivalent to calling minivec::MiniVec::dedup_by(|x, y| x == y).

Example

let mut v = minivec::mini_vec![1, 2, 1, 1, 3, 3, 3, 4, 5, 4];
v.dedup();

assert_eq!(v, [1, 2, 1, 3, 4, 5, 4]);

pub fn dedup_by<F>(&mut self, pred: F) where
    F: FnMut(&mut T, &mut T) -> bool, 

dedup_by “de-duplicates” all adjacent elements for which the supplied binary predicate returns true.

Example

let mut vec = minivec::mini_vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

vec.dedup_by(|x, y| *x + *y < 8);

// 1 + 2 < 8
// 1 + 3 < 8
// 1 + 4 < 8...
// 1 + 7 == 8
assert_eq!(vec, [1, 7, 8, 9, 10]);

pub fn dedup_by_key<F, K>(&mut self, key: F) where
    F: FnMut(&mut T) -> K,
    K: PartialEq<K>, 

dedup_by_key “de-duplicates” all adjacent elements where key(elem1) == key(elem2).

Example

let mut vec = minivec::mini_vec!["a", "b", "c", "aa", "bbb", "cc", "dd"];

vec.dedup_by_key(|x| x.len());

assert_eq!(vec, ["a", "aa", "bbb", "cc"]);

pub fn drain<R>(&mut self, range: R) -> Drain<'_, T> where
    R: RangeBounds<usize>, 

drain returns a minivec::Drain iterator which lazily removes elements from the supplied range.

If the returned iterator is not iterated until exhaustion then the Drop implementation for Drain will remove the remaining elements.

Panics

Panics if the supplied range would be outside the vector

Example

let mut vec = minivec::mini_vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

let other_vec : minivec::MiniVec<_> = vec.drain(1..7).map(|x| x + 2).collect();

assert_eq!(vec, [1, 8, 9, 10]);
assert_eq!(other_vec, [4, 5, 6, 7, 8, 9]);

pub fn drain_filter<F>(&mut self, pred: F) -> DrainFilter<'_, T, F> where
    F: FnMut(&mut T) -> bool, 

drain_filter creates a new DrainFilter iterator that when iterated will remove all elements for which the supplied pred returns true.

Removal of elements is done by transferring ownership of the element to the iterator.

Note: if the supplied predicate panics then DrainFilter will stop all usage of it and then backshift all untested elements and adjust the MiniVec’s length accordingly.

Example

let mut vec = minivec::mini_vec![
    1, 2, 4, 6, 7, 9, 11, 13, 15, 17, 18, 20, 22, 24, 26, 27, 29, 31, 33, 34, 35, 36, 37,
    39,
];

let removed = vec.drain_filter(|x| *x % 2 == 0).collect::<minivec::MiniVec<_>>();
assert_eq!(removed.len(), 10);
assert_eq!(removed, vec![2, 4, 6, 18, 20, 22, 24, 26, 34, 36]);

assert_eq!(vec.len(), 14);
assert_eq!(
    vec,
    vec![1, 7, 9, 11, 13, 15, 17, 27, 29, 31, 33, 35, 37, 39]
);

pub fn drain_vec(&mut self) -> Self

drain_vec returns a new instance of a MiniVec, created by moving the content out of self.

Compared to drain method, this is just simple swap of pointers. As result, any pointer to self becomes invalid.

Example

use minivec::mini_vec;

let mut vec = mini_vec![1, 2, 3, 4, 5, 6, 7, 9];
let new_vec = vec.drain_vec();

assert_eq!(vec.len(), 0);
assert_eq!(new_vec, [1, 2, 3, 4, 5, 6, 7, 9]);

let new_vec = vec.drain_vec();
assert_eq!(vec.len(), 0);
assert_eq!(new_vec, []);

pub unsafe fn from_raw_part(ptr: *mut T) -> MiniVec<T>

from_raw_part reconstructs a MiniVec from a previous call to MiniVec::as_mut_ptr or the pointer from into_raw_parts.

Safety

from_raw_part is incredibly unsafe and can only be used with the value of MiniVec::as_mut_ptr. This is because the allocation for the backing array stores metadata at its head and is not guaranteed to be stable so users are discouraged from attempting to support this directly.

Panics

Panics in debug mode if the supplied pointer is null.

Example

let mut vec = minivec::mini_vec![1, 2, 3, 4];

let ptr = vec.as_mut_ptr();

std::mem::forget(vec);

let new_vec = unsafe { minivec::MiniVec::from_raw_part(ptr) };

assert_eq!(new_vec, [1, 2, 3, 4]);

pub unsafe fn from_raw_parts(
    ptr: *mut T,
    length: usize,
    capacity: usize
) -> MiniVec<T>

from_raw_parts is an API-compatible version of alloc::vec::Vec::from_raw_parts. Because of MiniVec’s optimized layout, it’s not strictly required for a user to pass the length and capacity explicitly.

Like MiniVec::from_raw_part, this function is only safe to use with the result of a call to MiniVec::as_mut_ptr().

Panics

Panics in debug mode if the supplied pointer is null.

Safety

A very unsafe function that should only really be used when passing the vector to a C API.

Does not support over-aligned allocations. The alignment of the pointer must be that of its natural alignment.

Example

let mut vec = minivec::mini_vec![1, 2, 3, 4];
let len = vec.len();
let cap = vec.capacity();

let ptr = vec.as_mut_ptr();

std::mem::forget(vec);

let new_vec = unsafe { minivec::MiniVec::from_raw_parts(ptr, len, cap) };

assert_eq!(new_vec, [1, 2, 3, 4]);

pub fn insert(&mut self, index: usize, element: T)

insert places an element at the specified index, subsequently shifting all elements to the right of the insertion index by 1

Panics

Will panic when index > vec.len().

Example

let mut vec = minivec::mini_vec![0, 1, 2, 3];
vec.insert(1, 1337);
assert_eq!(vec, [0, 1337, 1, 2, 3]);

vec.insert(vec.len(), 7331);
assert_eq!(vec, [0, 1337, 1, 2, 3, 7331]);

pub fn into_raw_parts(self) -> (*mut T, usize, usize)

into_raw_parts will leak the underlying allocation and return a tuple containing a pointer to the start of the backing array and its length and capacity.

The results of this function are directly compatible with from_raw_parts.

Example

let vec = minivec::mini_vec![1, 2, 3, 4, 5];
let (old_len, old_cap) = (vec.len(), vec.capacity());

let (ptr, len, cap) = vec.into_raw_parts();
assert_eq!(len, old_len);
assert_eq!(cap, old_cap);

let vec = unsafe { minivec::MiniVec::from_raw_parts(ptr, len, cap) };
assert_eq!(vec, [1, 2, 3, 4, 5]);

pub fn is_empty(&self) -> bool

is_empty() returns whether or not the MiniVec has a length greater than 0.

Logically equivalent to manually writing: v.len() == 0.

Example

let vec = minivec::MiniVec::<i32>::with_capacity(256);
assert!(vec.is_empty());
assert!(vec.capacity() > 0);

pub fn leak<'a>(vec: MiniVec<T>) -> &'a mut [T] where
    T: 'a, 

leak “leaks” the supplied MiniVec, i.e. turn it into a ManuallyDrop instance and return a reference to the backing array via &'a [T] where 'a is a user-supplied lifetime.

Most useful for turning an allocation with dynamic duration into one with static duration.

Example

let vec = minivec::mini_vec![1, 2, 3];
let static_ref: &'static mut [i32] = minivec::MiniVec::leak(vec);
static_ref[0] += 1;
assert_eq!(static_ref, &[2, 2, 3]);

pub fn len(&self) -> usize

len returns the current lenght of the vector, i.e. the number of actual elements in it

capacity() >= len() is true for all cases

Example

let mut vec = minivec::mini_vec![-1; 256];
assert_eq!(vec.len(), 256);

pub fn new() -> MiniVec<T>

MiniVec::new constructs an empty MiniVec.

Note: does not allocate any memory.

Panics

Panics when a zero-sized type is attempted to be used.

Example

let mut vec = minivec::MiniVec::<i32>::new();

assert_eq!(vec.as_mut_ptr(), std::ptr::null_mut());
assert_eq!(vec.len(), 0);
assert_eq!(vec.capacity(), 0);

pub fn pop(&mut self) -> Option<T>

pop removes the last element from the vector, should it exist, and returns an Option which owns the removed element.

Example

let mut vec = minivec::mini_vec![Box::new(1)];
let ptr = vec.pop().unwrap();
assert_eq!(*ptr, 1);

assert_eq!(vec.pop(), None);

pub fn push(&mut self, value: T) -> &mut T

push appends an element value to the end of the vector. push automatically reallocates if the vector does not have sufficient capacity.

Unlike the standard library Vec, MiniVec::push returns a mutable reference to the newly created element that’s been placed at the back of the vector.

Example

let mut vec = minivec::MiniVec::<i32>::with_capacity(64);

for idx in 0..128 {
    vec.push(idx);
}

assert_eq!(vec.len(), 128);

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

remove moves the element at the specified index and then returns it to the user. This operation shifts all elements to the right index to the left by one so it has a linear time complexity of vec.len() - index.

Panics

Panics if index >= len().

Example

let mut vec = minivec::mini_vec![0, 1, 2, 3];
vec.remove(0);

assert_eq!(vec, [1, 2, 3]);

pub fn remove_item<V>(&mut self, item: &V) -> Option<T> where
    T: PartialEq<V>, 

remove_item removes the first element identical to the supplied item using a left-to-right traversal of the elements.

Example

let mut vec = minivec::mini_vec![0, 1, 1, 1, 2, 3, 4];
vec.remove_item(&1);

assert_eq!(vec, [0, 1, 1, 2, 3, 4]);

pub fn reserve(&mut self, additional: usize)

reserve ensures there is sufficient capacity for additional extra elements to be either inserted or appended to the end of the vector. Will reallocate if needed otherwise this function is a no-op.

Guarantees that the new capacity is greater than or equal to len() + additional.

Example

let mut vec = minivec::MiniVec::<i32>::new();

assert_eq!(vec.capacity(), 0);

vec.reserve(128);

assert!(vec.capacity() >= 128);

pub fn reserve_exact(&mut self, additional: usize)

reserve_exact ensures that the capacity of the vector is exactly equal to len() + additional unless the capacity is already sufficient in which case no operation is performed.

Example

let mut vec = minivec::MiniVec::<i32>::new();
vec.reserve_exact(57);

assert_eq!(vec.capacity(), 57);

pub fn resize(&mut self, new_len: usize, value: T) where
    T: Clone, 

resize will clone the supplied value as many times as required until len() becomes new_len. If the current len() is greater than new_len then the vector is truncated in a way that’s identical to calling vec.truncate(new_len). If the len() and new_len match then no operation is performed.

Example

let mut vec = minivec::mini_vec![-1; 256];

vec.resize(512, -1);
assert_eq!(vec.len(), 512);

vec.resize(64, -1);
assert_eq!(vec.len(), 64);

pub fn resize_with<F>(&mut self, new_len: usize, f: F) where
    F: FnMut() -> T, 

resize_with will invoke the supplied callable f as many times as is required until len() == new_len is true. If the new_len exceeds the current len() then the vector will be resized via a call to truncate(new_len). If the new_len and len() are equal then no operation is performed.

Example

let mut vec = minivec::MiniVec::<i32>::new();

vec.resize_with(128, || 1337);
assert_eq!(vec.len(), 128);

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

retain removes all elements from the vector for with f(elem) is false using a left-to-right traversal.

Example

let mut vec = minivec::mini_vec![1, 2, 3, 4, 5, 6];

let is_even = |x: &i32| *x % 2 == 0;
vec.retain(is_even);
assert_eq!(vec, [2, 4, 6]);

pub unsafe fn set_len(&mut self, len: usize)

set_len reassigns the internal len_ data member to the user-supplied len.

Safety

This function is unsafe in the sense that it will NOT call .drop() on the elements excluded from the new len so this function should only be called when T is a Copy type.

Example

let mut vec = minivec::mini_vec![1, 2, 3, 4];
unsafe { vec.set_len(2) };

assert_eq!(vec.len(), 2);

pub fn shrink_to(&mut self, min_capacity: usize)

shrink_to will attempt to adjust the backing allocation such that it has space for at least min_capacity elements.

If the min_capacity is smaller than the current length of the vector then the capacity will be shrunk down to len().

If the capacity() is identical to min_capacity then this function does nothing.

Panics

If the min_capacity is larger than the current capacity this function will panic.

Otherwise, the allocation is reallocated with the new min_capacity kept in mind.

Example

let mut vec = minivec::MiniVec::<i32>::with_capacity(128);
assert!(vec.capacity() >= 128);

vec.shrink_to(64);
assert_eq!(vec.capacity(), 64);

pub fn shrink_to_fit(&mut self)

shrink_to_fit will re-adjust the backing allocation such that its capacity is now equal to its length

Example

let mut vec = minivec::MiniVec::with_capacity(512);

vec.push(1);
vec.push(2);
vec.push(3);

vec.shrink_to_fit();

assert_eq!(vec.capacity(), 3);

pub fn spare_capacity_mut(&mut self) -> &mut [MaybeUninit<T>]

spare_capacity_mut returns a mutable slice to MaybeUninit<T>. This is a more structured way of interacting with MiniVec as an unitialized allocation vs simply creating a vector with capacity and then mutating its contents directly via as_mut_ptr.

Once manipulation of the unitialized elements has been completed, a call to set_len is required otherwise the contained elements cannot be accessed by MiniVec’s normal methods nor will the elements be dropped.

Example

let mut vec = minivec::MiniVec::<i32>::with_capacity(24);
let mut buf = vec.spare_capacity_mut();

for idx in 0..4 {
    unsafe { buf[idx].as_mut_ptr().write(idx as i32) };
}

unsafe { vec.set_len(4) };

assert_eq!(vec, [0, 1, 2, 3]);

pub fn splice<R, I>(
    &mut self,
    range: R,
    replace_with: I
) -> Splice<'_, <I as IntoIterator>::IntoIter> where
    I: IntoIterator<Item = T>,
    R: RangeBounds<usize>, 

splice returns a Splice iterator. Splice is similar in spirit to Drain but instead of simply shifting the remaining elements from the vector after it’s been drained, the range is replaced with the Iterator specified by replace_with.

Much like Drain, if the Splice iterator is not iterated until exhaustion then the remaining elements will be removed when the iterator is dropped.

Splice only fills the removed region when it is dropped.

Panics

Panics if the supplied range is outside of the vector’s bounds.

Example

let mut x = minivec::mini_vec![1, 2, 3, 4, 5, 6];
let new = [7, 8];

let y: minivec::MiniVec<_> = x.splice(1..4, new.iter().cloned()).collect();

assert_eq!(x, &[1, 7, 8, 5, 6]);
assert_eq!(y, &[2, 3, 4]);

pub fn split_at_spare_mut(&mut self) -> (&mut [T], &mut [MaybeUninit<T>])

split_at_spare_mut returns a pair containing two mutable slices: one referring to the currently initialized elements and the other pointing to the spare capacity of the backing allocation as a &mut [MaybeUninit<T>].

This is a convenience API that handles borrowing issues when attempting to do something like:

let (init, uninit) = (vec.as_mut_slice(), vec.spare_capacity_mut());

which results in borrowing errors from the compiler:

cannot borrow vec as mutable more than once at a time

Safety

When working with uninitialized storage, it is required that the user call set_len() appropriately to readjust the length of the vector. This ensures that newly inserted elements are dropped when needed.

Example

let mut vec = minivec::MiniVec::<String>::with_capacity(4);
vec.push(String::from("hello"));
vec.push(String::from("world"));

let (_, uninit) = vec.split_at_spare_mut();
uninit[0] = core::mem::MaybeUninit::<String>::new(String::from("rawr"));
uninit[1] = core::mem::MaybeUninit::<String>::new(String::from("RAWR"));

unsafe { vec.set_len(4) };

assert_eq!(vec[2], "rawr");
assert_eq!(vec[3], "RAWR");

pub fn split_off(&mut self, at: usize) -> MiniVec<T>

split_off will segment the vector into two, returning the new segment to the user.

After this function call, self will have kept elements [0, at) while the new segment contains elements [at, len).

Panics

Panics if at is greater than len().

Example

let mut vec = minivec::mini_vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

let tail = vec.split_off(7);

assert_eq!(vec, [0, 1, 2, 3, 4, 5, 6]);
assert_eq!(tail, [7, 8, 9, 10]);

pub fn swap_remove(&mut self, index: usize) -> T

swap_remove removes the element located at index and replaces it with the last value in the vector, returning the removed element to the caller.

Panics

Panics if index >= len().

Example

let mut vec = minivec::mini_vec![1, 2, 3, 4];

let num = vec.swap_remove(0);
assert_eq!(num, 1);
assert_eq!(vec, [4, 2, 3]);

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

truncate adjusts the length of the vector to be len. If len is greater than or equal to the current length no operation is performed. Otherwise, the vector’s length is readjusted to len and any remaining elements to the right of len are dropped.

Example

let mut vec = minivec::mini_vec![1, 2, 3, 4, 5];
vec.truncate(2);

assert_eq!(vec, [1, 2]);

pub fn with_alignment(
    capacity: usize,
    alignment: usize
) -> Result<MiniVec<T>, LayoutErr>

with_alignment is similar to its counterpart with_capacity except it takes an additional argument: the alignment to use for the allocation.

The supplied alignment must be a number divisible by 2 and larger than or equal to the result of core::mem::align_of::<*const ()>().

The internal allocation used to store the header information for MiniVec is aligned to the supplied value and then sufficient padding is inserted such that the result of as_ptr() will always be aligned as well.

This is useful for creating over-aligned allocations for primitive types such as when using SIMD intrinsics. For example, some vectorized floating point loads and stores must be aligned on a 32 byte boundary. with_alignment is intended to make this possible with a Vec-like container.

Errors

Returns a Result that contains either MiniVec<T> or a LayoutErr.

Example

#[cfg(target_arch = "x86")]
use std::arch::x86::*;
#[cfg(target_arch = "x86_64")]
use std::arch::x86_64::*;

let alignment = 32;
let num_elems = 2048;
let mut v1 = minivec::MiniVec::<f32>::with_alignment(num_elems, alignment).unwrap();
let mut v2 = minivec::MiniVec::<f32>::with_alignment(num_elems, alignment).unwrap();

v1
    .spare_capacity_mut()
    .iter_mut()
    .zip(v2.spare_capacity_mut().iter_mut())
    .enumerate()
    .for_each(|(idx, (x1, x2))| {
        *x1 = core::mem::MaybeUninit::new(idx as f32);
        *x2 = core::mem::MaybeUninit::new(idx as f32);
    });

unsafe {
    v1.set_len(num_elems);
    v2.set_len(num_elems);

    // use vectorization to speed up the summation of two vectors
    //
    for idx in 0..(num_elems / 8) {
        let offset = idx * 8;

        let p = v1.as_mut_ptr().add(offset);
        let q = v2.as_mut_ptr().add(offset);

        let r1 = _mm256_load_ps(p);
        let r2 = _mm256_load_ps(q);
        let r3 = _mm256_add_ps(r1, r2);

        _mm256_store_ps(p, r3);
    }
}

v1
    .iter()
    .enumerate()
    .for_each(|(idx, v)| {
        assert_eq!(*v, idx as f32 * 2.0);
    });

pub fn with_capacity(capacity: usize) -> MiniVec<T>

with_capacity is a static factory function that returns a MiniVec that contains space for capacity elements.

This function is logically equivalent to calling .reserve_exact() on a vector with 0 capacity.

Example

let mut vec = minivec::MiniVec::<i32>::with_capacity(128);

assert_eq!(vec.len(), 0);
assert_eq!(vec.capacity(), 128);

impl<T: Clone> MiniVec<T>

pub fn extend_from_slice(&mut self, elems: &[T])

extend_from_slice will append each element from elems in a left-to-right order, cloning each value in elems.

Example

let mut vec = minivec::mini_vec![1, 2];

let s : &[i32] = &[3, 4];

vec.extend_from_slice(s);

assert_eq!(vec, [1, 2, 3, 4]);

pub fn extend_from_within<Range>(&mut self, range: Range) where
    Range: RangeBounds<usize>, 

extend_from_within clones the elements contained in the provided Range and appends them to the end of the vector, allocating extra space as required.

Panics

Panics if the provided range exceeds the bounds of [0, len).

Example

let mut vec = minivec::mini_vec![1, 2, 3, 4, 5];
vec.extend_from_within(1..4);

assert_eq!(vec, [1, 2, 3, 4, 5, 2, 3, 4]);

impl<T> MiniVec<MaybeUninit<T>>

pub unsafe fn assume_minivec_init(self) -> MiniVec<T>

assume_minivec_init is a helper designed to make working with uninitialized memory more ergonomic.

Safety

Whatever length the current MiniVec has, it is consumed and then returned to the caller as a MiniVec<T> thus making the function unsafe as it relies on the caller to uphold length invariants.

Example

let mut buf = minivec::mini_vec![core::mem::MaybeUninit::<u8>::uninit(); 512];
buf
  .iter_mut()
  .for_each(|v| *v = core::mem::MaybeUninit::new(137));

unsafe { buf.set_len(512) };

let bytes = unsafe { buf.assume_minivec_init() };
assert_eq!(bytes[0], 137);
assert_eq!(bytes[511], 137);

Trait Implementations

impl<T> AsMut<[T]> for MiniVec<T>

fn as_mut(&mut self) -> &mut [T]

Performs the conversion.

impl<T> AsMut<MiniVec<T>> for MiniVec<T>

fn as_mut(&mut self) -> &mut MiniVec<T>

Performs the conversion.

impl<T> AsRef<[T]> for MiniVec<T>

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

Performs the conversion.

impl<T> AsRef<MiniVec<T>> for MiniVec<T>

fn as_ref(&self) -> &MiniVec<T>

Performs the conversion.

impl<T> Borrow<[T]> for MiniVec<T>

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

Immutably borrows from an owned value.

impl<T> BorrowMut<[T]> for MiniVec<T>

fn borrow_mut(&mut self) -> &mut [T]

Mutably borrows from an owned value.

impl<T: Clone> Clone for MiniVec<T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for MiniVec<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for MiniVec<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T> Deref for MiniVec<T>

type Target = [T]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for MiniVec<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T> Drop for MiniVec<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T> Extend<&'a T> for MiniVec<T> where
    T: 'a + Copy, 

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

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

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

impl<T> Extend<T> for MiniVec<T>

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

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

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

impl<'a, T> From<&'a [T]> for MiniVec<T> where
    T: Clone, 

fn from(s: &'a [T]) -> Self

Performs the conversion.

impl<'a, T> From<&'a MiniVec<T>> for Cow<'a, [T]> where
    T: Clone, 

fn from(v: &'a MiniVec<T>) -> Cow<'a, [T]>

Performs the conversion.

impl<'a, T> From<&'a mut [T]> for MiniVec<T> where
    T: Clone, 

fn from(s: &'a mut [T]) -> Self

Performs the conversion.

impl<'a> From<&'a str> for MiniVec<u8>

fn from(s: &'a str) -> Self

Performs the conversion.

impl<A> FromIterator<A> for MiniVec<A>

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

Creates a value from an iterator.

impl<T> Hash for MiniVec<T> where
    T: Hash, 

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<T, I> Index<I> for MiniVec<T> where
    I: SliceIndex<[T]>, 

type Output = <I as SliceIndex<[T]>>::Output

The returned type after indexing.

fn index(&self, index: I) -> &<MiniVec<T> as Index<I>>::Output

Performs the indexing (container[index]) operation.

impl<T, I> IndexMut<I> for MiniVec<T> where
    I: SliceIndex<[T]>, 

fn index_mut(&mut self, index: I) -> &mut <MiniVec<T> as Index<I>>::Output

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

impl<T> IntoIterator for MiniVec<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a MiniVec<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T> IntoIterator for &'a mut MiniVec<T>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

impl<T: Ord> Ord for MiniVec<T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<T, U, const N: usize> PartialEq<&'_ [U; N]> for MiniVec<T> where
    T: PartialEq<U>, 

fn eq(&self, other: &&[U; N]) -> bool

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

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

This method tests for !=.

impl<T, U> PartialEq<&'_ [U]> for MiniVec<T> where
    T: PartialEq<U>, 

fn eq(&self, other: &&[U]) -> bool

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

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

This method tests for !=.

impl<T, U> PartialEq<&'_ mut [U]> for MiniVec<T> where
    T: PartialEq<U>, 

fn eq(&self, other: &&mut [U]) -> bool

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

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

This method tests for !=.

impl<T, U, const N: usize> PartialEq<[U; N]> for MiniVec<T> where
    T: PartialEq<U>, 

fn eq(&self, other: &[U; N]) -> bool

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

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

This method tests for !=.

impl<T, U> PartialEq<[U]> for MiniVec<T> where
    T: PartialEq<U>, 

fn eq(&self, other: &[U]) -> bool

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

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

This method tests for !=.

impl<T, U> PartialEq<MiniVec<U>> for MiniVec<T> where
    T: PartialEq<U>, 

fn eq(&self, other: &MiniVec<U>) -> bool

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

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

This method tests for !=.

impl<T, U> PartialEq<MiniVec<U>> for &[T] where
    T: PartialEq<U>, 

fn eq(&self, other: &MiniVec<U>) -> bool

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

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

This method tests for !=.

impl<T, U> PartialEq<MiniVec<U>> for &mut [T] where
    T: PartialEq<U>, 

fn eq(&self, other: &MiniVec<U>) -> bool

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

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

This method tests for !=.

impl<T, U> PartialEq<Vec<U, Global>> for MiniVec<T> where
    T: PartialEq<U>, 

fn eq(&self, other: &Vec<U>) -> bool

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

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

This method tests for !=.

impl<T> PartialOrd<MiniVec<T>> for MiniVec<T> where
    T: PartialOrd, 

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

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

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

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

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

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

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

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

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

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

impl<T> Eq for MiniVec<T> where
    T: Eq, 

impl<T: Send> Send for MiniVec<T>

impl<T: Sync> Sync for MiniVec<T>