Enum Sizes

Rust enums are packed tightly, taking constraints due to alignment into account:

  1. use std::mem::{align_of, size_of};
  3. macro_rules! dbg_size {
  4.     ($t:ty) => {
  5.         println!("{}: size {} bytes, align: {} bytes",
  6.                  stringify!($t), size_of::<$t>(), align_of::<$t>());
  7.     };
  8. }
  10. enum Foo {
  11.     A,
  12.     B,
  13. }
  15. #[repr(u32)]
  16. enum Bar {
  17.     A,  // 0
  18.     B = 10000,
  19.     C,  // 10001
  20. }
  22. fn main() {
  23.     dbg_size!(Foo);
  24.     dbg_size!(Bar);
  25.     dbg_size!(bool);
  26.     dbg_size!(Option<bool>);
  27.     dbg_size!(&i32);
  28.     dbg_size!(Option<&i32>);
  29. }

Key Points:

  • Internally Rust is using a field (discriminant) to keep track of the enum variant.
  • Bar enum demonstrates that there is a way to control the discriminant value and type. If repr is removed, the discriminant type takes 2 bytes, becuase 10001 fits 2 bytes.
  • As a niche optimization an enum discriminant is merged with the pointer so that Option<&Foo> is the same size as &Foo.
  • Option<bool> is another example of tight packing.
  • For some types, Rust guarantees that size_of::<T>() equals size_of::<Option<T>>().
  • Zero-sized types allow for efficient implementation of HashSet using HashMap with () as the value.

Example code if you want to show how the bitwise representation may look like in practice. It’s important to note that the compiler provides no guarantees regarding this representation, therefore this is totally unsafe.

  1. use std::mem::transmute;
  3. macro_rules! dbg_bits {
  4.     ($e:expr, $bit_type:ty) => {
  5.         println!("- {}: {:#x}", stringify!($e), transmute::<_, $bit_type>($e));
  6.     };
  7. }
  9. fn main() {
  10.     // TOTALLY UNSAFE. Rust provides no guarantees about the bitwise
  11.     // representation of types.
  12.     unsafe {
  13.         println!("Bitwise representation of bool");
  14.         dbg_bits!(false, u8);
  15.         dbg_bits!(true, u8);
  17.         println!("Bitwise representation of Option<bool>");
  18.         dbg_bits!(None::<bool>, u8);
  19.         dbg_bits!(Some(false), u8);
  20.         dbg_bits!(Some(true), u8);
  22.         println!("Bitwise representation of Option<Option<bool>>");
  23.         dbg_bits!(Some(Some(false)), u8);
  24.         dbg_bits!(Some(Some(true)), u8);
  25.         dbg_bits!(Some(None::<bool>), u8);
  26.         dbg_bits!(None::<Option<bool>>, u8);
  28.         println!("Bitwise representation of Option<&i32>");
  29.         dbg_bits!(None::<&i32>, usize);
  30.         dbg_bits!(Some(&0i32), usize);
  31.     }
  32. }

More complex example if you want to discuss what happens when we chain more than 256 Options together.

  1. #![recursion_limit = "1000"]
  3. use std::mem::transmute;
  5. macro_rules! dbg_bits {
  6.     ($e:expr, $bit_type:ty) => {
  7.         println!("- {}: {:#x}", stringify!($e), transmute::<_, $bit_type>($e));
  8.     };
  9. }
  11. // Macro to wrap a value in 2^n Some() where n is the number of "@" signs.
  12. // Increasing the recursion limit is required to evaluate this macro.
  13. macro_rules! many_options {
  14.     ($value:expr) => { Some($value) };
  15.     ($value:expr, @) => {
  16.         Some(Some($value))
  17.     };
  18.     ($value:expr, @ $($more:tt)+) => {
  19.         many_options!(many_options!($value, $($more)+), $($more)+)
  20.     };
  21. }
  23. fn main() {
  24.     // TOTALLY UNSAFE. Rust provides no guarantees about the bitwise
  25.     // representation of types.
  26.     unsafe {
  27.         assert_eq!(many_options!(false), Some(false));
  28.         assert_eq!(many_options!(false, @), Some(Some(false)));
  29.         assert_eq!(many_options!(false, @@), Some(Some(Some(Some(false)))));
  31.         println!("Bitwise representation of a chain of 128 Option's.");
  32.         dbg_bits!(many_options!(false, @@@@@@@), u8);
  33.         dbg_bits!(many_options!(true, @@@@@@@), u8);
  35.         println!("Bitwise representation of a chain of 256 Option's.");
  36.         dbg_bits!(many_options!(false, @@@@@@@@), u16);
  37.         dbg_bits!(many_options!(true, @@@@@@@@), u16);
  39.         println!("Bitwise representation of a chain of 257 Option's.");
  40.         dbg_bits!(many_options!(Some(false), @@@@@@@@), u16);
  41.         dbg_bits!(many_options!(Some(true), @@@@@@@@), u16);
  42.         dbg_bits!(many_options!(None::<bool>, @@@@@@@@), u16);
  43.     }
  44. }