If you're reading this, you may already be interested in learning Rust. However, if not, I understand you. I am also very skeptical about learning new technologies. But I am here to try to change your mind.

Here are some reasons to consider it:

1. Performance: The main reason Rust has become popular is that it is designed to be fast and efficient. This makes it an excellent choice for performance-critical applications. It can often match (or exceed) the performance of C and C++ while providing additional safety features. I believe it strikes a good balance between performance and safety.

2. Memory Safety: Rust is designed to be memory-safe. This helps avoid common programming errors like null pointer dereferences and buffer overflows. Rust achieves this through its ownership system, which enforces strict rules about how memory is accessed and shared. This is a valuable feature for developers who want to write safe and reliable code without worrying about low-level memory management!

3. Concurrency: Writing concurrent code is usually a nightmare; however, Rust simplifies creating concurrent programs. Its strong type system and ownership model help prevent data races.

4. Helpful (and annoying) Compiler & Tooling: Rust's compiler is well-known for being very helpful. It does not just report random errors (I see you Java), it often explains them thoroughly and suggests how to fix your code. I like to compare it to that old annoying grandma who wants the best for you. You know she's annoying, but she is right. Plus, Rust comes with a fantastic tool called 'Cargo' that makes it easy to manage your project's dependencies and build your programs, simplifying the development process.

Are you not convinced yet? Well, I kept the best shot as the last one:

Rust has been voted the most-admired programming language in the latest Stack Overflow survey. Do you want to base your future learning choices on what you read on Twitter, what a tech influencer says, or real data?

If you are interested in learning Rust, I just published a 3.5-hour video on YouTube; it's free and might help you understand the core concepts of the language. Good luck!

Find me here: https://francescociulla.com

Unlike traditional loops, Rust’s iterators are lazy—meaning they don't perform any actions until explicitly instructed to. This laziness makes iterators efficient because they only evaluate elements when needed, often combining multiple transformations into a single pass over the data.

In this lesson, we’ll dive into the core of Rust's iterator system and explore how to use methods like .map(), .filter(), and .fold() (similar to reduce) to create expressive, functional code.

If you prefer a video version:

All the code is available on Github (link in the video description)

You can find me here: https://francescociulla.com

Introduction to Iterators

The iterator pattern allows you to perform tasks on a sequence of items in turn. An iterator handles the logic of moving from one item to the next and determines when the sequence has finished, freeing you from implementing that logic manually. In Rust, iterators are lazy, meaning they don’t do any work until you call methods that consume the iterator.

For Example:

fn main() {
    let v1 = vec![1, 2, 3];
    let v1_iter = v1.iter();

    for val in v1_iter {
        println!("Got: {}", val);
    }
}

In this code, we create an iterator over a vector using the .iter() method. We then use a for loop to iterate over each value in the iterator and print it. The iterator pattern allows us to abstract away the logic of iterating through the vector, making our code more readable and expressive.

The Iterator Trait and the next Method

The Iterator trait is the core trait for iterators in Rust. It defines the behavior of the .next() method, which returns an Option containing the next value in the sequence. When the iterator is finished, .next() returns None.

All iterators in Rust implement the Iterator trait, which defines a single required method: next.

pub trait Iterator {
    type Item;

    fn next(&mut self) -> Option<Self::Item>;
}

• type Item: This is an associated type that specifies the type of items the iterator will yield.

• next(): Advances the iterator and returns the next item, or None when the iterator is exhausted.

For Example:

fn main() {
    let v1 = vec![1, 2, 3];
    let mut v1_iter = v1.iter();

    assert_eq!(v1_iter.next(), Some(&1));
    assert_eq!(v1_iter.next(), Some(&2));
    assert_eq!(v1_iter.next(), Some(&3));
    assert_eq!(v1_iter.next(), None);
}

In this code, we create an iterator over a vector and call the .next() method to get the next value in the sequence. We use the assert_eq! macro to check that the values returned by .next() are correct.

Core Types of Iterators

Rust provides three main types of iterators: consuming adaptors, iterator adaptors, and iterators themselves. Consuming adaptors take ownership of the iterator and consume it, producing a single value. Iterator adaptors take an iterator and return a new iterator with a different behavior. Iterators themselves are the base trait for all iterators and define the behavior of the .next() method.

The three main types of iterators are:

• iter(): This method creates an iterator that borrows each element of the collection.

• into_iter(): This method creates an iterator that takes ownership of each element of the collection.

• iter_mut(): This method creates an iterator that mutably borrows each element of the collection.

Let's see the purpose, ownership and use case of each iterator type:

iter()

• Purpose: This method creates an iterator that borrows each element of the collection.

• Ownership: The original collection remains intact after calling iter().

• Use Case: Use iter() when you want to iterate over the collection without taking ownership of it.

For Example:

let numbers = vec![1, 2, 3];

for num in numbers.iter() {
    println!("{}", num); // Outputs each number
}

println!("after iter: {:?}", numbers); // Outputs: [1, 2, 3]

iter_mut()

• Purpose: This method creates an iterator that mutably borrows each element of the collection.

• Ownership: The original collection remains intact after calling iter_mut().

• Use Case: Use iter_mut() when you want to iterate over the collection and modify its elements.

For Example:

let mut numbers = vec![1, 2, 3];
for num in numbers.iter_mut() {
    *num += 1; // Mutates each element by adding 1
    println!("{}", num);
}

println!("{:?}", numbers); // Outputs: [2, 3, 4]

into_iter()

• Purpose: This method creates an iterator that takes ownership of each element of the collection.

• Ownership: The original collection is consumed after calling into_iter().

• Use Case: Use into_iter() when you want to move each element out of the collection.

For Example:

let numbers = vec![1, 2, 3];

for num in numbers.into_iter() {
    println!("{}", num); // Outputs each number
}

// println!("{:?}", numbers); // Error: `numbers` is no longer accessible

Summary table of iterator types:

Here is a summary table of the three main types of iterators in Rust:

Methods to Modify or Consume Iterators: .map(), .filter(), and .fold()

Rust provides a variety of methods to modify or consume iterators, allowing you to transform, filter, and aggregate elements efficiently. These methods are called iterator adaptors and are chained together to create expressive, functional code.

Some common iterator adaptors include:

• .map(): Transforms each element in the iterator.
• .filter(): Filters elements based on a predicate function.
• .fold(): Aggregates elements into a single value.

Let's explore each of these methods in more detail:

.map() - Transforming Elements

The .map() method transforms each element in the iterator by applying a closure to it. The closure takes an element as input and returns a new value, which is then yielded by the iterator.

let numbers = [1, 2, 3, 4, 5];
let squares: Vec<_> = numbers.iter().map(|&x| x * x).collect();
println!("Map - Squares: {:?}", squares); // Outputs: [1, 4, 9, 16, 25]

In this code, we use the .map() method to square each element in the numbers array. The closure |&x| x * x squares the input x, and the resulting values are collected into a new vector.

.filter() - Filtering Elements

The .filter() method filters elements in the iterator based on a predicate function. The closure takes an element as input and returns a boolean value indicating whether the element should be included in the output.

let numbers = [1, 2, 3, 4, 5];

let evens: Vec<_> = numbers.iter().filter(|&x| x % 2 == 0).collect();

println!("Filter - Evens: {:?}", evens); // Outputs: [2, 4]

In this code, we use the .filter() method to select only the even numbers from the numbers array. The closure |&x| x % 2 == 0 checks if the input x is even, and the resulting values are collected into a new vector.

.fold() - Aggregating Elements

The .fold() method aggregates elements in the iterator into a single value. It takes an initial value and a closure that combines the current accumulator value with each element in the iterator. It's similar to the reduce function in other languages.

let numbers = [1, 2, 3, 4, 5];

let sum = numbers.iter().fold(0, |acc, &x| acc + x);

println!("Fold - Sum: {}", sum); // Outputs: 15

In this code, we use the .fold() method to calculate the sum of all elements in the numbers array. The initial value 0 is passed as the first argument, and the closure |acc, &x| acc + x adds each element x to the accumulator acc.

Summary

Rust’s iterators provide a flexible way to process data efficiently by allowing transformations, filtering, and aggregations over collections. Key takeaways:

Laziness: Iterators do nothing until explicitly consumed.

Ownership and Mutability Control: Choose between iter(), iter_mut(), and into_iter() for precise control over element handling.

Functional Methods: Methods like .map(), .filter(), and .fold() allow expressive, functional transformations.

Iterators give fine-grained control over data ownership and mutability during iteration, making Rust efficient and powerful in processing collections.

If you prefer a video version:

All the code is available on Github (link in the video description)

You can find me here: https://francescociulla.com

What Are Closures?

Closures are blocks of code that can be assigned to variables, passed to other functions, or returned from functions. They are similar to regular functions, but closures have one key advantage: they can capture variables from the scope in which they are defined. This allows them to be more flexible and powerful than traditional functions.

If you prefer a video version:

All the code is available on Github (link in the video description)

Key Characteristics of Closures in Rust:

• Anonymous Functions: Closures are unnamed functions that can be stored in variables or passed to other functions.
• Capturing Environment: Closures can capture values from their surrounding scope by borrowing, mutably borrowing, or taking ownership of them.
• Type Inference: Rust infers the types of parameters and return types in most closures, so explicit type annotations are often unnecessary.
• Flexibility: Closures can be stored as function pointers or as traits like Fn, FnMut, and FnOnce, depending on how they capture variables.

Syntax

Closures in Rust are defined using the |args| body syntax. The args represent the arguments the closure takes, and the body is the code that the closure executes. Here's an example of a closure that takes no arguments and returns a string:

let closure = || "Hello, world!";

Here's a more complex example with two arguments:

let closure = |a: i32, b: i32| -> i32 {
    a + b
};

Rust can infer the types of a and b in most cases, so you can simplify this to:

let closure = |a, b| a + b;

Example: Simple Closure

Here's an example of a closure that adds two numbers:

fn main() {
    let add = |a, b| a + b;
    let result = add(3, 5);
    println!("The sum is: {}", result);
}

In this example, the closure add takes two arguments, a and b, and returns their sum. The |a, b| syntax defines the closure's arguments, and the body is simply a + b.

Capturing Variables with Closures

Closures can capture variables from their environment in three different ways: by borrowing (immutably or mutably) or by taking ownership of the variable (moving it). This behavior is determined by how the closure is used.

1. Borrowing (Immutable Capture)

In this case, the closure borrows a variable immutably, meaning it can read the variable but not modify it.

fn main() {
    let x = 5;
    let print_x = || {
        println!("The value of x is: {}", x);
    };
    print_x();
}

In this example, the closure closure borrows the variable x immutably, allowing it to read x but not modify it.

2. Mutably Borrowing (Mutable Capture)

The closure borrows a variable mutably, allowing it to both read and modify the variable.

Example:

fn main() {
    let mut y = 100;
    let mut print_y = || {
        y += 1;
        println!("The value of x is: {}", y);
    };
    print_y();
}

In this example, the closure mutably borrows the variable x, allowing it to modify the value of x.

3. Moving (Ownership Capture)

The closure can take ownership of a variable, meaning the variable is moved into the closure and can no longer be used outside of it.

Example:

fn main() {
    let x = String::from("Hello");
    let consume_x = move || {  // `x` is moved into the closure
        println!("Consumed: {}", x);
        drop(x);  // Consumes `x` by dropping it
    };
    consume_x();  // `x` is moved and consumed
    // consume_x();  // Error: closure can only be called once, `x` was consumed
}

In this example, the closure consume_x takes ownership of the variable x by using the move keyword. After being moved into the closure, x cannot be used outside the closure.

Closure Traits: Fn, FnMut, and FnOnce

Rust provides three traits that represent how closures capture variables from their environment:

• Fn: The closure captures variables immutably, allowing it to be called multiple times.
• FnMut: The closure captures variables mutably, meaning it can modify them. It can also be called multiple times.
• FnOnce: The closure takes ownership of captured variables and can only be called once because it consumes the environment.

