Match integers against enum cases without a double match statement in Rust

Question

So in Rust, i am trying to iterate over a vector of u8, and match them against cases of an enum. To do that, I set up the following code.

use std::io::prelude::*;

enum Byte {
    A = 0,
    B = 1,
    C = 2,
    D = 3
}

fn main() {
    let mut buf = Vec::<u8>::new();
    write!(buf, "\x01\x03\x02\x00");
    match buf[1] {
        Byte::A => println!("got A"),
        Byte::B => println!("got B"),
        Byte::C => println!("got C"),
        Byte::D => println!("got D")
    }
}

Assume the println! statements could be any form of behavior, such as determining what type comes next in the byte vec, etc.

However, this results in

error[E0308]: mismatched types
  --> src/main.rs:16:9
   |
6  |     A = 0,
   |     ----- unit variant defined here
...
15 |     match buf[1] {
   |           ------ this expression has type `u8`
16 |         Byte::A => println!("got A"),
   |         ^^^^^^^ expected `u8`, found enum `Byte`

Then, if i try to cast the enum as a u8, with Byte::A as u8 , a syntax error occurs. I am aware it's possible to convert the u8 into a Byte, then match the converted Byte, but that requires two match statements, one to convert, then one to compare. I am looking for a way similar as in C/C++, to treat an enum case directly as an integer in Rust. Such that my original code can function.

If there is no way to do this, a way to match against named constants in a match statement would suffice.

Answer 1

In short: you want to convert¹ an u8 value to an Byte's variant.

The problem is that there are values of u8 that don't correspond to any variants of the Byte enum, for example, any u8 value higher than 3 doesn't have a variant in Byte backing it (i.e., any u8 value that matches 4..=255).

How should such a conversion behave if you (try to) convert 7u8 to a Byte's variant? Converting an u8 value to an enum's variant falls into the category of fallible conversions.

---

You could however implement the trait TryFrom<u8> for Byte for this kind of fallible conversion:

use std::convert::TryFrom;

impl TryFrom<u8> for Byte {
    type Error = ();

    fn try_from(val: u8) -> Result<Byte, ()> {
        match val {
            0 => Ok(Byte::A),
            1 => Ok(Byte::B),
            2 => Ok(Byte::C),
            3 => Ok(Byte::D),
            _ => Err(()),
        }
    }
}

Its associated function try_from() returns a Result<Byte, ()> instead of just Byte because the conversion may fail. Then, you just need extract the Byte (if any) from the returned Result:

match Byte::try_from(buf[1]).unwrap() {
    Byte::A => println!("got A"),
    Byte::B => println!("got B"),
    Byte::C => println!("got C"),
    Byte::D => println!("got D")
}

Or more concise, had Byte implemented Display, then you could just do away with the match above:

println!("got {}", Byte::try_from(buf[1]).unwrap());

---

¹ Note that performing a conversion in the other direction, i.e., from a Byte's variant to an u8 value, can be done trivially with the as operator, e.g., Byte::A as u8.