You can download the example project and code for this book by following the instructions in the Download the example code files section in the Preface of this book.

This chapter’s code files are included in the downloadable code bundle.

Enums can empower structs so that they can handle multiple types. This can also be translated for any type of function or data structure. However, this can lead to a lot of repetition. Take, for instance, a User struct. Users have a core set of values, such as a username and password; however, they could also have extra functionality based on roles. With users, we must check roles before firing certain processes based on the traits that the user has implemented.

Through the creation of a simple program that defines users and their roles, we can demonstrate how to wrap up structs with traits:

1. We define our users with the following code:

   struct AdminUser {
       username: String,
       password: String
   }
   struct User {
       username: String,
       password: String
   }
   

We can see in the preceding code that the User and AdminUser structs have the same fields. For this exercise, we just need two different structs to demonstrate the effect...

Metaprogramming can generally be described as a way in which a program can manipulate itself based on certain instructions.

Considering the strong typing Rust has, one of the simplest ways in which we can meta-program is by using generics. A classic example of demonstrating generics is through coordinates, as follows:

struct Coordinate <T> {
    x: T,
    y: T
}
fn main() {
    let one = Coordinate{x: 50, y: 50};
    let two = Coordinate{x: 500, y: 500};
    let three = Coordinate{x: 5.6, y: 5.6};
}

In the preceding snippet, the Coordinate struct is defined with a single generic parameter, T. This T is a placeholder that can represent any type. When we create an instance of Coordinate, Rust’s compiler replaces T with specific types. In our example:

• one uses T as i32
• three uses T as f62

This flexibility allows the Coordinate struct to handle different types of numbers without needing implementations for...

Throughout the book, we will be using a web framework to match HTTP requests to the right function to be handled. However, there are times when you want to accept a message over a TCP connection and match the handling function based on the message received. (It does not have to be via TCP; I have found this type of macro to be useful for module interfaces or receiving messages via a channel.) In this section, we will implement a simple macro that will reduce the amount of code we need to write when mapping a struct to a function.

We map our messages using macros by carrying out the following steps:

1. Defining our contracts and contract handler
2. Defining functions to handle contracts
3. Building a register contract macro
4. Using our macro in a program

We will start with step 1.

Defining our contracts and contract handler

To map messages, we initially must define the data contracts that we will be mapping to our...

In a Rust web program, we generally have a series of layers and APIs. These layers usually consist of a frontend, backend, and data access layer. With these layers, we can have multiple different frameworks and engines. Throughout the book, we will be building out our web application so we can swap these frameworks and engines out.

These frameworks should have minimal footprint on your code, with clear separation between the interfaces. With web frameworks, you still must run a server using the web framework. We can swap out different engines, frameworks, and crates by using traits with no reference to self.

To demonstrate how this works, we are going to add another endpoint and data contract that gets a user by name from the database. Our database could be any database. We do not want our code to commit to having a particular data storage engine to run; this would not be flexible. To make an interaction with a database flexible, we implement...

There are times when the state of a struct and certain processes are just not appropriate anymore. A nice, clear example would be a database transaction. While a database transaction is in progress, certain processes are appropriate, such as adding another operation to the transaction. You may also want to commit your transaction or roll it back. However, once we have committed our transaction, we cannot roll it back or add another operation to the transaction; we need another transaction for this. Considering this, I would want my compiler to check and ensure that I am not passing in a transaction into certain functions once the transaction is no longer in progress. The compiler will not only give me instant feedback, but it will also be safer, as it could be that only certain edge cases could cause a bug, increasing the chance of the bug slipping through tests. We can start by defining a state with our struct.

Defining the state of a struct...

In this chapter, we covered some useful Rust-specific patterns that will take our code to the next level. We can enable multiple permissions for a struct using multiple traits. We then scaled our ability to write Rust code with macros, where we mapped data contracts with functions to handle them. Finally, we revisited traits to configure functions and implemented the type state pattern to lock down our struct.

These approaches can help you solve problems in Rust in an elegant, secure, and scalable way. You can use these approaches to solve problems you generally come across outside of web programming, too. Throughout the book, we will be revisiting these approaches to solve problems in web programming. Hopefully, with these approaches, you can see that Rust is a safe, yet flexible and powerful language. Whenever I am feeling a little too sure of myself, I remind myself that some super smart people came up with the Rust programming language and traits. This always reminds...

1. How can we enable multiple permissions for a struct?
2. How can we ensure that two permissions are enabled for a struct that can be passed into a function?
3. Let us say I wanted a struct that had an ID field and nothing more. I wanted that ID field to be a string in some cases and an i32 in others. How could I achieve this?
4. I want to have a function that calls an I/O function in it, but I want the implementation of the I/O call to be flexible, enabling other developers to slot in different implementations. How can I do this?
5. Let us say I have a struct that passes through a process of steps, and I want to lock down my struct so it cannot be passed into functions outside of the current step. How can I do this?

1. We can declare a trait per permission. We can then implement multiple traits in a struct.
2. We can ensure that two traits are implemented for the struct being passed into the function with <T: TraitA + TraitB>.
3. We would exploit generics, where the generic parameter would map to the ID field; we could then create StructA<i32> and StructA<String>.
4. We can define a trait where the functions for the trait do not have a reference to self. This trait can then be passed to the function as a trait parameter with function_a<T: SomeTrait>(), so we can define the function struct with function_a<SomeStruct>().
5. We can implement the type state pattern.

Learn more on Discord

To join the Discord community for this book – where you can share feedback, ask questions to the author, and learn about new releases – follow this QR code: https://packt.link/EaKXL