Rust automatically chooses the most appropriate trait depending on how the closure is used.

Closures as Function Parameters

Closures can be passed as arguments to functions, enabling custom behavior within those functions.

This is often used in scenarios where you want to pass logic (in the form of a closure) to a function that can then execute it.

Example:

// Fn trait bound: takes an i32 and returns an i32
fn apply<F>(f: F) where F: Fn(i32) -> i32, {
    let result = f(10);  // Call the closure with 10 as an argument
    println!("Result: {}", result);
}

fn main() {
    let double = |x| x * 2;
    apply(double);  // Pass the closure to a function
}

In this example, the apply function accepts a closure f as an argument.

The closure must implement the Fn(i32) -> i32 trait, which means it takes an i32 as input and returns an i32.

The double closure doubles its argument and is passed to apply, which calls it with the value 10.

Differences Between Functions and Closures

While closures and functions share similarities, they have important differences:

1. Capturing Variables: Closures can capture variables from the surrounding scope, whereas functions cannot.

2. Syntax: Closures are defined using the |args| body syntax, while functions use the fn keyword.

3. Flexibility: Closures can be stored in variables, passed around as arguments, and returned from other functions, giving them more flexibility than traditional functions.

4. Memory Usage: Closures that capture variables from their environment may use more memory than regular functions because they store those captured values.

Conclusion

Closures in Rust are a powerful feature that allows you to capture variables from their environment and create flexible, reusable code blocks. By understanding the different ways closures capture variables (borrowing, mutably borrowing, or moving), you can make the most of Rust's closures in scenarios where traditional functions might fall short.

Closures are often used in functional programming, callback functions, and iterator chains, making them a vital part of mastering Rust.

If you prefer a video version:

All the code is available on Github (link in the video description)

All the code is available on Github (link in the video description)

If you have any comments, just drop them below.

You can also find me here: https://francescociulla.com

They are used to store configuration settings and other information required by the system and other applications.

In this article, we'll explore how to work with environment variables in Rust using the standard library and the dotenv crate.

What Are Environment Variables?

Environment variables provide a flexible way to configure your applications without hardcoding values directly in your source code.

This makes it easier to manage different configurations for different environments, (development, testing, and production) and to keep sensitive information, such as API keys, secure.

Let's see 3 different examples of how we can use the environment variables in Rust.

1. Using the std::env module
2. Using the command line (Windows and Linux)
3. Using the dotenv crate

If you prefer a video version:

All the code is available on Github (link in the video description)

1. Environemnt Variables using the std::env module

Rust provides the std::env module to interact with environment variables. This module can read, set, and remove environment variables.

Importing the env Module

First, import the env module from the standard library:

use std::env;

You can test this by typing cargo run in the terminal.

Your output should be something like this:

Setting an Environment Variable

You can set an environment variable using the set_var function. Here's an example where we set a variable AAA with the value 123:

fn main() {
    let key = "AAA";
    std::env::set_var(key, "123"); // Sets AAA to 123
}

Removing an Environment Variable

To remove an environment variable, use the remove_var function:

fn main() {
    let key = "AAA";
    env::remove_var(key); // Removes the variable AAA
}

Checking If an Environment Variable Exists

To check if an environment variable exists, use the env::var function, which returns a Result. You can handle this with a match statement:

fn main() {
    let key = "AAA";

    match env::var(key) {
        Ok(val) => println!("{}: {:?}", key, val),
        Err(e) => println!("Error {}: {}", key, e),
    }
}

2. Environment Variables from the Command Line

You can pass environment variables directly from the command line when running your Rust program:

Here's how you can read the CLI_ARG environment variable:

fn main() {
    let cli_arg = env::var("CLI_ARG");

    match cli_arg {
        Ok(val) => println!("CLI_ARG: {:?}", val),
        Err(e) => println!("Error CLI_ARG: {}", e),
    }
}

To read them from the command line, you can use the following commands:

On Linux/macOS:

CLI_ARG=TEST cargo run

On Windows(powershell):

$env:CLI_ARG="TEST"; cargo run

3. Environment Variables with the dotenv Crate

In addition to the standard library, you can use the dotenv crate to load environment variables from a .env file. This is particularly useful in development environments.

First, add dotenv to your Cargo.toml file:

[dependencies]
dotenv = "0.15.0"

And create a .env file in the root of your project with the following content:

API_KEY=1234567890

Loading Environment Variables from a .env File

After adding dotenv, you can use it to load variables from a .env file:

use dotenv::dotenv;
use std::env;

fn main() {
    dotenv().ok(); // Reads the .env file

    let api_key = env::var("API_KEY");

    match api_key {
        Ok(val) => println!("API_KEY: {:?}", val),
        Err(e) => println!("Error API_KEY: {}", e),
    }

    //Simulate the execution of the rest of the program
    println!("...program continues...");
}

And you if you run the program, you should see the output:

In the example above, the dotenv().ok(); line loads the variables from a .env file located in the root of your project. The program then attempts to read the API_KEY variable and prints its value or an error if it is not set.

Conclusion

These are just three basic examples of working with environment variables in Rust.

I hope everything is clear and you can use them in your projects. If you have any questions, feel free to ask in the comments below.

If you prefer a video version: If you prefer a video version:

All the code is available on Github (link in the video description)

You can find me here: Francesco

Video Version

Rust was recently added to the Linux kernel, the first new language in nearly 30 years, endorsed by Linus Torvalds himself. It’s gaining traction for its focus on safety and reliability.

DARPA is backing Rust, aiming to convert millions of lines of C code to eliminate common security vulnerabilities.

Google reports that developers using Rust are twice as productive compared to C++. It's been crucial in reducing memory usage and defects in projects like Android.

Microsoft and Google have each invested $1 million in Rust's growth, showing confidence in its future.

Rust has been voted the most admired programming language by developers for many years in a row, even surpassing Kotlin in popularity and closing in on GO.

If you're considering a language that’s fast, safe, and gaining wide trust, Rust is worth a look.

Sources: https://www.zdnet.com/article/rust-in-linux-where-we-are-and-where-were-going-next/ https://www.darkreading.com/application-security/darpa-aims-to-ditch-c-code-move-to-rust https://survey.stackoverflow.co/2024/technology/ https://techinformed.com/world-in-disruption-trust-in-rust/ https://thenewstack.io/microsofts-1m-vote-of-confidence-in-rusts-future/ https://www.theregister.com/2024/02/05/google_rust_donation/

Video Version

For the Frontend:

• Rust - Core Programming Language
• Web Assembly - For running Rust in the browser
• Yew - Rust Framework for building client web apps
• Trunk - For serving the frontend app
• Tailwind CSS - For styling the frontend

For the Backend:

• Rust - Core Programming Language
• Rocket - Rust Framework for building web servers

For the Database:

• Postgres - Relational Database
• Docker - Dockerfile and Docker Compose for running Postgres

Wow, so many technologies! But we'll keep the example as basic as possible to help you understand the core concepts. Let's get started!

We will proceed with a bottom-up approach, starting with the database, then the backend, and finally the frontend.

If you prefer a video tutorial, you can watch it here.

All the code is available on GitHub (link in video description)

Architecture

Before we start, here is a simple architecture diagram of the application we are going to build:

The front end will be built using Yew, a new Rust framework for building client web apps. Yew is inspired by Elm and React and is designed to be simple and easy to use. We will use Trunk to serve the frontend and Tailwind CSS for styling. All this will be compiled to Web Assembly and run in the browser.

The Backend will be built using Rocket, a web framework for Rust. Rocket is designed to maximize the Developer Experience. We will use Rocket to build a simple REST API that will interact with the database.

The Database will be Postgres, a relational database. We will use Docker to run Postgres in a container, and we will use no ORM to keep things simple. We will interact with the database using SQL queries written directly in the Rocket handlers.

Prerequisites

Before we start, make sure you have the following installed on your machine:

• Rust
• Docker

That's it! If you have never used WASM or Trunk, no worries; I will show you the commands you need to run.

Preparation.

We will have a folder that will contain the following subfolders:

• backend
• frontend

So, let's create a new folder, navigate it, and open it in any IDE you want.

I will use Visual Studio Code.

mkdir rustfs
cd rustfs
code .

From the root folder, initialize a git repository.

git init

And create a compose.yml file (this will be used to run the Postgres database)

And you should have something like this:

We are now ready to build our application. In the next section, we will set up the database.

Setting up the Database

We will use Docker to run a Postgres database in a container. This will make it easy to run the database locally without installing Postgres on your machine.

Open the compose.yml file and add the following:

services:
  db:
    container_name: db
    image: postgres:12
    ports:
      - "5432:5432"
    environment:
      POSTGRES_USER: postgres
      POSTGRES_PASSWORD: postgres
      POSTGRES_DB: postgres
    volumes:
      - pgdata:/var/lib/postgresql/data

volumes:
  pgdata: {}

• db is the name of the service
• container_name is the name of the container, we will use db
• image is the Postgres image (we will use Postgres 12)
• ports is the port mapping (5432:5432)
• environment is the environment variables for the Postgres instance
• volumes is the volume mapping for the Postgres data

We also define a volume pgdata that will be used to store the Postgres data.

Now, run the following command to start the Postgres database:

docker compose up

You should see the Postgres logs in the terminal. If you see database system is ready to accept connections, the database is probably running successfully.

To make another test, you can go on the terminal and type:

docker ps -a

And you should see the database running:

You can also step into the database container by running:

docker exec -it db psql -U postgres

You can check the current databases by running:

\dt

And you should see the following output (Did not find any relations):

This is because we have not created any tables yet. We will do that in the next section.

Setting up the Backend

We will use Rocket to build the backend.

Rocket is a web framework for Rust that is designed to maximize the Developer Experience. We will use Rocket to build a simple REST API that will interact with the database.

Create a new Rust project called backend, without initializing a git repository:

cargo new backend --vcs none

Your project structure should look like this:

Open the Cargo.toml file and add the following dependencies:

