# Discriminated type using const generics in Rust It's common in rust to express that the type can be one of other types or values using enums or dyn traits. In this article I want to explore another option that may be better for some use cases ## Enum example Lets consider type `Person` that has a `is_binary` property which is binary, either true or false. ```rust struct Person { is_binary: bool, name: String, age: u64, } ``` `is_binary` here is a property of a type, its data. So if I wanted to have a type that holds only binary or non binary people I will have to use runtime checks. ```rust struct NonBinaryPeople(Vec); impl NonBinaryPeople { pub fn include(&mut self, person: Person) -> bool { if !person.is_binary { self.0.push(person); true } else { false } } } ``` ## Const generics example ```rust struct Person { name: String, age: u64, } type NonBinaryPerson = Person; type BinaryPerson = Person; ``` The benefit of this is that we can have two distinct types with the same structure discriminated by const value. This is the same as defining two distinct types but with no duplication of code. ```rust struct NonBinaryPerson { name: String, age: u64, } struct BinaryPerson { name: String, age: u64, } ``` And a type that exclusively holds specific type of people can be expressed easily as ```rust struct NonBinaryPeople(Vec); // Vec> ``` I can also express a type that can be either: ```rust enum PersonByBinarity { NonBinary(NonBinaryPerson), // Person Binary(BinaryPerson) // Person } ``` ## Serde Using concrete types is beneficial when defining a business logic, which often uses parsing a type from an input, deserialising ```rust impl Deserialize for Person { fn deserialize(input: &str) -> Result, Error> { let (is_binary, name, age) = parse_person_from_str(input)?; if is_binary != IS_BINARY { Err(Error::BinarityMismatch { expected: IS_BINARY }) } else { Ok(Self { name, age }) } } } #[derive(Deserialize)] #[serde(untagged)] enum PersonByBinarity { NonBinary(NonBinaryPerson), // Person Binary(BinaryPerson) // Person } ``` This example is less efficient when deserializing `PersonByBinarity` in case first variant fails it will try to deserialize to a second variant which results in parsing `parse_person_from_str(input)?` twice. To avoid that we can try to implement deserilization for an enum and delegate it to `TryFrom` conversion for concrete types, as: ```rust impl Deserialize for PersonByBinarity { fn deserialize(input: &str) -> Result, Error> { let (is_binary, name, age) = parse_person_from_str(input)?; Ok(if is_binary { PersonByBinarity::Binary(BinaryPerson { name, age }) } else { PersonByBinarity::NonBinary(NonBinaryPerson { name, age }) }) } } impl TryFrom for Person { fn try_from(person_by_binarity: PersonByBinarity) -> Result { match (person_by_binarity, IS_BINARY) { (PersonByBinarity::Binary(person), true) => Ok(person), (PersonByBinarity::NonBinary(person), false) => Ok(person), _ => Err(Error::BinarityMismatch { expected: IS_BINARY }) } } } #[derive(Deserialize)] #[serde(try_from="PersonByBinarity")] struct Person { name: String, age: u8, } ``` ## Pros Allows stricter typing while allowing for more flexibility and less code ## Cons Can be used only when variants have the same structure