Weekly Rust Trivia on Thorsten Hans

Weekly Rust Trivia: How to use pattern matching

Thu, 03 Aug 2023 13:00:00 +0200

Weekly Rust Trivia is a problem-oriented series of articles that assist developers while learning Rust. Every article solves simple, everyday development tasks using the Rust standard library or leveraging popular and proven crates.

Question: How to use pattern matching in Rust?

In Rust, pattern matching is a powerful language feature that allows you to destructure data and match it against specific patterns. It helps you handle different cases and extract values from complex data structures with concise and readable code. The match keyword is used to perform pattern matching. Inside a match block, you define patterns and corresponding code blocks for each pattern. When the input data matches a specific pattern, the corresponding code block will be executed.

Weekly Rust Trivia: How to share state between threads

Thu, 27 Jul 2023 13:00:00 +0200

Question: How to share state between threads in Rust?

In Rust, we have the ability to share data between threads by using smart pointers and synchronization primitives provided by the Rust standard library. The most popular ones are Arc (atomic reference counting) and Mutex (mutual exclusion). These allow multiple threads to access shared data in a safe and synchronized manner.

Weekly Rust Trivia: How to write a function-like macro

Thu, 20 Jul 2023 13:00:00 +0200

Weekly Rust Trivia is a problem-oriented series of articles that assists developers while learning Rust. Every article solves simple, everyday development tasks using the Rust standard library or leveraging popular and proven crates.

Question: How to implement a function-like macro in Rust?

Function-like macros in Rust are powerful tools that allow us to define macros that resemble function calls. They can take in arguments and generate code based on those arguments. Function-like macros are defined using the macro_rules! macro and a set of rules that define patterns and transformations. For demonstration purposes, we will define the factorial macro, which will generate code to calculate the factorial of a given number:

Weekly Rust Trivia: How to write an HTTP API with Actix

Thu, 13 Jul 2023 13:00:00 +0200

Question: How to write an HTTP API in Rust with Actix?

To create an HTTP API with Actix, we must add the actix-web crate to our project. We can add it using cargo add:

# Add actix-web as dependency
cargo add actix-web

At the time of writing, this adds actix-web in version 4.18.

Weekly Rust Trivia: How to Implement the Builder Pattern

Thu, 06 Jul 2023 13:00:00 +0200

Question: How to implement the builder pattern in Rust?

The derive_builder crate provides a macro which allows us to satisfy the builder pattern for our individual structs without writing custom code.

First, let’s add the dependency using cargo add:

Weekly Rust Trivia: How to Implement a Generic Stack

Thu, 29 Jun 2023 13:00:00 +0200

Question: How to implement a generic stack in Rust?

To implement a generic stack, we can simply create a custom struct wrapping a vector (Vec<T>):

struct Stack<T> {
    items: Vec<T>,
}

impl<T> Stack<T> {
    fn new() -> Self {
        Stack { items: Vec::new() }
    }

    fn push(&mut self, item: T) {
        self.items.push(item);
    }

    fn pop(&mut self) -> Option<T> {
        self.items.pop()
    }

    fn is_empty(&self) -> bool {
        self.items.is_empty()
    }

    fn size(&self) -> usize {
        self.items.len()
    }
}

The implementation (impl<T> Stack<T>) uses a generic type T to allow it to store any type of data. The Stack struct has five methods: new, push, pop, is_empty, and size:

Weekly Rust Trivia: How to Retrieve Image Dimensions

Thu, 22 Jun 2023 13:00:00 +0200

Question: How to retrieve the dimensions of an image in Rust?

The image crate provides the necessary functionality to work with images in Rust. We can combine functionality provided by the crate with the path module from Rust’s standard library to solve this trivia. We also use the anyhow crate to streamline error handling.

Weekly Rust Trivia: How to create a TCP Server

Thu, 15 Jun 2023 13:00:00 +0200

Question: How to create a TCP server in Rust?

We can use the io, net, and thread modules from the Rust standard library to solve this trivia.

use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};
use std::thread;

fn handle(mut stream: TcpStream) {
    // 64 KB buffer for demonstration purposes
    let mut buffer = [0; 65536];

    loop {
        let bytes_read = match stream.read(&mut buffer) {
            Ok(0) => return, // End of stream
            Ok(n) => n,
            Err(_) => return, // Error reading from stream
        };

        // Echo the data back to the client
        if stream.write_all(&buffer[..bytes_read]).is_err() {
            return; // Error writing to stream
        }
    }
}

The handle function takes in a TcpStream object representing a client connection.

Weekly Rust Trivia: How to Implement Binary Search

Thu, 08 Jun 2023 13:00:00 +0200

Question: How to implement binary search in Rust?

All we need to implement binary search in Rust is to bring the cmp module into scope. The cmp::Ordering enum and the cmp::Ord trait provide everything required to implement a generic binary search supporting all types implementing the Ord trait.

Weekly Rust Trivia: How to Read a CSV File

Thu, 01 Jun 2023 13:00:00 +0200

Question: How to read a .csv file in Rust?

The csv crate provides the necessary functionality to work with .csv files in Rust. We can combine functionality provided by the crate with the fs module from Rust’s standard library to solve this trivia. We also use the anyhow crate to streamline error handling.

Weekly Rust Trivia: How to Compute a SHA256 Hash of a File

Thu, 25 May 2023 13:00:00 +0200

Question: How to compute a SHA256 hash of a file in Rust?

The sha2 crate is an implementation of cryptographic hash algorithms that we can use to compute hashes. We can combine functionality provided by the crate with the fs and io modules from Rust’s standard library to solve this trivia. We also use the anyhow crate to streamline error handling.

Weekly Rust Trivia: How to Download an Image to a File

Thu, 18 May 2023 13:00:00 +0200

Question: How to download an image from the web and store it in a file using Rust?

The reqwest crate allows us to create HTTP requests with ease. We can combine functionality provided by the crate with the fs and io modules from Rust’s standard library to solve this trivia. We also use the anyhow crate to streamline error handling.

Weekly Rust Trivia: How to Get all Files in a Directory

Thu, 11 May 2023 13:00:00 +0200

Question: How to get a vector (Vec<String>) containing all filenames of a particular directory in Rust?

We can use the fs and io modules from the Rust standard library to solve this trivia.

use std::{fs, io};

fn get_files_in_directory(path: &str) -> io::Result<Vec<String>> {
    // Get a list of all entries in the folder
    let entries = fs::read_dir(path)?;

    // Extract the filenames from the directory entries and store them in a vector
    let file_names: Vec<String> = entries
        .filter_map(|entry| {
            let path = entry.ok()?.path();
            if path.is_file() {
                path.file_name()?.to_str().map(|s| s.to_owned())
            } else {
                None
            }
        })
        .collect();

    Ok(file_names)
}

In this example, we pass the path of the desired directory as an argument to the get_files_in_directory function. We then use the fs::read_dir() function to get a list of all entries in the directory, which returns a std::fs::ReadDir iterator. Every item of that iterator is an io::Result<DirEntry>. We use the filter_map() method together with ok()? to skip entries that could not be read, then check whether each entry is a file using the is_file() method of the std::path::Path struct. Note that is_file() follows symbolic links, so a symlink pointing to a file is also considered a file.