rocket = { version = "0.5", features = ["json"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
tokio = { version = "1", features = ["full"] }
tokio-postgres = "0.7.11"
rocket_cors = { version = "0.6.0", default-features = false }

• rocket is the Rocket web framework we will use to build the backend
• serde is a serialization/deserialization library
• serde_json is a JSON serialization/deserialization library
• tokio is an asynchronous runtime for Rust
• tokio-postgres is a Postgres client for Tokio
• rocket_cors is a CORS library for Rocket

Now, open the /backend/main.rs file and replace the contents with the following (explanation below):

#[macro_use]
extern crate rocket;

use rocket::serde::{ Deserialize, Serialize, json::Json };
use rocket::{ State, response::status::Custom, http::Status };
use tokio_postgres::{ Client, NoTls };
use rocket_cors::{ CorsOptions, AllowedOrigins };

#[derive(Serialize, Deserialize, Clone)]
struct User {
    id: Option<i32>,
    name: String,
    email: String,
}

#[post("/api/users", data = "<user>")]
async fn add_user(
    conn: &State<Client>,
    user: Json<User>
) -> Result<Json<Vec<User>>, Custom<String>> {
    execute_query(
        conn,
        "INSERT INTO users (name, email) VALUES ($1, $2)",
        &[&user.name, &user.email]
    ).await?;
    get_users(conn).await
}

#[get("/api/users")]
async fn get_users(conn: &State<Client>) -> Result<Json<Vec<User>>, Custom<String>> {
    get_users_from_db(conn).await.map(Json)
}

async fn get_users_from_db(client: &Client) -> Result<Vec<User>, Custom<String>> {
    let users = client
        .query("SELECT id, name, email FROM users", &[]).await
        .map_err(|e| Custom(Status::InternalServerError, e.to_string()))?
        .iter()
        .map(|row| User { id: Some(row.get(0)), name: row.get(1), email: row.get(2) })
        .collect::<Vec<User>>();

    Ok(users)
}

#[put("/api/users/<id>", data = "<user>")]
async fn update_user(
    conn: &State<Client>,
    id: i32,
    user: Json<User>
) -> Result<Json<Vec<User>>, Custom<String>> {
    execute_query(
        conn,
        "UPDATE users SET name = $1, email = $2 WHERE id = $3",
        &[&user.name, &user.email, &id]
    ).await?;
    get_users(conn).await
}

#[delete("/api/users/<id>")]
async fn delete_user(conn: &State<Client>, id: i32) -> Result<Status, Custom<String>> {
    execute_query(conn, "DELETE FROM users WHERE id = $1", &[&id]).await?;
    Ok(Status::NoContent)
}

async fn execute_query(
    client: &Client,
    query: &str,
    params: &[&(dyn tokio_postgres::types::ToSql + Sync)]
) -> Result<u64, Custom<String>> {
    client
        .execute(query, params).await
        .map_err(|e| Custom(Status::InternalServerError, e.to_string()))
}

#[launch]
async fn rocket() -> _ {
    let (client, connection) = tokio_postgres
        ::connect("host=localhost user=postgres password=postgres dbname=postgres", NoTls).await
        .expect("Failed to connect to Postgres");

    tokio::spawn(async move {
        if let Err(e) = connection.await {
            eprintln!("Failed to connect to Postgres: {}", e);
        }
    });

    //Create the table if it doesn't exist
    client
        .execute(
            "CREATE TABLE IF NOT EXISTS users (
                id SERIAL PRIMARY KEY,
                name TEXT NOT NULL,
                email TEXT NOT NULL
            )",
            &[]
        ).await
        .expect("Failed to create table");

    let cors = CorsOptions::default()
        .allowed_origins(AllowedOrigins::all())
        .to_cors()
        .expect("Error while building CORS");

    rocket
        ::build()
        .manage(client)
        .mount("/", routes![add_user, get_users, update_user, delete_user])
        .attach(cors)
}

In this part of the video, I explain the code above.

Explanation

• We make all the imports at the top of the file. We also definte a macro_use attribute to import the rocket macro.
• We define a User struct that will represent the user data. This struct will be serialized/deserialized to/from JSON (Note: The id is an Option because we don't want to provide an id when creating a new user, it will be assigned by the database).
• We define the add_user route that will insert a new user into the database. We use the execute_query function to execute the SQL query. We then call the get_users function to return all the users.
• We define the get_users route that will return all the users from the database.
• We define the update_user route that will update a user in the database. We use the execute_query function to execute the SQL query. We then call the get_users function to return all the users.
• We define the delete_user route that will delete a user from the database. We use the execute_query function to execute the SQL query.
• We define the execute_query function that will execute a SQL query on the database.
• We define the rocket function that will create the Rocket instance. We connect to the Postgres database and create the users table if it doesn't exist, using a SQL query. We then create the CORS options and attach them to the Rocket instance. Even if we are running the frontend and back end on the same machine, we need to enable CORS to allow the frontend to make requests to the backend.

We can now run the backend by running:

cargo run

And we should see the following output:

You can visit the following URL: http://127.0.0.1:8000/api/users and you should see an empty array []:

Testing the APIs with Postman

You can test the APIs using Postman.

You can get the list of the users by sending a GET request to http://127.0.0.1:8000/api/users:

You can create a new user by sending a POST request to http://127.0.0.1:8000/api/users with the following JSON body:

{
    "name": "AAA",
    "email": "aaa@mail.com"
}

You can create 2 more users:

{
    "name": "BBB",
    "email": "
}

{
    "name": "CCC",
    "email": "
}

You should see the following output:

To Update a user, you can send a PUT request to http://127.0.0.1:8000/api/users/2 with the following JSON body:

{
    "name": "Francesco",
    "email": "francesco@mail"
}

And we should see the updated user:

To delete a user, you can send a DELETE request to http://127.0.0.1:8000/api/users/1:

And we should get a 204 response (Resource was deleted):

And if we try to get all the users, we should see the following output:

We can see that this is consistent if we use the browser to check the users at the address http://127.0.0.1:8000/api/users:

We can also test it directly in the Postgres database by running: (If you closed the terminal, you can step into the container by running docker exec -it db psql -U postgres)

\dt
select * from users;

Congratulations! You have successfully set up the backend. In the next section, we will set up the frontend.

Setting up the Frontend

Now, let's work on the front end. We will use Yew to build it. Yew is a Rust framework for building client web apps. We will use Trunk to build and bundle the front end and Tailwind CSS for styling. All this will be compiled to Web Assembly and run in the browser.

IMPORTANT! If you never used Wasm for Rust on your machine, you can install it by running:

rustup target add wasm32-unknown-unknown

IMPORTANT! You must also have trunk installed on your machine. You can install it by running:

cargo install trunk

You can verify that trunk is installed by running:

trunk --version

Now you can create a new Rust project called frontend (be sure to be in the rustfs folder):

cargo new frontend --vcs none

Now open the frontend/Cargo.toml file and add the following dependencies:

[package]
name = "frontend"
version = "0.1.0"
edition = "2021"

[dependencies]
yew = { version = "0.21", features = ["csr"] }
wasm-bindgen = "0.2"
web-sys = { version = "0.3", features = ["console"] }
gloo = "0.6"
wasm-bindgen-futures = "0.4"  
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

• yew is the Yew framework (Rust framework for building client web apps)
• wasm-bindgen is a library that facilitates communication between WebAssembly and JavaScript
• web-sys is a library that provides bindings to Web APIs
• gloo is a library that provides utilities for WebAssembly
• wasm-bindgen-futures is a library that provides utilities for working with futures in WebAssembly
• serde is a serialization/deserialization library
• serde_json is a JSON serialization/deserialization library

Now create a new file called index.html in the frontend folder and add the following:

<!DOCTYPE html>
<html>
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <title>Yew + Tailwind</title>
    <script src="https://cdn.tailwindcss.com"></script>
  </head>
  <body>
    <div id="app"></div>
    <script type="module">
      import init from './pkg/frontend.js';
      init();
    </script>
  </body>
</html>

• We import the Tailwind CSS CDN in the head of the HTML file
• We create a div with the id app where the Yew app will be mounted
• We import the frontend.js file that will be generated by Trunk

Now open the frontend/src/main.rs file and replace the contents with the following:

use yew::prelude::*;
use serde::{ Deserialize, Serialize };
use gloo::net::http::Request;
use wasm_bindgen_futures::spawn_local;

#[derive(Serialize, Deserialize, Clone, Debug)]
struct User {
    id: i32,
    name: String,
    email: String,
}

fn main() {
    yew::Renderer::<App>::new().render();
}

• We import the necessary dependencies
• We define a User struct that will represent the user data
• We define the main function that will render the Yew app

But this is not enough. We need to add the App component. We can use an external file, but here for simplicity, we will add it directly in the main.rs file.

Below is the code you should add to the main.rs file.

This code defines a Yew function component named App that manages user data and interactions within a web application. The use_state hooks initialize states for managing user information (user_state), messages (message), and the list of users (users).

The component defines several callbacks for interacting with a backend API:

• get_users: Fetches the list of users from the backend API and updates the users state. If the request fails, it sets an error message.
• create_user: Sends a POST request to create a new user using the data from user_state. On success, it triggers the get_users callback to refresh the user list.
• update_user: Updates an existing user's information by sending a PUT request to the backend. If successful, it refreshes the user list and resets the user_state.
• delete_user: Deletes a user based on their ID by sending a DELETE request to the backend. On success, it refreshes the user list.
• edit_user: Prepares a user's information for editing by updating the user_state with the selected user's details.

These callbacks utilize asynchronous operations (spawn_local) to handle network requests without blocking the UI thread, ensuring a responsive user experience.

...
#[function_component(App)]
fn app() -> Html {
    let user_state = use_state(|| ("".to_string(), "".to_string(), None as Option<i32>));
    let message = use_state(|| "".to_string());
    let users = use_state(Vec::new);

    let get_users = {
        let users = users.clone();
        let message = message.clone();
        Callback::from(move |_| {
            let users = users.clone();
            let message = message.clone();
            spawn_local(async move {
                match Request::get("http://127.0.0.1:8000/api/users").send().await {
                    Ok(resp) if resp.ok() => {
                        let fetched_users: Vec<User> = resp.json().await.unwrap_or_default();
                        users.set(fetched_users);
                    }

                    _ => message.set("Failed to fetch users".into()),
                }
            });
        })
    };

    let create_user = {
        let user_state = user_state.clone();
        let message = message.clone();
        let get_users = get_users.clone();
        Callback::from(move |_| {
            let (name, email, _) = (*user_state).clone();
            let user_state = user_state.clone();
            let message = message.clone();
            let get_users = get_users.clone();

            spawn_local(async move {
                let user_data = serde_json::json!({ "name": name, "email": email });

                let response = Request::post("http://127.0.0.1:8000/api/users")
                    .header("Content-Type", "application/json")
                    .body(user_data.to_string())
                    .send().await;

                match response {
                    Ok(resp) if resp.ok() => {
                        message.set("User created successfully".into());
                        get_users.emit(());
                    }

                    _ => message.set("Failed to create user".into()),
                }

                user_state.set(("".to_string(), "".to_string(), None));
            });
        })
    };

    let update_user = {
        let user_state = user_state.clone();
        let message = message.clone();
        let get_users = get_users.clone();

        Callback::from(move |_| {
            let (name, email, editing_user_id) = (*user_state).clone();
            let user_state = user_state.clone();
            let message = message.clone();
            let get_users = get_users.clone();

            if let Some(id) = editing_user_id {
                spawn_local(async move {
                    let response = Request::put(&format!("http://127.0.0.1:8000/api/users/{}", id))
                        .header("Content-Type", "application/json")
                        .body(serde_json::to_string(&(id, name.as_str(), email.as_str())).unwrap())
                        .send().await;

                    match response {
                        Ok(resp) if resp.ok() => {
                            message.set("User updated successfully".into());
                            get_users.emit(());
                        }

                        _ => message.set("Failed to update user".into()),
                    }

                    user_state.set(("".to_string(), "".to_string(), None));
                });
            }
        })
    };

    let delete_user = {
        let message = message.clone();
        let get_users = get_users.clone();

        Callback::from(move |id: i32| {
            let message = message.clone();
            let get_users = get_users.clone();

            spawn_local(async move {
                let response = Request::delete(
                    &format!("http://127.0.0.1:8000/api/users/{}", id)
                ).send().await;

                match response {
                    Ok(resp) if resp.ok() => {
                        message.set("User deleted successfully".into());
                        get_users.emit(());
                    }

                    _ => message.set("Failed to delete user".into()),
                }
            });
        })
    };

    let edit_user = {
        let user_state = user_state.clone();
        let users = users.clone();

        Callback::from(move |id: i32| {
            if let Some(user) = users.iter().find(|u| u.id == id) {
                user_state.set((user.name.clone(), user.email.clone(), Some(id)));
            }
        })
    };
...

You can check writing the code line by line in this part of the video

Now we need to add the HTML code rendered by the Yew component. Below is the code you should add in the main.rs file.

If you know React, this is similar to what happens in a JSX file.

This HTML part written using Yew's html! macro, defines the user interface of the Yew application. It consists of several key sections that provide functionalities for managing users.

• A main container with some padding and a nice layout using Tailwind CSS.
• A big title at the top says “User Management” to let users know what the app is about.
• Two input fields: one for the user's name and another for their email. As you type, it updates the state to track what’s entered.
• A button that changes its action and label depending on whether you're creating a new user or updating an existing one. It says Create User if you're adding a new one or Update User if you're editing.
• A space for messages to appear—like success or error messages—just below the input fields (the text color is always green; feel free to make it red in case of errors).
• A Fetch User List button that, when clicked, pulls the latest user data from the backend.
• A section that lists all the users fetched from the backend, showing their ID, name, and email.
• Each user in the list has a "Delete" button to remove them and an "Edit" button to load their details into the input fields for editing.

...
html! {
        <div class="container mx-auto p-4">
            <h1 class="text-4xl font-bold text-blue-500 mb-4">{ "User Management" }</h1>
                <div class="mb-4">
                    <input
                        placeholder="Name"
                        value={user_state.0.clone()}
                        oninput={Callback::from({
                            let user_state = user_state.clone();
                            move |e: InputEvent| {
                                let input = e.target_dyn_into::<web_sys::HtmlInputElement>().unwrap();
                                user_state.set((input.value(), user_state.1.clone(), user_state.2));
                            }
                        })}
                        class="border rounded px-4 py-2 mr-2"
                    />
                    <input
                        placeholder="Email"
                        value={user_state.1.clone()}
                        oninput={Callback::from({
                            let user_state = user_state.clone();
                            move |e: InputEvent| {
                                let input = e.target_dyn_into::<web_sys::HtmlInputElement>().unwrap();
                                user_state.set((user_state.0.clone(), input.value(), user_state.2));
                            }
                        })}
                        class="border rounded px-4 py-2 mr-2"
                    />

                    <button
                        onclick={if user_state.2.is_some() { update_user.clone() } else { create_user.clone() }}
                        class="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 px-4 rounded"
                    >
                        { if user_state.2.is_some() { "Update User" } else { "Create User" } }

                    </button>
                        if !message.is_empty() {
                        <p class="text-green-500 mt-2">{ &*message }</p>
                    }
                </div>

                <button
                    onclick={get_users.reform(|_| ())}  
                    class="bg-gray-500 hover:bg-gray-700 text-white font-bold py-2 px-4 rounded mb-4"
                >
                    { "Fetch User List" }
                </button>

                <h2 class="text-2xl font-bold text-gray-700 mb-2">{ "User List" }</h2>

                <ul class="list-disc pl-5">
                    { for (*users).iter().map(|user| {
                        let user_id = user.id;
                        html! {
                            <li class="mb-2">
                                <span class="font-semibold">{ format!("ID: {}, Name: {}, Email: {}", user.id, user.name, user.email) }</span>
                                <button
                                    onclick={delete_user.clone().reform(move |_| user_id)}
                                    class="ml-4 bg-red-500 hover:bg-red-700 text-white font-bold py-1 px-2 rounded"
                                >
                                    { "Delete" }
                                </button>
                                <button
                                    onclick={edit_user.clone().reform(move |_| user_id)}
                                    class="ml-4 bg-yellow-500 hover:bg-yellow-700 text-white font-bold py-1 px-2 rounded"
                                >
                                    { "Edit" }
                                </button>
                            </li>
                        }
                    })}

                </ul>


        </div>
    }
...

You can check writing the code line by line in this part of the video

Here is the complete code for the /frontend/src/main.rs file:

use yew::prelude::*;
use serde::{ Deserialize, Serialize };
use gloo::net::http::Request;
use wasm_bindgen_futures::spawn_local;

#[function_component(App)]
fn app() -> Html {
    let user_state = use_state(|| ("".to_string(), "".to_string(), None as Option<i32>));
    let message = use_state(|| "".to_string());
    let users = use_state(Vec::new);

    let get_users = {
        let users = users.clone();
        let message = message.clone();
        Callback::from(move |_| {
            let users = users.clone();
            let message = message.clone();
            spawn_local(async move {
                match Request::get("http://127.0.0.1:8000/api/users").send().await {
                    Ok(resp) if resp.ok() => {
                        let fetched_users: Vec<User> = resp.json().await.unwrap_or_default();
                        users.set(fetched_users);
                    }

                    _ => message.set("Failed to fetch users".into()),
                }
            });
        })
    };

    let create_user = {
        let user_state = user_state.clone();
        let message = message.clone();
        let get_users = get_users.clone();
        Callback::from(move |_| {
            let (name, email, _) = (*user_state).clone();
            let user_state = user_state.clone();
            let message = message.clone();
            let get_users = get_users.clone();

            spawn_local(async move {
                let user_data = serde_json::json!({ "name": name, "email": email });

                let response = Request::post("http://127.0.0.1:8000/api/users")
                    .header("Content-Type", "application/json")
                    .body(user_data.to_string())
                    .send().await;

                match response {
                    Ok(resp) if resp.ok() => {
                        message.set("User created successfully".into());
                        get_users.emit(());
                    }

                    _ => message.set("Failed to create user".into()),
                }

                user_state.set(("".to_string(), "".to_string(), None));
            });
        })
    };

    let update_user = {
        let user_state = user_state.clone();
        let message = message.clone();
        let get_users = get_users.clone();

        Callback::from(move |_| {
            let (name, email, editing_user_id) = (*user_state).clone();
            let user_state = user_state.clone();
            let message = message.clone();
            let get_users = get_users.clone();

            if let Some(id) = editing_user_id {
                spawn_local(async move {
                    let response = Request::put(&format!("http://127.0.0.1:8000/api/users/{}", id))
                        .header("Content-Type", "application/json")
                        .body(serde_json::to_string(&(id, name.as_str(), email.as_str())).unwrap())
                        .send().await;

                    match response {
                        Ok(resp) if resp.ok() => {
                            message.set("User updated successfully".into());
                            get_users.emit(());
                        }

                        _ => message.set("Failed to update user".into()),
                    }

                    user_state.set(("".to_string(), "".to_string(), None));
                });
            }
        })
    };

    let delete_user = {
        let message = message.clone();
        let get_users = get_users.clone();

        Callback::from(move |id: i32| {
            let message = message.clone();
            let get_users = get_users.clone();

            spawn_local(async move {
                let response = Request::delete(
                    &format!("http://127.0.0.1:8000/api/users/{}", id)
                ).send().await;

                match response {
                    Ok(resp) if resp.ok() => {
                        message.set("User deleted successfully".into());
                        get_users.emit(());
                    }

                    _ => message.set("Failed to delete user".into()),
                }
            });
        })
    };

    let edit_user = {
        let user_state = user_state.clone();
        let users = users.clone();

        Callback::from(move |id: i32| {
            if let Some(user) = users.iter().find(|u| u.id == id) {
                user_state.set((user.name.clone(), user.email.clone(), Some(id)));
            }
        })
    };

    //html

    html! {
        <div class="container mx-auto p-4">
            <h1 class="text-4xl font-bold text-blue-500 mb-4">{ "User Management" }</h1>
                <div class="mb-4">
                    <input
                        placeholder="Name"
                        value={user_state.0.clone()}
                        oninput={Callback::from({
                            let user_state = user_state.clone();
                            move |e: InputEvent| {
                                let input = e.target_dyn_into::<web_sys::HtmlInputElement>().unwrap();
                                user_state.set((input.value(), user_state.1.clone(), user_state.2));
                            }
                        })}
                        class="border rounded px-4 py-2 mr-2"
                    />
                    <input
                        placeholder="Email"
                        value={user_state.1.clone()}
                        oninput={Callback::from({
                            let user_state = user_state.clone();
                            move |e: InputEvent| {
                                let input = e.target_dyn_into::<web_sys::HtmlInputElement>().unwrap();
                                user_state.set((user_state.0.clone(), input.value(), user_state.2));
                            }
                        })}
                        class="border rounded px-4 py-2 mr-2"
                    />

                    <button
                        onclick={if user_state.2.is_some() { update_user.clone() } else { create_user.clone() }}
                        class="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 px-4 rounded"
                    >
                        { if user_state.2.is_some() { "Update User" } else { "Create User" } }

                    </button>
                        if !message.is_empty() {
                        <p class="text-green-500 mt-2">{ &*message }</p>
                    }
                </div>

                <button
                    onclick={get_users.reform(|_| ())}  
                    class="bg-gray-500 hover:bg-gray-700 text-white font-bold py-2 px-4 rounded mb-4"
                >
                    { "Fetch User List" }
                </button>

                <h2 class="text-2xl font-bold text-gray-700 mb-2">{ "User List" }</h2>

                <ul class="list-disc pl-5">
                    { for (*users).iter().map(|user| {
                        let user_id = user.id;
                        html! {
                            <li class="mb-2">
                                <span class="font-semibold">{ format!("ID: {}, Name: {}, Email: {}", user.id, user.name, user.email) }</span>
                                <button
                                    onclick={delete_user.clone().reform(move |_| user_id)}
                                    class="ml-4 bg-red-500 hover:bg-red-700 text-white font-bold py-1 px-2 rounded"
                                >
                                    { "Delete" }
                                </button>
                                <button
                                    onclick={edit_user.clone().reform(move |_| user_id)}
                                    class="ml-4 bg-yellow-500 hover:bg-yellow-700 text-white font-bold py-1 px-2 rounded"
                                >
                                    { "Edit" }
                                </button>
                            </li>
                        }
                    })}

                </ul>


        </div>
    }
}

#[derive(Serialize, Deserialize, Clone, Debug)]
struct User {
    id: i32,
    name: String,
    email: String,
}

fn main() {
    yew::Renderer::<App>::new().render();
}

Building the Frontend

It's now time to run the frontend.

You can type:

cargo build --target wasm32-unknown-unknown

And then you can run the frontend by running:

trunk serve

You can now visit http://127.0.0.1:8080 and click the Fetch User List button to fetch the users from the backend:

As you can see, we fetch users from the backend and display them in the front end. The front end also allows you to create, update, and delete users.

For example, we can create a user with name yew and email yes@mail.com:

The user should be displayed correctly on the frontend, with the message User created successfully:

To check the consistency of data, we can use Postman, making a GET request to http://127.0.0.1:8000/api/users:

We can also update a user, for example, the one with ID 3, by changing the name to subscribe and the email to subscribe@mail.com. Notice that when we hit the Edit button, the form is populated with the user data, and the button label is changed to Update User:

After hitting the Update User button, we should see the message User updated successfully:

The last test is to delete a user, for example, the one with ID 3. After hitting the Delete button, we should see the message User deleted successfully:

After hitting the Delete button, we should see the message User deleted successfully:

Note: You should be able to see all the HTTP requests in the backend logs.

Let's create the last user, and let's call it last and let's use as email last@mail.com

If we use Postman and make a GET request to http://127.0.0.1:8000/api/users, we should see the following output:

We can also see the data by opening a new tab and visiting http://127.0.0.1:8000/api/users:

The last test is to check it directly in the Postgres container. You can step into the container by running docker exec -it db psql -U postgres and then run:

\dt
select * from users;

Well done!

Conclusion

In this tutorial, we built a full-stack web application using Rust. We built a backend using Rocket and Postgres and a frontend using Yew, Tailwind CSS, and Trunk. We created, read, update, and deleted users from the database using the front end. We also tested the APIs using Postman and checked

All the code is available on GitHub (link in video description)

You can find me here: https://francescociulla.com

They provide insights and help us learn new concepts.

But without practical application, you’ll likely forget what you’ve learned the day after. That’s why solving exercises is so important in programming. It forces your brain to engage, solve the problem with your hands, and truly grasp the concepts.

In many tutorials, including mine, the student’s approach is often PASSIVE: You watch the tutorial, read the article, clone the project, run it, it works, and you think you are making progress. And yes, you do make some progress, but it’s the same progress you make by watching someone else play poker. You understand the rules but miss out on what it means to play and learn the tactics to win.

That's why I created the Rust Workbook, a collection of exercises designed to help you learn Rust by doing. These exercises are carefully crafted to guide you through solving problems, building confidence, and reinforcing your understanding of Rust's core concepts.

In this article I want to give you a sneak peek into the Rust Workbook, show you how the exercises are structured, and provide an example to illustrate how they work.

Let’s dive in!

To truly benefit from this exercise, try to solve it independently before peeking at the solution (give yourself at least 30 minutes). That’s when the magic happens in your brain, and that’s when real learning occurs.

A Simple Exercise Example: Understanding Ownership in Rust Let's examine an exercise focused on understanding Rust's ownership system to illustrate how the exercises are structured and how they guide you through the learning process.

Exercise 2.2: Ownership

Introduction

In Rust, every value has an owner, the variable that holds the value. When you move a value from one variable to another, the original variable can no longer be used. You can also borrow a value using the & operator, which allows you to access the value without transferring ownership.

Task

Declare a variable, move its value to another variable, and observe what happens when using the original variable. Then, use the & operator to borrow the value instead of moving it and see how this affects the original variable.

Instructions

1. Open your terminal, run cargo new ownership, then cd ownership.
2. Open src/main.rs in your IDE and replace its content with the code below.

fn main() {
    // Declare a variable with a string value
    let s1 = String::from("hello");

    // Move the value to a new variable (let s2 = s1)
    // Print both variables to see what happens

    // Borrow the value (let s2 = &s1)
    // Print both the original and the borrowed variable
}

3. Declare a variable with a string value using the let keyword.
4. Move the value from this variable to a new variable using the = operator (let s2 = s1;).
5. Try to print the original and the new variable to see what happens (you should encounter an error!).
6. Instead, use the & operator to borrow the value from the original variable and assign it to a new variable (e.g., let s2 = &s1;).
7. Print both the original and the borrowed variable to see the difference.
8. Save the file and run cargo run in the terminal to see the result.

Good luck. If you need help, you can check this video

Once you have tried to solve the exercise, you can check the solution below.

Solution to Exercise 2.2: Ownership

Solution Overview

In this exercise, you were asked to explore Rust's ownership system by declaring a variable, moving its value to another variable, and observing what happens when you try to use the original variable. You also used the & operator to borrow the value instead of moving it, which allowed you to see how borrowing works in Rust.

Final Code

Here’s the code that achieves the task:

fn main() {
    // Declare a variable with a string value
    let s1 = String::from("hello");

    // Move the value to a new variable (s1 is no longer valid after this point)
    let s2 = s1;

    // Uncommenting the following line would cause a compile-time error because s1 has been moved
    // println!("s1: {}", s1); // This would cause an error

    // Print the new variable
    println!("s2: {}", s2);

    // Borrow the value from s2 using a reference
    let s3 = &s2;

    // Print both the original and the borrowed variable
    println!("s2: {}", s2);
    println!("s3: {}", s3);
}

Program Output

When you run the program using cargo run, you will see this output in your terminal:

s2: hello
s2: hello
s3: hello

Explanation

• Ownership Transfer (Move): The line let s2 = s1; moves the String ownership from s1 to s2. After this move, s1 is no longer valid, and any attempt to use s1 would result in a compile-time error.

• Borrowing with References: The line let s3 = &s2; creates a reference to s2, meaning s3 borrows the value of s2 without taking ownership. This allows both s2 and s3 to be used without transferring ownership.

• Error Prevention: Rust's ownership system ensures memory safety by preventing multiple data ownership. Once a value is moved, the original variable can no longer be used, which prevents dangling references or double-free errors.

This exercise demonstrates how Rust's ownership model works, including how values can be moved between variables and how references can be used to borrow values without taking ownership.

It’s not about making things difficult—it’s about guiding you through the process, step by step, to help you understand how Rust manages memory safely.

Conclusion

This example highlights how the exercises in this workbook are designed. They may not be overly challenging, but they are structured to guide you through the learning process, helping you build a solid understanding of Rust's core concepts.

The book encourages you to think critically about your code and understand the underlying principles by taking a step-by-step approach.

Remember, the real value of this workbook lies in solving the exercises. Take your time, work through them methodically, and you’ll find that even simple exercises can lead to deep insights into how Rust works.

If you like this style and you want more exercises like the one above, check out the full Rust Workbook.

However, as with any powerful tool, getting the most out of Rust requires a solid understanding of its fundamentals.

In this article, I want to share three common mistakes beginners often make when learning Rust and practical solutions to help you avoid them.

All the code is available and open source here: https://github.com/FrancescoXX/three-rust-mistakes

Let's get started!

1. Confusion Around the let Keyword

If you're from a JavaScript background, you might find Rust's let keyword familiar yet surprisingly different.

Example:

In JavaScript, you can reassign a variable declared with let:

let x = 10;
x = 20;  // Reassignment is allowed

console.log(x);  // Outputs: 20

..But if we try to do the same in Rust, we'll encounter a compile-time error:

fn main() {
    let x = 10;
    x = 20;  // This will cause a compile-time error in Rust

    println!("{}", x);
}

Why? In Rust, variables are immutable by default, meaning you can't reassign a value unless you explicitly declare the variable as mutable:

While let in both languages is used to declare variables, Rust’s strict handling of mutability and scope can be a source of confusion.

Solution:

To allow reassignment, you must declare the variable as mutable using the mut keyword:

fn main() {
    let mut x = 10;  // Declare x as mutable
    x = 20;  // Now reassignment is allowed

    println!("{}", x);  // Outputs: 20
}

If you want to learn more about variables in Rust, check out this YouTube video

2. Misunderstanding Ownership and Borrowing

One of Rust's most distinctive and powerful features is its ownership model.

While this model ensures memory safety without a garbage collector, it can be tricky for beginners to grasp fully.

Misunderstanding ownership and borrowing often leads to common errors like "value borrowed after move" or "cannot borrow as mutable."

Example:

Consider the following code:

fn main() {
    let s = String::from("Hello, Rust!");
    let s2 = s;  // Ownership moves to s2, s is no longer valid

    println!("{}", s);  // This will cause a compile-time error
}

In this example, when we assign s to s2, the ownership of the data is transferred to s2. As a result, s is no longer valid, and attempting to use it will cause a compile-time error!

Solution:

To avoid this mistake, you can borrow the value instead of transferring ownership.

Borrowing allows you to reference the original value without taking ownership, ensuring that the original variable remains valid:

fn main() {
    let s = String::from("Hello, Rust!");
    let s2 = &s;  // Borrowing s, s is still valid

    println!("{}", s);   // This will work
    println!("{}", s2);  // This will also work
}

By using a &s reference , we can access the value without transferring ownership, allowing both s and s2 to coexist without errors.

Understanding ownership and borrowing is crucial to mastering Rust.

If you want a deeper dive into these concepts, check out this YouTube video on Rust's ownership model.

3. Ignoring Error Handling

While it's tempting to ignore error checks and use unwrap to quickly access values, doing so can lead to unexpected panics and runtime errors if something goes wrong.

Rust's Result type provides a powerful mechanism for handling errors safely and concisely, ensuring your program can gracefully deal with unexpected situations.

Example:

Consider the following code snippet that reads a file and prints its contents:

use std::fs::File;
use std::io::Read;

fn main() {
    let file = File::open("example.txt");
    let mut contents = String::new();
    file.unwrap().read_to_string(&mut contents).unwrap();  // This can panic if the file doesn't exist
    println!("{}", contents);
}

In this example, the open method returns a Result type that represents the operation's success or failure.

Using unwrap on the Result can cause the program to panic if the file doesn’t exist or if there's another error.

Solution:

To handle errors properly, you can use the match expression to check the Result and handle both success and failure cases:

use std::fs::File;
use std::io::{self, Read};

fn main() {
    let file = File::open("example.txt");

    match file {
        Ok(mut f) => {
            let mut contents = String::new();
            match f.read_to_string(&mut contents) {
                Ok(_) => println!("{}", contents),
                Err(e) => eprintln!("Error reading file: {}", e),
            }
        }
        Err(e) => eprintln!("Error opening file: {}", e),
    }
}

In this solution, instead of using unwrap, we handle the Result explicitly with a match statement (here is a video about the match statement).

This approach ensures errors are caught and handled, preventing unexpected panics and making the code more robust.

Using the ? Operator:

For even more concise error handling, Rust provides the ? operator, which can be used to propagate errors up the call stack:

use std::fs::File;
use std::io::{self, Read};

fn read_file() -> io::Result<String> {
    let mut file = File::open("example.txt")?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

fn main() {
    match read_file() {
        Ok(contents) => println!("{}", contents),
        Err(e) => eprintln!("Error: {}", e),
    }
}

Here, the ? operator handles errors in a way that keeps the code clean and readable while still ensuring that errors are correctly managed.

If you want an introduction to Error Handling in Rust, check out this YouTube video.

Conclusion

Rust is an excellent language, but it takes time to get used to its quirks and unique features, like any new tool.

Remember, everyone makes mistakes, and it's normal while learning a new programming language, especially one as powerful and unique as Rust.

If you want to learn more about Rust, I have a Rust YouTube playlist where I post a complete course for beginner Rust developers.

All the code is available and open source here: https://github.com/FrancescoXX/three-rust-mistakes

Have fun writing Rust code!

Francesco

Good choice! Rust is an awesome language that combines the power of systems programming with modern language features, and it can be used for Web Development and blockchain.

However, when learning Rust, one of the blockers is getting familiar with its Syntax.

In this article, I'll do my best to provide examples that will make you feel comfortable with them.

Getting Started: Variables and Types

Let's start with the basics: variables.

By default, Rust variables are immutable. This might sound weird if you're used to languages like Python or JavaScript, which allow variables to change.

fn main() {
    let x = 5; // x is immutable by default
    // x = 6; // Uncommenting this will throw a compiler error

    let mut y = 5; // y is mutable
    y = 6; // No problem here
}

Notice the let keyword? That's how you declare variables in Rust. If you want to change a variable, make it mutable with the mut keyword.

Type Annotations

Rust has great type inference: the compiler usually knows your variables' type.

But sometimes, you'll need to specify the type yourself:

// Here, we're explicitly saying that z is a 32-bit integer
let z: i32 = 10;

Rust's type system is one of its great advantages, so it’s worth getting comfortable with it early on.

Functions

Functions in Rust look pretty familiar if you've worked with other languages. But there are some syntax quirks to watch out for.

fn add(a: i32, b: i32) -> i32 {
    a + b // No semicolon means this is the return value
}

Notice that we’re using -> to define the function's return type. Also, there's no return keyword here; Rust returns the last expression by default if you omit the semicolon.

It’s nice once you get used to it.

Ownership and Borrowing

Alright, here’s where things get interesting. Rust’s ownership model makes it stand out but can be tricky at first.

Let’s see another example

Ownership

In Rust, each value has a variable, which is its owner.

When the owner goes out of scope, the value is dropped. This is how Rust avoids memory leaks.

fn main() {
    let s1 = String::from("hello");
    let s2 = s1; // Ownership of the String is moved to s2, s1 is now invalid

    // println!("{}", s1); // This would cause a compile-time error
}

Here, s1 no longer owns the String after it’s moved to s2.

If you try to use s1 after that, Rust won’t let you. It’s like Rust says: "Hey, that’s not yours anymore."

Borrowing

But what if you want to use a value without taking ownership of it?

That’s where borrowing comes in. You can borrow a value by using references:

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1); // We're borrowing s1 here

    println!("The length of '{}' is {}.", s1, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

In this example, &s1 is a reference to s1. The calculate_length function temporarily borrows s1 without taking ownership. After the function is done, s1 is still valid. That's pretty cool.

Lifetimes

Lifetimes are how Rust keeps track of how long references are valid.

They can be confusing initially, but they’re crucial for safe memory management.

Let's see a very basic example, to get familiar with it.

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
}

Here, 'a is a lifetime parameter. It means the references x and y must live at least as long as the return value. This ensures that we don’t return a reference to something that’s already been dropped.

Pattern Matching

Rust's match statement is like a switch on steroids. It’s one of my favorite parts of the language because it’s so powerful and expressive.

fn main() {
    let number = 7;

    match number {
        1 => println!("One!"),
        2 => println!("Two!"),
        3 | 4 | 5 => println!("Three, Four, or Five!"),
        6..=10 => println!("Between Six and Ten!"),
        _ => println!("Anything else!"),
    }
}

The match statement checks a value against multiple patterns and runs the code for the first matching pattern. The _ is a catch-all pattern, which is useful when you want to handle anything you haven’t explicitly matched.

Destructuring with Pattern Matching

You can also use match to destructure complex data types like tuples or enums.

fn main() {
    let pair = (2, 5);

    match pair {
        (0, y) => println!("First is zero and y is {}", y),
        (x, 0) => println!("x is {} and second is zero", x),
        _ => println!("No zeroes here!"),
    }
}

This is just scratching the surface.

Match can do much more, but this should give you a solid foundation.

Error Handling

Rust doesn’t have exceptions. Instead, it uses the Result and Option types for error handling. It might feel a bit verbose initially, but it’s much safer than unchecked exceptions.

fn main() {
    let result = divide(10, 2);
    match result {
        Ok(v) => println!("Result is {}", v),
        Err(e) => println!("Error: {}", e),
    }
}

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err(String::from("Division by zero"))
    } else {
        Ok(a / b)
    }
}

Here, Result is a type that can be either Ok (success) or Err (error). This forces you to handle success and failure cases, which is great for writing robust code.

The ? Operator

To make error handling a bit more ergonomic, Rust provides the ? Operator. It’s a shorthand for propagating errors.

fn main() -> Result<(), String> {
    let result = divide(10, 0)?; // If divide returns Err, it returns from the function immediately
    println!("Result is {}", result);
    Ok(())
}

This is Rust's saying, “If there’s an error, just return it.”

Advanced Syntax: Traits, Generics, and More

Now that we've got the basics down, let's dive into more advanced topics.

Traits: Interfaces (Kinda)

Traits are kind of like interfaces in other languages. They define shared behavior that different types can implement.

trait Summary {
    fn summarize(&self) -> String;
}

struct Article {
    title: String,
    content: String,
}

impl Summary for Article {
    fn summarize(&self) -> String {
        format!("{}: {}", self.title, self.content)
    }
}

Here, we define and implement a Summary trait for the Article struct. Now, any Article can be summarized. Traits are super powerful for writing generic and reusable code.

Generics: Writing Flexible Code

Generics let you write functions and types that work with any data type.

fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];
    for item in list {
        if item > largest {
            largest = item;
        }
    }
    largest
}

