Cantor is a general toolkit for working with types that have a small number of values (typically, but not exclusively enums). This crate defines the Finite trait and implements several efficient zero-allocation algorithms on top of it.

Applications

• Iterating over possible values
• Value compression
• Array-based maps
• Bitmap sets

Example

```rust // Define a "Finite" type

[derive(Finite, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Debug)]

enum MyType { A, B(bool), C(bool, bool) }

// Value iteration let mut numvalues = 0; for _ in MyType::iter() { numvalues += 1; } asserteq!(numvalues, 7);

// Value compression let value = MyType::B(false); asserteq!(sizeofval(&value), 3); let compressed = compress(value); asserteq!(sizeofval(&compressed), 1); assert_eq!(value, compressed.expand());

// Array map let mut map = ArrayMap::default(); map[MyType::B(true)] = 1; map[MyType::C(true, true)] = 2; asserteq!(map[MyType::A], 0); asserteq!(map[MyType::B(true)], 1); assert_eq!(map[MyType::C(true, true)], 2);

// Bitmap set let mut set = BitmapSet::none(); set.include(MyType::A); set.include(MyType::B(false)); set.include(MyType::C(true, false)); assert_eq!(set.size(), 3); assert!(set.contains(MyType::B(false))); assert!(!set.contains(MyType::C(false, true))); ```