enum SomeEnum: Int { case One, Two, Three } class SomeClass<E: RawRepresentable where E.RawValue == Int>{ func doSomething(e: E) { print(e.rawValue) } } class SomeEnumClass : SomeClass<SomeEnum> { } or directly class SomeOtherClass{ func doSomething<E: RawRepresentable where E.RawValue == Int>(e: E) { print(e.rawValue) } } UPDATE for swift3: enum SomeEnum: Int { case One, Two, … Read more
Use matches!, e.g.: matches!(my_struct.my_enum, Unknown) Alternatively, you can use PartialEq trait, for example, by #[derive]: #[derive(PartialEq)] enum MyEnum { … } Then your “ideal” variant will work as is. However, this requires that MyEnum‘s contents also implement PartialEq, which is not always possible/wanted.
It’s not possible to ensure the parameter is an enum, because enumerations in TS don’t inherit from a common ancestor or interface. TypeScript brings static analysis. Your code uses dynamic programming with Object.keys and e[dynamicKey]. For dynamic codes, the type any is convenient. Your code is buggy: length() doesn’t exists, e[Math.floor((Math.random() * length)+1)] returns a … Read more
Update as of 2022 There’s a new function std::mem::variant_count in rust nightly version. Example to use by rust docs. use std::mem; enum Void {} enum Foo { A(&’static str), B(i32), C(i32) } assert_eq!(mem::variant_count::<Void>(), 0); assert_eq!(mem::variant_count::<Foo>(), 3); assert_eq!(mem::variant_count::<Option<!>>(), 2); assert_eq!(mem::variant_count::<Result<!, !>>(), 2);
Why treat enums differently to other types? Keep them in the same namespace as they’re likely to be used – and assuming they’re going to be used by other classes, make them top-level types in their own files. The only type of type which I do commonly clump together is delegates – I sometimes have … Read more
Flutter is able to generate JSON serialization code. The tutorial you can find here. It references the package json_annotation. It contains also support for enum serialization. So all you need, is use this tool and annotate your enum values with @JsonValue. From the code docs: An annotation used to specify how a enum value is … Read more
First have a look at the free, official Rust book The Rust Programming Language, specifically the chapter on enums. match fn initialize(datastore: DatabaseType) { match datastore { DatabaseType::Memory => { // … } DatabaseType::RocksDB => { // … } } } if let fn initialize(datastore: DatabaseType) { if let DatabaseType::Memory = datastore { // … … Read more
Let’s discuss the difference between enums and sealed classes over various aspects with contrasting examples. This will help you choose one over the other depending on your use case. Properties Enum In enum classes, each enum value cannot have its own unique property. You are forced to have the same property for each enum value: … Read more
You can derive an implementation of std::format::Debug: #[derive(Debug)] enum Suit { Heart, Diamond, Spade, Club } fn main() { let s = Suit::Heart; println!(“{:?}”, s); } It is not possible to derive Display because Display is aimed at displaying to humans and the compiler cannot automatically decide what is an appropriate style for that case. … Read more
What I have seen is to introduce a new struct for each enum variant, and then methods on the enum to decompose it: struct Dog(i32); struct Cat(u8); enum Animal { Dog(Dog), Cat(Cat), } impl Animal { fn cat(self) -> Cat { if let Animal::Cat(c) = self { c } else { panic!(“Not a cat”) } … Read more