This function works with any type T that can be compared. The PartialOrd part is trait-bound, meaning that T must implement the PartialOrd trait, which allows for ordering comparisons.

Practical Tips: Writing Idiomatic Rust

• Use rustfmt: Rust has a built-in formatter that keeps your code looking sharp. Just run cargo fmt in your project directory.

• Use Rust Analyzer: This powerful IDE extension provides code completion, refactoring, and more. It’s like having an assistant that knows Rust inside and out.

• Clippy: This is a linter for Rust that catches common mistakes and suggests improvements. Run cargo clippy to see what it finds.

Conclusion

This quick article is to get a bit more familiar with Rust.

I have a series of free videos about these specific topics.

You can check it out here

In Rust, testing is built into the language, making writing and running tests straightforward.

This article will introduce you to the basics of testing in Rust with practical examples.

If you prefer a video version

Create the lib project

In this case, we will create a library project using the following command:

cargo new adder --lib

Remember to use the --bin flag to create a binary project.

To run the tests, you can use the following command:

cargo test

This command will compile the code and run the tests.

Now let's create a simple function to test.

Basic Test Function

Let's start with a simple test function. In Rust, test functions are annotated with #[test].

#[cfg(test)]
mod tests {
    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }
}

In this example, the #[cfg(test)] attribute ensures that the test module is only compiled when running tests. The #[test] attribute marks the function as a test.

