#[derive(Copy, Clone, Debug, PartialEq, Eq)]
struct Digit {
    x: u8, // x >= 0 && x <= 9
}

unsafe impl EnumLike for Digit {
    const NUM_VARIANTS: usize = 10;
    fn to_discr(self) -> usize {
        self.x as usize
    }
    fn from_discr(x: usize) -> Self {
        let x = x as u8;
        Self { x }
    }
}

这个特性是不安全的，因为其他代码假定 to_discr() 从不返回一个大于 >= NUM_VARIANTS 的值。

内存效率

由于默认情况下每个块为32位，当每个元素长度为1、2、4、8、16或32位时，EnumVec 才能达到100%的内存效率。这是因为元素永远不会跨两个块分割：一个15位的元素存储在32位块中时，将始终使用30位，并浪费剩余的2位。一般来说，效率可以计算为 1 - (32 % n) / 32，但它始终等于或优于普通的 Vec。然而，当 n >= 11 时，它们是相等的，所以如果你有一个具有2048种变体的类型，你应该考虑使用 Vec。

完整的表格可以作为Python单行脚本获得

x = [(n, n/8 if n <= 8 else n/16 if n <= 16 else n/32 if n <= 32 else n/64, 1-(8%n)/8, 1-(16%n)/16, 1-(32%n)/32, 1-(64%n)/64, 1-(128%n)/128) for n in range(1, 64+1)]

具有8位存储块的 EnumVec8 不能用于存储大于8位的项。同样，对于存储大于32位的元素，默认的 EnumVec32 是不够的。一个项的最大大小（位）在 EnumLike 库中定义为可以放入一个 usize 的位数。具有128位存储的 EnumVec 是目前最节省内存的选项，但在典型的64位机器上，大多数操作比其他实现慢2倍。8、16、32和64位版本的性能相似。

每个 EnumVecN 的“效率限制”，即它优于 Vec 的最大项大小（位），如下所示

自定义

要更改默认存储，请从内部模块导入 EnumVec

use enum_vec::vec_u64::EnumVec;
use enum_vec::vec_u8::EnumVec as EnumVec8;

这将使 EnumVec 使用64位块，从而提高内存效率，并添加使用8位块的 EnumVec8 的选项。请注意，enum_vec![] 宏始终创建一个 EnumVec，所以以下代码将无法编译：

let a: EnumVec8 = enum_vec![];

将无法编译。

选择哪种存储大小？

• 使用 EnumVec8 来最小化小型向量的开销，实际上可以考虑使用 SmallEnumVec。
• 使用 EnumVec64 来处理非常大的向量，特别是当元素位大小不是2的幂时，因为它在某些情况下更节省内存。
• 只有当内存效率比性能更重要时才使用 EnumVec128。
• 如果性能比内存效率更重要，请使用 Vec。
• 如果大多数时候需要存储少量元素（最多128位），请使用 SmallEnumVec。

PackedU8

当项目大小为8位或16位时，使用Vec总是更好的选择。但这并不总是容易的，因为一个Vec<[bool; 8]>会使用每个元素8个字节而不是8位。为了强制它使用8位，请将其包装为Vec<PackedU8<[bool; 8]>>

use enum_like::PackedU8;

let a = vec![PackedU8::new([true; 8]); 10];

for x in a {
    let x = x.value();
}

SmallEnumVec

有一个实验性的SmallEnumVec可在以下位置使用：

use enum_vec::smallvec_u32::EnumVec as SmallEnumVec;

当使用smallvec特性编译时，该特性在Cargo.toml中启用。

enum_vec = { version = "0.3", features = ["smallvec"] }

SmallEnumVec将使用堆栈来存储项目，并且只有在它变得太大时才会进行分配。目前默认情况下是使用4x32位的内联存储。这将允许存储128个1位项目，64个2位，32个4位等。

有关更多信息，请参阅smallvec存储库。

缺点

