Testing Frameworks for Rust Cheat Sheet

Structs and enums are some of the most important components of the Rust programming language. Structs help in creating custom data types while enums define custom data types that can take on predefined variant values. In this comprehensive guide, we’ll take an in-depth look at how to use structs and enums in rust hacksheets.

1. Introduction to Structs

Structs are data types used to group data under a single record with each individual component called a field. A struct can be created by using the struct keyword before the struct name and enclosing its fields in curly braces. A struct can be implemented by creating its instance for storing data, and by implementing any specified properties.

Let’s take an example of a struct defined below:


struct Employee {

    name: String,

    age: i32



The above code block shows how the struct `Employee` is created and how it will form a blueprint for creating new instances of the struct. Once the struct is created, we can create instances of the struct by passing in values for its fields.

2. Defining Enums

Enums are custom data types that come with Rust’s standard library. You can use enums to create a new type that accepts a limited set of specified variant values. You can create an enum using the `enum` keyword, defining each variant of that enum inside curly braces and separated with a comma. Each variant can have an associated value or not.

Here’s an example of a Rust enum:


enum Color {






The code block above shows an example of a Rust enum with three variants. The variants don’t have any associated values. Also note that the variants are separated using commas.

3. Accessing Struct Fields and Enum Variants

Struct fields can be accessed by using a `dot` notation. Suppose we create an instance of the `Employee` struct named `emp1`; the name field can be accessed using `emp1.name` and the age field using `emp1.age` syntax.

Similarly, enum variants can also be accessed using a `dot` notation. Enum variants are accessed in a similar way as accessing fields of a struct. If we have created an instance of the `Color` enum named `red`, we can access its variants as `Color::Red`.

4. Rust Struct and Enum Composition

In Rust programming, we can compose structs and enums to build more complex data types, that can define a more powerful application logic. This is useful if you want to create more complex data structures, with struct fields representing other existing data types and composite enums where the variants themselves are other enums or structs.

Here’s an example of Rust Struct and Enum composition:


enum AgeGroup {





struct Person {

    name: String,

    age: AgeGroup,


fn main() {

    let john = Person {

        name: String::from(“John”),

        age: AgeGroup::Adult,

    println!(“{} is {} years old”, john.name, john.age);

The above code illustrates the composition of a `Person` struct that has two fields (`String` and `AgeGroup`) and the `AgeGroup` enum that defines possible age groups. Through this composition, we can create complex data types for our application.

Structs and enums are integral components of the Rust programming language that helps in creating custom data types. With a proper understanding of how to use and work with these features, developers can implement more complex data structures into their applications, leading to more functionality and better performance. This cheat sheet provides a quick and easy guide on how to use structs and enums in Rust programming.