The assert_eq! macro checks if the two arguments are equal. If they are not, the test will fail.

The output of the test will look like this:

running 1 test
test tests::it_works ... ok

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

Making a Test That Fails

It's often useful to see what happens when a test fails.

Here's an example:

#[cfg(test)]
mod tests {
    #[test]
    fn it_fails() {
        assert_eq!(2 + 2, 5);
    }
}

When you run this test, it will fail, and you'll see an error message like this:

---- it_fails stdout ----
thread 'tests::it_fails' panicked at 'assertion failed: `(left == right)`
  left: `4`,
 right: `5`', src/lib.rs:4:9
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

Using the assert! Macro

The assert! macro is used to check boolean expressions. If the expression evaluates to false, the test will fail.

#[cfg(test)]
mod tests {
    #[test]
    fn check_true() {
        assert!(true);
    }
}

Testing Equality with assert_eq! and assert_ne!

The assert_eq! macro checks if two values are equal, while assert_ne! checks if they are not.

#[cfg(test)]
mod tests {
    #[test]
    fn test_equality() {
        assert_eq!(3 * 3, 9);
        assert_ne!(3 * 3, 8);
    }
}

Adding Custom Failure Messages

You can add custom failure messages to your tests using the assert! macro.

#[cfg(test)]
mod tests {
    #[test]
    fn custom_message() {
        assert_eq!(2 + 2, 5, "Math is broken!");
    }
}