• 由于EnumVec不能返回引用，因此没有索引语法。请使用get和set代替。
• 您不能使用slice方法，如split()、get(range)、reverse()、chunk和window迭代器、sort()、dedup()等。因为没有实现deref（与可以用于&Vec的&[T]不同）。
• 大多数操作（push、pop、insert、remove）的速度大约是Vec等价的2或3倍。像extend、from_slice或vec![None; 1000];这样的操作甚至更糟糕。

基准测试

以下是当T需要2位存储时，Vec<T>与EnumVec<T>的比较。

(提交e8db9c883b82e472e9aefb6087be55dafd76b6a0)

 name                           normal_vec2 ns/iter  enum_vec32_2 ns/iter  diff ns/iter    diff %  speedup 
 ::bench_all                    3                    5                                2    66.67%   x 0.60 
 ::bench_all_small              3                    5                                2    66.67%   x 0.60 
 ::bench_all_worst_case         1,308                41                          -1,267   -96.87%  x 31.90 
 ::bench_all_worst_case_small   19                   5                              -14   -73.68%   x 3.80 
 ::bench_any                    8                    12                               4    50.00%   x 0.67 
 ::bench_any_small              8                    12                               4    50.00%   x 0.67 
 ::bench_any_worst_case         447                  59                            -388   -86.80%   x 7.58 
 ::bench_any_worst_case_small   11                   6                               -5   -45.45%   x 1.83 
 ::bench_extend                 419                  3,793                        3,374   805.25%   x 0.11 
 ::bench_extend_small           48                   108                             60   125.00%   x 0.44 
 ::bench_from_slice             180                  3,237                        3,057  1698.33%   x 0.06 
 ::bench_from_slice_small       27                   79                              52   192.59%   x 0.34 
 ::bench_insert                 8,059                13,154                       5,095    63.22%   x 0.61 
 ::bench_insert_at_zero         16,898               38,729                      21,831   129.19%   x 0.44 
 ::bench_insert_at_zero_small   218                  190                            -28   -12.84%   x 1.15 
 ::bench_insert_small           275                  258                            -17    -6.18%   x 1.07 
 ::bench_iter_all               2,327                4,948                        2,621   112.63%   x 0.47 
 ::bench_macro_from_elem        602                  2,435                        1,833   304.49%   x 0.25 
 ::bench_macro_from_elem_small  28                   80                              52   185.71%   x 0.35 
 ::bench_push                   4,914                7,097                        2,183    44.42%   x 0.69 
 ::bench_push_small             181                  130                            -51   -28.18%   x 1.39 
 ::bench_pushpop                4,390                12,107                       7,717   175.79%   x 0.36 
 ::bench_remove                 5,261                10,823                       5,562   105.72%   x 0.49 
 ::bench_remove_at_zero         15,880               68,593                      52,713   331.95%   x 0.23 
 ::bench_remove_at_zero_small   101                  443                            342   338.61%   x 0.23 
 ::bench_remove_small           103                  207                            104   100.97%   x 0.50 

唯一肯定比Vec等价方法更快的是all和any，它们利用打包来一次处理多个元素。一些其他基准测试由于重新分配而看起来更快：当达到1、2、4、8等元素时，Vec将进行重新分配，但EnumVec将每32/n、64/n等重新分配一次，并且由于在基准测试中n=2且"_small"基准测试中插入的数量默认为16，因此Vec将重新分配4次，而EnumVec将重新分配1次。

要运行基准测试，请下载源代码并运行：

cargo +nightly bench --features smallvec > bench_log
cargo benchcmp normal_vec2 enum_vec32_2 bench_log

您需要安装cargo-benchcmp才能轻松比较基准测试。例如，要比较默认的32位EnumVec与8位EnumVec，在处理4位元素时运行：

cargo benchcmp enum_vec32_4 enum_vec8_4 bench bench_log

另请参阅

enum-set

enum-map

enum-kinds

bit-vec

smallbitvec

smallvec