Cast a number to a c-style enum

[jamorton]

It doesn't seem there is any way to do this:

enum foo { X, Y, Z }
let v : foo = 1 as foo;

( v == Y )

Useful for interfacing with c libraries, writing DCPU16 emulators (!!!), etc. Possible?

[marijnh]

I think unsafe::reinterpret_cast will do this, but there's no safe way yet (it'd require checking whether the int is a valid value for this enum).

[jamorton]

Yeah, I ended up doing:

enum basic_opcode { ... }
fn basic_opcode(v: uint) -> basic_opcode {
    unsafe { unsafe::reinterpret_cast(v) }
}

but it would be nice to have this as a feature of "as".

[catamorphism]

Could this be another use for overloaded integer literals? Or would that be a bridge too far?

[catamorphism]

In any case, marking as RFC since it is a language change.

[marijnh]

I don't think the actual use case involved a literal—if you already know, when writing the code, which value you want, you should probably write the variant's name anyway. Autoconverting literals to enum values seems like a bad idea.

[jamorton]

yeah, that was a bit of a contrived example. I actually wanted to convert some arbitrary uint data into an opcode enum for alting

[nikomatsakis]

This seems like a case for a macro. Something that will generate a function foo_from_uint(x: uint) -> option<foo>

[catamorphism]

@marijnh Quite right -- I wasn't thinking.

[brson]

Doing it with a macro would require that the macro also define the enum, so that it knows the names and values, which I think would make for an ugly enum declaration. I would maybe prefer to use an attribute.

This could also be done with reflection and I think it should: enum::from_int<T: CLikeEnum>(int) -> T. Could be implemented in a number of ways. You would have to introduce a new compiler generated trait for c-like enums, or have dynamic failures if T isn't one.

[graydon]

continues in #3868 , closing this as a dupe