In this example, the test will fail with the message "Math is broken!".

The output will look like this:

---- custom_message stdout ----
thread 'tests::custom_message' panicked at 'assertion failed: `(left == right)`
  left: `4`,
 right: `5`: Math is broken!', src/lib.rs:4:9

Checking for Panics with should_panic

You can test if a function panics using the should_panic attribute.

#[cfg(test)]
mod tests {
    #[test]
    #[should_panic]
    fn it_panics() {
        panic!("This test will panic");
    }
}

Using Result in Tests

Test functions can return Result<(), E> to use the ? operator for error handling.

#[cfg(test)]
mod tests {
    #[test]
    fn test_with_result() -> Result<(), String> {
        if 2 + 2 == 4 {
            Ok(())
        } else {
            Err("Math is broken".into())
        }
    }
}

Conclusion

Rust makes testing easy and powerful with its built-in features.

By using attributes like #[test], assert!, assert_eq!, and should_panic, you can write robust tests for your code.

If you prefer a video version

The Rust team just announced the release of Rust 1.80.0.

This article aims to give you a quick recap of the main updates.

To update to this latest version, run:

$ rustup update stable

Key Updates in Rust 1.80.0

LazyCell and LazyLock

These new types delay data initialization until first access.

LazyLock is thread-safe, suitable for static values, while LazyCell is not thread-safe but can be used in thread-local statics.

Example using LazyLock:

use std::sync::LazyLock;
use std::time::Instant;

static LAZY_TIME: LazyLock<Instant> = LazyLock::new(Instant::now);

fn main() {
    let start = Instant::now();
    std::thread::scope(|s| {
        s.spawn(|| {
            println!("Thread lazy time is {:?}", LAZY_TIME.duration_since(start));
        });
        println!("Main lazy time is {:?}", LAZY_TIME.duration_since(start));
    });
}

Checked cfg Names and Values

Cargo 1.80 now includes checks for cfg names and values to catch typos and misconfigurations, improving the reliability of conditional configurations.

Example demonstrating cfg check:

fn main() {
    println!("Hello, world!");

    #[cfg(feature = "crayon")]
    rayon::join(
        || println!("Hello, Thing One!"),
        || println!("Hello, Thing Two!"),
    );
}

Warning output:

warning: unexpected `cfg` condition value: `crayon`
 --> src/main.rs:4:11
  |
4 |     #[cfg(feature = "crayon")]
  |           ^^^^^^^^^^--------
  |                     |
  |                     help: there is an expected value with a similar name: `"rayon"`
  |
  = note: expected values for `feature` are: `rayon`
  = help: consider adding `crayon` as a feature in `Cargo.toml`

Exclusive Ranges in Patterns

Rust now supports exclusive range patterns (a..b), enhancing pattern matching and reducing the need for separate constants for inclusive endpoints.

Example using exclusive range patterns:

pub fn size_prefix(n: u32) -> &'static str {
    const K: u32 = 10u32.pow(3);
    const M: u32 = 10u32.pow(6);
    const G: u32 = 10u32.pow(9);
    match n {
        ..K => "",
        K..M => "k",
        M..G => "M",
        G.. => "G",
    }
}

Stabilized APIs

New stable APIs include implementations for Rc and Arc types, enhancements to Duration, Option, Seek, BinaryHeap, NonNull, and more.

Read more

This is just a quick recap. For more details, check out here

Have a great day

Francesco

After four and a half years of sharing free content and insights on social media, I'm excited to announce my very first paid product: a comprehensive guide to mastering Rust programming.

This book is designed to take you from a complete beginner to a proficient Rust developer.

With 16 detailed chapters, it covers everything from the fundamentals to advanced topics such as pointers and multi-threading.

Here’s what you can expect:

Foundational Concepts: Start setting up your environment and writing your first Rust programs. Core Rust Features: Understand ownership, lifetimes, and memory safety. Advanced Techniques: Delve into pointers, concurrency, and more. I’m committed to making Rust accessible and engaging, and this book is crafted to ensure you gain theoretical knowledge and practical skills.

Sign up for my newsletter for the latest updates, exclusive previews, and special offers. By subscribing, you’ll be the first to know about discounts, early access opportunities, and more.

Stay informed and participate in this exciting journey—subscribe to the newsletter here.

I appreciate your support!

Usually, when we learn about a programming language, we reference other languages, like “it works like in JavaScript,” “it’s similar to Python,” and so on.

We can’t make this analogy in this case because “Lifetimes” are peculiar to the Rust programming language.

Lifetimes in Rust ensure that references are valid as long as they are used, preventing common bugs like dangling pointers and use-after-free errors.

This article explores lifetimes, their significance, and how to work with them through examples.

If you prefer a video version {% youtube w8lmMaKY3Hs %}

So what are lifetimes?

In short, Lifetimes are a form of generic parameter that describes the scope for which a reference is valid. The Rust compiler uses lifetimes to check that references do not outlive the data they point to, ensuring memory safety.

