Rust - Get Enum-With-Data Ordinal - rust

Question

I'm trying to serialize an enum. I plan to serialize by first encoding the ordinal of the enum, then the values very similarly to enum to bytes / bytes to enum?. The answer to that question involved using a crate, serde; I would like to avoid using this crate.
It seems that there are two types of enums: with data and without, that are incompatible in some ways. It appears possible to get ordinal values from enums without data using as u8 simply enough. A value comes back from as u8 on enum variants with data, but enum variants without data (when other enum variants have data) fail to compile:
https://play.rust-lang.org/?gist=2f6a4e8507a59d451546a69407bc0d77
#[repr(u8)]
enum Enumeration {
One=0,
}
#[repr(u8)]
enum Other {
Twelve(String)=4,
Thirteen=5,
}
fn main() {
println!("Got unsigned {:?}", Enumeration::One as u8);
println!("Got other {:?}", Other::Twelve as u8);
// Uncommenting the next line produces a compiler error
//println!("Got other {:?}", Other::Thirteen as u8);
}
(I get the impression that the values coming back from enum variants with data are not useful.)
How do I get the ordinal for enum variants with data?

Answer 1

TLDR; you're casting a function pointer to a u8, not what you want. Use serde or similar to achieve your goal if you want to.
So, running clippy on your code gives a very good indication of what's going on here:
warning: casting function pointer `Other::Twelve` to `u8`, which truncates the value
--> src/main.rs:13:32
|
13 | println!("Got other {:?}", Other::Twelve as u8);
| ^^^^^^^^^^^^^^^^^^^ help: try: `Other::Twelve as usize`
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#fn_to_numeric_cast_with_truncation
= note: `#[warn(clippy::fn_to_numeric_cast_with_truncation)]` on by default
warning: cast of an enum tuple constructor to an integer
--> src/main.rs:13:32
|
13 | println!("Got other {:?}", Other::Twelve as u8);
| ^^^^^^^^^^^^^^^^^^^
|
= help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_enum_constructor
= note: `#[warn(clippy::cast_enum_constructor)]` on by default
So, that's probably not what you want.
If we dig deeper into the nomicon, we can find this article:
If the enum has fields, the effect is similar to the effect of repr(C) in that there is a defined layout of the type. This makes it possible to pass the enum to C code, or access the type's raw representation and directly manipulate its tag and fields. See the RFC for details.
[...]
Adding an explicit repr(u*), repr(i*), or repr(C) to an enum with fields suppresses the null-pointer optimization, like:
enum MyOption<T> {
Some(T),
None,
}
#[repr(u8)]
enum MyReprOption<T> {
Some(T),
None,
}
assert_eq!(8, size_of::<MyOption<&u16>>());
assert_eq!(16, size_of::<MyReprOption<&u16>>());
If you want to read what you can do with that, follow the RFC: https://github.com/rust-lang/rfcs/blob/master/text/2195-really-tagged-unions.md#guide-level-explanation

Answer 2

Based on
Given that rustc guarantees that #[repr(u16)] enumerations start with their discriminant stored as a u16...
here: https://github.com/rust-lang/rfcs/pull/2363/files, the first byte of the enumeration value should be the underlying u8. So...
https://play.rust-lang.org/?gist=21e3ab42f76ccbc05b6b61560cbd29ec
#[repr(u8)]
enum MyOption {
Option(String),
NotOption,
}
fn get_ordinal(option: MyOption) -> u8 {
let ptr_to_option = (&option as *const MyOption) as *const u8;
unsafe {
*ptr_to_option
}
}
fn main() {
let option = MyOption::Option("Yolo".to_string());
let not_option = MyOption::NotOption;
println!("ordinal for Option is {}; NotOption is {}",
get_ordinal(option), get_ordinal(not_option));
}
output ordinal for Option is 0; NotOption is 1.