1 | initial version |
In Rust, compile-time errors can be used to limit the possible permutations of a struct by using the concept of enums with associated values. An enum is a way to define a type by enumerating its possible variants, and associated values allow you to attach data of different types to these variants.
For example, suppose you have a struct called Person
that can have a different set of attributes depending on whether that person is a student, employee or retiree. Instead of creating separate structs for each of these types, you can define an enum called PersonType
that represents the different types of people:
enum PersonType {
Student(String, u32),
Employee(String, u32),
Retiree(String),
}
In this enum, each variant contains different associated values depending on the type of person. Student
has a string for their name and an unsigned integer for their age, Employee
has a string for their name and an unsigned integer for their employee ID, and Retiree
only has a string for their name.
Now, when you create a Person
, you can specify their PersonType
and provide the associated values accordingly:
struct Person {
ptype: PersonType,
}
let student = Person {
ptype: PersonType::Student(String::from("John Doe"), 20),
};
let retiree = Person {
ptype: PersonType::Retiree(String::from("Jane Smith")),
};
If you try to create a Person
struct without providing the necessary associated values for each variant of PersonType
, Rust's type checker will give you a compile-time error. This limits the possible permutations of the Person
struct and ensures that only valid combinations of attributes can be created at compile-time.