In Rust, every reference has a lifetime (even though you don't always see it in the code). The compiler infers lifetimes in many cases, but sometimes you need to specify them explicitly, especially in function signatures and struct definitions.

Basic Example:

Let’s see a basic example

In this example, x is created inside an inner scope and is destroyed at the end of that scope.

The reference r points to x, but r is used outside the scope where x was valid. Rust's borrow checker will produce a compile-time error to prevent this situation.

Explicit Lifetimes in Function Signatures

Sometimes, you need to write functions that accept references and return references. To ensure the references are valid, you must specify the lifetimes explicitly.

Consider this function that returns the longer of two string slice:

In the function longest, we declare a lifetime parameter 'a and use it to indicate that the references s1 and s2 must be valid for at least as long as the returned reference.

This ensures the returned reference does not outlive the data it points to.

Lifetimes in Structs

Lifetimes are also used in structs to ensure that references held by the struct do not outlive the struct itself.

Let’s see an example:

In this example, the ImportantExcerpt struct references a part of a string. The lifetime 'a ensures that the reference part cannot outlive the ImportantExcerpt instance, thereby preventing invalid references.

Conclusion

Lifetimes in Rust are a powerful feature that guarantees memory safety by ensuring references are valid for as long as they are used.

While the compiler often infers lifetimes, understanding and specifying them explicitly when needed is important for writing robust Rust programs.

With these examples and explanations, you should have a good foundation to explore more complex scenarios involving lifetimes in Rust.

If you prefer a video version

Traits might sound new, but you've probably encountered the concept before. Think of them like interfaces in other languages – they define shared behavior in a way that multiple types can use. Let's break down how traits work and why they're helpful.

Here's a video version if you want to check it out.

What is a Trait?

A trait in Rust defines functionality that a particular type has and can share with others. It specifies methods that can be called on a type. For example, imagine we have different types of text data: a NewsArticle struct for news stories and a Tweet struct for tweets. Both can share a typical behavior: summarizing content. We define this shared behavior using a trait.

pub trait Summary {
    fn summarize(&self) -> String;
}

Here, the Summary trait has a summarize method. Any type implementing this trait must provide its own version of this method.

Implementing Traits

To implement a trait, you define the method specified by the trait for your type. Here's how we do it for NewsArticle and Tweet.

pub struct NewsArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

pub struct Tweet {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub retweet: bool,
}

impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

Now, both NewsArticle and Tweet can use the summarize method. This allows us to call summarize on instances of these types.

Default Implementations

Traits can also have default method implementations. If we don't want to write the same method for each type, we can provide a default:

pub trait Summary {
    fn summarize(&self) -> String {
        String::from("(Read more...)")
    }
}

Types can still override this default if they need specific behavior.

Using Traits as Parameters

Traits can be used to define function parameters. If we want a function to accept any type that implements Summary, we can write:

pub fn notify(item: &impl Summary) {
    println!("Breaking news! {}", item.summarize());
}

This makes our code flexible and reusable.

Returning Types that Implement Traits

We can also specify that a function returns a type that implements a trait:

fn returns_summarizable() -> impl Summary {
    Tweet {
        username: String::from("horse_ebooks"),
        content: String::from("of course, as you probably already know, people"),
        reply: false,
        retweet: false,
    }
}

This allows us to return different types that conform to the Summary trait without exposing the concrete type.

Conditional Implementations

Sometimes, you want methods to be available only if certain conditions are met. Rust allows conditional implementations:

impl<T: Display + PartialOrd> Pair<T> {
    fn cmp_display(&self) {
        if self.x >= self.y {
            println!("The largest member is x = {}", self.x);
        } else {
            println!("The largest member is y = {}", self.y);
        }
    }
}

Here, cmp_display is only available if T implements both Display and PartialOrd.

Conclusion

Traits are a powerful feature in Rust that help define and share behavior across types. They make your code more modular, reusable, and easier to understand. By moving errors to compile time, they ensure your code is robust and efficient. Happy coding!

I just released a video about this topic, if you are curious, you can check it out.

If you prefer a video version

Introducing Rustcrab

Before diving into Pieces, I'd like to introduce you to Rustcrab. Rustcrab is an open-source repository designed to be the ultimate resource hub for Rust developers. The project aims to provide meaningful information about the Rust community, resources, news, projects, dev tools, and more. You can check out Rustcrab on GitHub: Rustcrab.

Setting Up Pieces Suite

I installed Pieces on my Windows machine (but I'm sure other options are available).

The installation process took less than a minute.

I was prompted to allow Pieces Suite to access diagnostic information about my app, and I decided to trust them.

Then, I had the choice of manual or automatic installation. I went with the automatic install.

The installation process started, installing the following components:

• Pieces OS: A local database server that enables Pieces to run quickly. It works both offline and inside the IDE.

• Pieces for Developer: Used to store code snippets, file fragments, images, and more. It requires Pieces OS to work.

Personalizing Pieces Suite

Next, I personalized my Pieces Suite setup.

I chose Dark Mode (it was the default option, well done).

Personalization Preferences

Then, I set up my preferences:

• Areas: DevOps, Frontend, Backend, and Blockchain

• Languages: Rust, JavaScript, TypeScript, and Python

• Toolchains: VSCode and Google Chrome

• Level: Advanced

• Project Type: Individual (for now)

Search, Reference, & Reuse

I was prompted to set the hub for search and materials.

I chose the default generative workflow and blended search as the default search engine. For sort mode, I went with the recommended option (Recent).

Auto-Enrichment & Copilot

For control over data, I chose:

• Blended (recommended)

• Mistral 7b as the default LLM runtime

• No specific automatic material enrichment levels

• Added the local repository for my project Rustcrab

Cloud Accounts & Integrations

I connected Pieces with my GitHub account.

I also claimed my cloud's subdomain (francesco.pieces.cloud).

The onboarding process was now complete!

Pieces Suite in Action

Here’s how Pieces Suite looked the first time I opened it. I am definitely impressed by the UI.

I then clicked on the "Add Material" button and chose "Create from scratch."

I added an existing component I used in my current project—a component that gets a repository's GitHub stars—to the "Rustcrab" project.

Conclusion

Thanks for reading! I went through the Pieces Suite onboarding process and was impressed by the UI and features. I will definitely use it in my future projects.

This was just the installation and onboarding process; I might share something more in the upcoming articles.

If you have any comments, leave them below.

You can check out the Rustcrab project on GitHub: Rustcrab

You can find me here: Francesco Ciulla

You might think I'm diving deep into Rust with what I've done so far, but that was just the beginning. Trust Francesco.

It's Time for an Announcement

I've officially started a new project called:

"Rustcrab, the repository for Rust Developers that isn't crap"

This project aims to create a free, open-source resource dedicated to the Rust programming language.

I will only share meaningful information about the Rust community, resources, news, projects, dev tools, and as much as possible. The project is 100% open-source and free.

What I've Done So Far:

• Bought the domain using NameCheap

• Created a Next.js project and deployed it to Vercel

• Linked the custom domain to Vercel

• Created a very minimal page that includes light and dark modes, real-time GitHub stars, and social profiles

• Integrated Substack email (it might be improved in the future, but for now it works)

Thanks to AI's support, all this was done in just a few hours. It's incredible how AI can speed up the process if you know what you're doing but want it done quickly.

This is how it looks right now. It's pretty basic, and not much on it, but I will keep working on it.

What's Next:

• Add more sections

• Promote the project

• Send email updates

• Create some live events about this

Feel free to check the GitHub repository: Rustcrab GitHub Repository

Why All of This?

Well, because this is basically what I have been doing every day for more than six months: checking @dailydotdev, organizing things, making private lists and notes, and so on. I think it's time for this project to be more open and accessible to everyone.

I will also create a separate channel on Discord for discussions.

If you are interested in this project, subscribe to the newsletter and star the repo (only two stars now).

I will update you in the next few days.

The project aims to make your life easier if you want to get involved with the Rust community, resources, and updates. Rust is not for everyone, but if you want to make a bet on the future of your tech career, this is a great opportunity to stop making excuses and get started.

Disclaimer

For now, it's not even worth checking, but I've learned that the sooner you launch, the better. Feel free to add issues in the GitHub repository, and I will work on that. I can also do some work live.

Well, that was a long post.

If you reached the end, that already means a lot to me.

Thank you

Check the project: Rustcrab

Let's see an example for both.

unwrap_or_else on an Option

For Option, the unwrap_or_else method is used to provide a fallback value if the Option is None**

fn main() {
    let some_value: Option<i32> = Some(10);
    let none_value: Option<i32> = None;

    // Using unwrap_or_else on an Option
    let result_some = some_value.unwrap_or_else(|| {
        println!("some_value was None, using default value.");
        0 // Default value
    });

    let result_none = none_value.unwrap_or_else(|| {
        println!("none_value was None, using default value.");
        0 // Default value
    });

    println!("Result when Option is Some: {}", result_some);
    println!("Result when Option is None: {}", result_none);
}

Output:

none_value was None, using default value.
Result when Option is Some: 10
Result when Option is None: 0

Explanation:

In this example, we have two Option variables, some_value and none_value. The some_value is Some(10) and the none_value is None.

The unwrap_or_else method is used on both Option variables. The closure passed to unwrap_or_else is only called when the Option is None. In this case, the closure prints a message and returns a default value of 0.

unwrap_or_else on a Result

For Result, the unwrap_or_else method is used to provide a fallback value if the Result is an Err.

fn main() {
    let ok_result: Result<i32, &str> = Ok(10);
    let err_result: Result<i32, &str> = Err("An error occurred");

    // Using unwrap_or_else on a Result
    let result_ok = ok_result.unwrap_or_else(|err| {
        println!("ok_result was Err: {}, using default value.", err);
        0 // Default value
    });

    let result_err = err_result.unwrap_or_else(|err| {
        println!("err_result was Err: {}, using default value.", err);
        0 // Default value
    });

    println!("Result when Result is Ok: {}", result_ok);
    println!("Result when Result is Err: {}", result_err);
}

Output:

Error: Error message
Result when Result is Ok: 10
Result when Result is Err: 0

Explanation:

In this example, we have two Result variables, ok_result and err_result. The ok_result is Ok(10) and the err_result is Err("An error occurred").

The unwrap_or_else method is used on both Result variables. The closure passed to unwrap_or_else is only called when the Result is Err. In this case, the closure prints a message and returns a default value of 0.

Conclusion

In both examples, the unwrap_or_else method is used to provide a default value when the Option or Result is None or Err respectively.

The unwrap_or_else method takes a closure that returns the default value. The closure is only called when the Option is None or the Result is Err.

If you find this interesting and you want to get started with Rust, you can check this FREE playlist on YouTube:

What are Structs?

Structs are a way to create more complex data types.

They are similar to tuples, but with a few differences.

For example, you can name the fields of a struct (and you can also define methods for structs).

If you prefer a video version

All the code is available on GitHub (link available in the video description)

Define a Struct

Let's say that we want to crete a User, with name, email, is_active and age. We can define a struct like this:

struct User {
    name: String,
    email: String,
    is_active: bool,
    age: u8,
}

And then you can create an instance of the struct like this:

```rust
struct User {
    name: String,
    email: String,
    is_active: bool,
    age: u8,
}

fn main() {
    let user = User {
        name: String::from("Jhon Doe"),
        email: String::from("doe@mail.com"),
        is_active: true,
        age: 25,
    };
}

Accessing Struct Fields

You can access the fields of a struct using dot notation:

struct User {
    name: String,
    email: String,
    is_active: bool,
    age: u8,
}

fn main() {
    let user = User {
        name: String::from("Jhon Doe"),
        email: String::from("doe@mail.com"),
        is_active: true,
        age: 25,
    };

    println!("User name: {}", user.name);
}

Explanaition:

• We define a struct called User with four fields: name, email, is_active and age.
• We create an instance of the struct and assign it to the user variable.
• We access the name field of the user struct using dot notation (user.name).

Mutable Structs

You can make a struct mutable by using the mut keyword:

struct User {
    name: String,
    email: String,
    is_active: bool,
    age: u8,
}

fn main() {
    let mut user = User {
        name: String::from("Jhon Doe"),
        email: String::from("doe@mail.com"),
        is_active: true,
        age: 25,
    };

    user.name = String::from("Francesco");
    println!("User name: {}", user.name);

}

Note the you can't make individual fields of a struct mutable, you can only make the entire struct mutable.

Create a Struct instance using a function

You can create a function that returns a struct instance:

struct User {
    name: String,
    email: String,
    is_active: bool,
    age: u8,
}

fn main() {
    let user = create_user(String::from("Jhon Doe"), String::from("doe@mail"),);

    println!("User name: {}", user.name);
}

fn create_user(name: String, email: String,) -> User {
    User {
        name,
        email,
        is_active: true,
        age : 25,
    }
}

You can see the init shorthand syntax in the create_user function. This is a shorthand for initializing fields with variables that have the same name as the fields.

Creating Instances from Other Instances with Struct Update Syntax

You can create a new instance of a struct using another instance with the struct update syntax:

struct User {
    name: String,
    email: String,
    is_active: bool,
    age: u8,
}

fn main() {
    let user1 = User {
        name: String::from("Jhon Doe"),
        email: String::from("doe@mail.com"),
        is_active: false,
        age: 40
    };

    let new_user = User {
        name: String::from("Francesco"),
        email: user1.email,
        is_active: user1.is_active,
        age: user1.age,
    };

    println!("User name: {}", new_user.name);
}

In this example, we create a new instance of the User struct using the user1 instance with the struct update syntax.

Tuple Structs

Tuple structs are similar to regular structs, but their fields are not named:

struct Color(i32, i32, i32);
struct Point(i32, i32, i32);

fn main() {
    let black = Color(0, 0, 0);
    let origin = Point(0, 0, 0);
    println!("Black color: {}, {}, {}", black.0, black.1, black.2);
    println!("Origin: {}, {}, {}", origin.0, origin.1, origin.2);
}

In this example, we define two tuple structs: Color and Point. We create instances of these tuple structs and access their fields using dot notation.

Unit-Like Structs

You can define a struct with no fields, called a unit-like struct:

#[derive(Debug)]
struct User;

fn main() {
    let user = User;
    println!("User: {:?}", user);
}

Unit-like structs are useful when you need to implement a trait on a type but don't have any data to store in the type.

Conclusion

Structs are a way to create more complex data types in Rust. They are similar to tuples, but with a few differences. You can name the fields of a struct (and you can also define methods for structs). You can also make a struct mutable by using the mut keyword.

You can create a function that returns a struct instance. You can create a new instance of a struct using another instance with the struct update syntax. You can define tuple structs and unit-like structs.

I hope this lesson was useful. In the next lesson, we will see a practical example of using structs in Rust.

If you prefer a video version

All the code is available on GitHub (link available in the video description)

You can find me on https://francescociulla.com and on Twitter/X

Rust has a built-in type called Slice that is used to reference a contiguous sequence of elements in a collection. Slices are a very important concept in Rust, and they are used extensively in the standard library. In this lesson, we will explore the Slice type and how it is used in Rust.

If you prefer a video version

All the code is available on GitHub (link available in the video description)

What is a Slice?

A slice is a reference to a contiguous sequence of elements in a collection.

Slices are used to reference a portion of a collection, and they are used extensively in the standard library.

Slices are a very important concept in Rust, and they are used extensively in the standard library. In this lesson, we will explore the Slice type and how it is used in Rust.

A first example

Let's see a simple example of a slice. We will use an array:

fn main() {
    let a = ["a", "b", "c", "d", "e"];
    let slice = &a[1..3];
    println!("{:?}", slice);
}

In this example, we have an array a with five elements. We then create a slice slice that references the second and third elements of the array.

When we run the program, we get the following output:

["b", "c"]

The Range 1..3 is used to create the slice. The first number is the starting index, and the second number is the ending index.

The ending index is exclusive, which means that the element at the ending index is not included in the slice.

A second example

Let's try a slice of a vector of integers:

fn main() {
    let v = vec![10, 20, 30, 40, 50];
    let slice = &v[3..4];
    println!("{:?}", slice);
}

In this example, we have a vector v with five elements. We then create a slice slice that references the fourth element of the vector.

When we run the program, we get the following output:

[40]

Third Example

Let's try a slice of a string:

fn main() {
    let s = String::from("hello world");
    let hello = &s[0..5];
    let world = &s[6..11];
    println!("{:?}", hello);
    println!("{:?}", world);
}

In this example, we have a string s with the value "hello world". We then create two slices, hello and world, that reference the first five and last five characters of the string, respectively.

When we run the program, we get the following output:

"hello"
"world"

Range shortcuts for slices

There are some shortcuts for creating slices. For example, if you want to start at index 0, you can omit the first number:

let s = String::from("hello");
let slice = &s[0..2];
let slice = &s[..2];

Will have as an output:

"he"

Also, if you want to go to the end of the string, you can omit the second number:

let s = String::from("hello");
let len = s.len();
let slice = &s[3..len];
let slice = &s[3..];

Will have as an output:

"lo"

You can also get the entire string by using the .. syntax:

let s = String::from("hello");
let len = s.len();
let slice = &s[0..len];
let slice = &s[..];

Will have as an output:

"hello"

Exercise (without Slices)

Let's write a program that takes a string and returns the first word in the string.

First, let'simplement a solution without using slices.

Here is the code:

fn main() {
    let mut s = String::from("hello world");
    let word = first_word(&s);
    println!("the first word is: {}", word);
}


fn first_word(s: &String) -> usize {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return i;
        }
    }

    s.len()
}

Explanation:

• The as_bytes method returns a slice of the string's bytes.
• The iter method returns an iterator over the slice.
• The enumerate method returns an iterator that yields the index and the value of each element in the slice.
• The b' ' syntax is used to create a byte literal.
• The s.len() method returns the length of the string.

We get this output:

the first word is: 5

In this case, 5 is the index of the first space in the string, which is the end of the first word.

But there is a problem with this code. If we try to clear the string s after calling the first_word function, we will NOT get a compile error. The variable word will still have the value 5, even though the string s has been cleared.

fn main() {
    let mut s = String::from("hello world");
    let word = first_word(&s); // word will get the value 5
    println!("the s is: {}", s);
    println!("the first word is: {}", word);

    s.clear(); // this empties the String, making it equal to ""
    println!("the s is: {}", s);
    println!("the first word is: {}", word);    
}

The output will be:

the s is: hello world
the first word is: 5
the s is:
the first word is: 5

The word variable still has the value 5, but the string s has been cleared.

Let's see how we can fix this using slices.

Exercise (using slices)

Let's go back to our programming example.

Using slices, we can rewrite the first_word function like this:

fn first_word(s: &String) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

Now, the first_word function returns a string slice, which is a reference to part of the original string.

If now we have somerthing like this:

fn main() {
    let mut s = String::from("hello world");
    let word = first_word(&s); // word will get the value 5
    println!("the s is: {}", s);
    println!("the first word is: {}", word);

    s.clear(); // this empties the String, making it equal to ""
    println!("the s is: {}", s);
    println!("the first word is: {}", word);    
}

We will get a compile error, because we are trying to use word after s has been cleared.

String literals as Slices

Recall that we talked about string literals being stored inside the binary.

Now that we know about slices, we can understand string literals.

Update the code in the main function to use a string literal below the s variable (you can keep the lines that use s as well). :

fn main() {
    let s = String::from("hello world");
    let word = first_word(&s); // word will get the value 5
    println!("the s is: {}", s);
    println!("the first word is: {}", word);

    let s2 = "hello world";
    let word2 = first_word(&s2); // word will get the value 5
    println!("the s is: {}", s2);
    println!("the first word is: {}", word2);
}

fn first_word(s: &str) -> &str {
    let bytes = s.as_bytes();

    for (i, &item) in bytes.iter().enumerate() {
        if item == b' ' {
            return &s[0..i];
        }
    }

    &s[..]
}

The type of s is &str, which is a slice of a string. This means that s is a reference to a contiguous sequence of characters in memory.

As a final note, the type of s2 is &str, which is a slice of a string. This means that s2 is a reference to a contiguous sequence of characters in memory.

So we can remove the &s2 from the first_word function and the code will still work.

Conclusion

In this lesson, we explored the Slice type in Rust. We learned that a slice is a reference to a contiguous sequence of elements in a collection.

We also learned how to create slices using the Range type and how to use slices to reference parts of a string.

In the next lesson, we will see the Struct type in Rust.

If you prefer a video version

All the code is available on GitHub (link available in the video description)

In this article, we will see how to use references in Rust. If you want an introduction to Ownership in Rust, in can check the previous article

In this lesson, we will see:

• Ownership and Functions
• Return Values and Scope
• Introduction to References and Borrowing
• Mutable References
• Multiple Mutable References
• Mutable and Immutable References
• Dangling references
• References Rules

If you prefer a video version

All the code is available on GitHub (link available in the video description)

Ownership and Functions

When you pass a variable to a function, you move or copy it.

If you move it, as it happens with strings, the variable is no longer valid after the function call.

//ownership and functions
fn main(){
    let i = 5;
    call_integer(i);
    println!("{}", i);

    let s = String::from ("Hello, World!");
    call_string(s);
    println!("{}", s);
}

Return Values and Scope

When a function returns a value, it gives ownership of the value to the calling function.

We can also have a function that has ownership but gives it back to the calling function.

//ownership and functions
fn main(){
    let s1 = give_ownership();
    let s2 = String::from("hello");  // s2 comes into scope
    let s3 = take_and_give_back(s2); // s2 is moved into take_and_give_back, it returns s3

    println!("s1: {}", s1);
    println!("s2: {}", s2); // error: value used here after move
    println!("s3: {}", s3);
}

fn give_ownership() -> String {
    let some_string = String::from("hello");
    some_string
}

fn take_and_give_back(a_string: String) -> String {
    a_string
}

Let's type cargo run -q and see the output:

But if we try to use the s2 variable after the function call, we get an error.

So how can we solve this? Let's see an example.

A first example of getting the ownership back

One first solution might be this: we can return the value passed in input back, using a tuple.

For example, if we want to calculate the length of a string, we can return the string and its length.

fn main(){
    let s1 = String::from("hello");
    let (s2, len) = calculate_length(s1);
    println!("The length of '{}' is {}", s2, len);
}

fn calculate_length(s: String) -> (String, usize){
    let length = s.len();
    (s, length)
}

This "works", but it's not the best solution.

This solution is tedious and error-prone.

Rust has a feature called references that allows you to refer to some value without taking ownership of it.

Let's see how to modify the previous example using references.

Introduction to References and Borrowing

Modify the code above to use references instead of taking ownership of the string.

fn main(){
    let s1 = String::from("hello");
    let len = calculate_length(&s1);
    println!("The length of '{}' is {}", s1, len);
}

fn calculate_length(s: &String) -> usize{
    let length = s.len();
    length
}

Explanation: &s1 creates a reference to the value of s1 but does not take ownership of it.

In the signature of calculate_length, s: &String means that s is a reference to a String.

If we type cargo run -q, we get the expected output:

We are getting the same outut as before, but now we are not taking ownership of the string.

Here is a schema of what happens when we pass a reference to a function:

IMPORTANT: The action of passing a reference to a function is called Borrowing.

Mutable References

Can we change the value of a reference?

fn main(){
    let s = String::from("hello");
    change(&s);
    println!("{}", s);
}

fn change(s: &String){
    s.push_str(", world");
}

But here we get an error:

References are immutable by default.

But we can make them mutable by using &mut instead of &.

Of course, the value of the variable must be mutable as well.

//mutable references
fn main(){
    let mut s = String::from("hello");
    modify(&mut s);
    println!("{}", s);
}

fn modify(s: &mut String){
    s.push_str(" world");
}

Multiple Mutable References

Can we have multiple mutable references to the same variable?

fn main() {
    let mut s = String::from("hello");

    let s1 = &mut s;
    let s2 = &mut s;

    println!("{}, {}", s1, s2);
}

This code is not valid.

This should surprise you. In many programming languages, having multiple references to the same variable is not a problem. But this can lead to problems at runtime.

In Rust, the compiler prevents this from happening.

Of course, we can have multiple mutable references, but in different scopes.

fn main() {
    let mut s = String::from("hello");

    {
        let s1 = &mut s;
        s1.push_str(" world");
    }   //s1 goes out of scope here

    let s2 = &mut s;
    s2.push_str("!");

    println!("{}", s2);
}

This code is valid.

Mutable and Immutable References

Let's try to mix mutable and immutable references.

fn main() {
    let mut s = String::from("hello");

    let s1 = &s; //immutable borrow
    let s2 = &s; //immutable borrow

    let s3 = &mut s; //mutable borrow

    println!("{}, {}, {}", s1, s2, s3);
    //throws error: cannot borrow `s` as mutable because it is also borrowed as immutable
}

This code is not valid: we cannot have a mutable reference while we have immutable references.

But if we use the immutable references before the mutable reference, the code is valid.

fn main() {
    let mut s = String::from("hello");

    let s1 = &s; //immutable borrow
    let s2 = &s; //immutable borrow

    println!("{} and {}", s1, s2);

    let s3 = &mut s; //mutable borrow

    println!("{}", s3);
}

This code is valid because the immutable borrows are not used after the mutable borrow.

Dangling references

A Dangling reference is a reference that points to an invalid memory.

fn main() {
    let s  = dangle();
}

fn dangle() -> &String {
    let s = String::from("hello");
    &s
}

In this case, the reference &s is returned, but s goes out of scope at the end of the function.

To solve this problem, we can return the string directly.

fn main() {
    let s = no_dangle();
    println!("{}", s);
}

fn no_dangle() -> String {
    let s = String::from("hello");
    s
}

This code is valid.

References Rules

There are 2 main rules for references:

• At any given time, you can have either one mutable reference or any number of immutable references.

• References must always be valid.

Conclusion

In this article, we have seen how to use references in Rust.

We have seen how to pass references to functions, how to use mutable references, and the rules for using references.

If you prefer a video version

All the code is available on GitHub (link available in the video description)

You can find me here: Francesco