#vec #any #container


Type erased vector. Most operations can be done without type knowledge. Mostly zero overhead.

14 releases (breaking)

0.11.0 Aug 26, 2022
0.10.0 Jul 10, 2022
0.9.1 Jun 28, 2022

#218 in Data structures

Download history 20/week @ 2022-11-27 12/week @ 2022-12-04 27/week @ 2022-12-11 26/week @ 2022-12-18 9/week @ 2022-12-25 10/week @ 2023-01-01 23/week @ 2023-01-08 8/week @ 2023-01-15 20/week @ 2023-01-22 26/week @ 2023-01-29 25/week @ 2023-02-05 36/week @ 2023-02-12 61/week @ 2023-02-19 3/week @ 2023-02-26 12/week @ 2023-03-05 13/week @ 2023-03-12

90 downloads per month
Used in 2 crates


2.5K SLoC

crates.io license Docs CI

Type erased vector. All elements have the same type.

Designed to be type-erased as far as possible - most of the operations does not know about concrete type.

Only type-erased destruct and clone operations have additional overhead of indirect call.


    let mut vec: AnyVec = AnyVec::new::<String>();
        // Typed operations.
        let mut vec = vec.downcast_mut::<String>().unwrap();
    let mut other_vec: AnyVec = AnyVec::new::<String>();
    // Fully type erased element move from one vec to another
    // without intermediate mem-copies.
    let element = vec.swap_remove(0);

    // Output 2 1
    for s in vec.downcast_ref::<String>().unwrap(){
        println!("{}", s);

See documentation for more.

Send, Sync, Clone

You can make AnyVec Sendable, Syncable, Cloneable:

use any_vec::AnyVec;
use any_vec::traits::*;
let v1: AnyVec<dyn Cloneable + Sync + Send> = AnyVec::new::<String>();
let v2 = v1.clone();

This constraints will be applied compiletime to element type:

// This will fail to compile. 
let v1: AnyVec<dyn Sync + Send> = AnyVec::new::<Rc<usize>>();


Whenever possible, any_vec type erased elements can be lazily cloned:

 let mut v1: AnyVec<dyn Cloneable> = AnyVec::new::<String>();

 let mut v2: AnyVec<dyn Cloneable> = AnyVec::new::<String>();
 let e = v1.swap_remove(0);


MemBuilder + Mem works like Allocator for AnyVec. But unlike allocator, Mem container-specialized design allows to perform more optimizations. For example, it is possible to make stack-allocated FixedAnyVec and small-buffer-optimized(SBO) SmallAnyVec from AnyVec by just changing MemBuilder:

type FixedAnyVec<Traits = dyn None> = AnyVec<Traits, Stack<512>>;
let mut any_vec: FixedAnyVec = AnyVec::new::<String>();

// This will be on stack, without any allocations.

With help of clone_empty_in you can use stack allocated, or SBO AnyVec as fast intermediate storage for values of unknown type:

fn self_push_first_element<T: Trait + Cloneable>(any_vec: &mut AnyVec<T>){
    let mut tmp = any_vec.clone_empty_in(StackN::<1, 256>);

MemBuilder interface, being stateful, allow to make Mem, which can work with complex custom allocators.


See CHANGELOG.md for version differences.

Known alternatives

  • type_erased_vec. Allow to store Vec<T> in type erased way, but you need to perform operations, you need to "cast" to concrete type first.
  • untyped_vec. Some operations like len, capacity performed without type knowledge; but the rest - require concrete type.

No runtime deps