Cookin’ with Rust

This Rust Cookbook is a collection of simple examples that demonstrate good practices to accomplish common programming tasks, using the crates of the Rust ecosystem.

Read more about Rust Cookbook, including tips for how to read the book, how to use the examples, and notes on conventions.

Contributing

This project is intended to be easy for new Rust programmers to contribute to, and an easy way to get involved with the Rust community. It needs and welcomes help. For details see CONTRIBUTING.md.

Algorithms

Recipe	Crates	Categories
Generate random numbers
Generate random numbers within a range
Generate random numbers with given distribution
Generate random values of a custom type
Create random passwords from a set of alphanumeric characters
Create random passwords from a set of user-defined characters
Sort a Vector of Integers
Sort a Vector of Floats
Sort a Vector of Structs

Asynchronous

Recipe	Crates	Categories
Tokio Runtime
Tokio Runtime Builder
Create Files Operations
Read Files Operations
Write Files Operations
Remove Files Operations
AsyncRead and AsyncWrite traits
Bounded channels
Unbounded channels
First-to-complete
Task Timeouts
Join Sets

Command Line

Recipe	Crates	Categories
Parse command line arguments
ANSI Terminal

Compression

Recipe	Crates	Categories
Decompress a tarball
Compress a directory into a tarball
Decompress a tarball while removing a prefix from the paths

Concurrency

Recipe	Crates	Categories
Spawn a short-lived thread
Create a parallel data pipeline
Pass data between two threads
Maintain global mutable state
Calculate SHA1 sum of *.iso files concurrently
Draw fractal dispatching work to a thread pool
Mutate the elements of an array in parallel
Test in parallel if any or all elements of a collection match a given predicate
Search items using given predicate in parallel
Sort a vector in parallel
Map-reduce in parallel
Generate jpg thumbnails in parallel
Actor Pattern with Tokio
Custom Future (Pin, Waker, Poll)

Cryptography

Recipe	Crates	Categories
Calculate the SHA-256 digest of a file
Sign and verify a message with an HMAC digest
Salt and hash a password with PBKDF2

Data Structures

Recipe	Crates	Categories
Define and operate on a type represented as a bitfield
Count word frequency in a document
Group records by key
Look up records within a time range
Set operations with HashSet
Process tasks in priority order
Sliding-window buffer with VecDeque

Database

Recipe	Crates	Categories
Create a SQLite database
Insert and Query data
Create tables in a Postgres database
Insert and Query data
Aggregate data

Date and Time

Recipe	Crates	Categories
Measure elapsed time
Perform checked date and time calculations
Convert a local time to another timezone
Examine the date and time
Convert date to UNIX timestamp and vice versa
Display formatted date and time
Parse string into DateTime struct

Development Tools

Debugging

Recipe	Crates	Categories
Log a debug message to the console
Log an error message to the console
Log to stdout instead of stderr
Log messages with a custom logger
Log to the Unix syslog
Enable log levels per module
Use a custom environment variable to set up logging
Include timestamp in log messages
Log messages to a custom location

Versioning

Recipe	Crates	Categories
Parse and increment a version string
Parse a complex version string
Check if given version is pre-release
Find the latest version satisfying given range
Check external command version for compatibility

Build Time

Recipe	Crates	Categories
Compile and link statically to a bundled C library
Compile and link statically to a bundled C++ library
Compile a C library while setting custom defines

Encoding

Recipe	Crates	Categories
Percent-encode a string
Encode a string as application/x-www-form-urlencoded
Encode and decode hex
Encode and decode base64
Read CSV records
Read CSV records with different delimiter
Filter CSV records matching a predicate
Handle invalid CSV data with Serde
Serialize records to CSV
Serialize records to CSV using Serde
Transform one column of a CSV file
Serialize and deserialize unstructured JSON
Deserialize a TOML configuration file
Read and write integers in little-endian byte order

File System

Recipe	Crates	Categories
Read lines of strings from a file
Avoid writing and reading from a same file
Access a file randomly using a memory map
File names that have been modified in the last 24 hours
Find loops for a given path
Recursively find duplicate file names
Recursively find all files with given predicate
Traverse directories while skipping dotfiles
Recursively calculate file sizes at given depth
Find all png files recursively
Find all files with given pattern ignoring filename case

Hardware Support

Recipe	Crates	Categories
Check number of logical cpu cores

Memory Management

Recipe	Crates	Categories
Declare lazily evaluated constant
Std::cell
std::cell:LazyCell
std::sync::LazyLock

Networking

Recipe	Crates	Categories
Listen on unused port TCP/IP

Operating System

Recipe	Crates	Categories
Run an external command and process stdout
Run an external command passing it stdin and check for an error code
Run piped external commands
Redirect both stdout and stderr of child process to the same file
Continuously process child process’ outputs
Read environment variable

Science

science/mathematics

Recipe	Crates	Categories
Vector Norm
Adding matrices
Multiplying matrices
Multiply a scalar with a vector with a matrix
Invert matrix
Calculating the side length of a triangle
Verifying tan is equal to sin divided by cos
Distance between two points on the Earth
Creating complex numbers
Adding complex numbers
Mathematical functions on complex numbers
Measures of central tendency
Computing standard deviation
Big integers

Text Processing

Recipe	Crates	Categories
Collect Unicode Graphemes
Verify and extract login from an email address
Extract a list of unique #Hashtags from a text
Extract phone numbers from text
Filter a log file by matching multiple regular expressions
Replace all occurrences of one text pattern with another pattern.
Implement the FromStr trait for a custom struct

WebAssembly

wasmtime is an embeddable WebAssembly runtime. These recipes cover the host embedding API — loading modules, calling exports, sharing linear memory, and wiring up host-defined functions that guests can call back into.

The recipes live outside the main workspace because wasmtime is a large dependency not used elsewhere. Run them with cargo run --manifest-path crates/wasm/Cargo.toml --bin <name>.

Embedding wasmtime

Recipe	Crates	Categories
Call an exported WebAssembly function
Exchange data via WebAssembly linear memory
Define host functions for WebAssembly
Component Model — typed strings and structs

Web Programming

Scraping Web Pages

Recipe	Crates	Categories
Extract all links from a webpage HTML
Check webpage for broken links
Extract all unique links from a MediaWiki markup

Uniform Resource Locations (URL)

Recipe	Crates	Categories
Parse a URL from a string to a Url type
Create a base URL by removing path segments
Create new URLs from a base URL
Extract the URL origin (scheme / host / port)
Remove fragment identifiers and query pairs from a URL

Media Types (MIME)

Recipe	Crates	Categories
Get MIME type from string
Get MIME type from filename
Parse the MIME type of a HTTP response

Clients

Recipe	Crates	Categories
Make a HTTP GET request
Set custom headers and URL parameters for a REST request
Query the GitHub API
Check if an API resource exists
Create and delete Gist with GitHub API
Consume a paginated RESTful API
Download a file to a temporary directory
Make a partial download with HTTP range headers
POST a file to paste-rs

Web Authentication

Recipe	Crates	Categories
Basic Authentication

Full Stack Web

Recipe	Crates	Categories
Return filtered results as HTML
Synchronize component state with the server