Rust From the Ground Up

The Rust CLI Programming book by Matthew Provost

New! Updated for the 2021 Edition of Rust and `clap` version 3

Rust is not just another programming language: it represents a new paradigm for building modern systems. Previous generations of languages are all based on early processor architectures and decade-old assumptions. Rust is a modern language built for modern architectures, bringing a new approach to building software: focusing on performance, reliability, and security from the ground up. Experienced programmers will recognize much of the syntax, but old patterns won’t translate to new solutions.

Rust provides a unique platform not only to master a new technology, but also to understand the new foundations of software for modern systems. Every chapter in Rust From the Ground Up takes a practical, “show, don’t tell” approach: examining the original BSD sources for a well-known Unix CLI program and introducing enough Rust to build a fully functional copy. This book flattens Rust's learning curve, demonstrating how to build powerful applications which handle realistic conditions such as edge cases and errors. After reading this book, you will have gained the confidence and intuition to understand Rust and the new approaches to modern software rooted in real world examples.

Security

Its ownership system makes Rust particularly well suited for replacing existing programs written in the C language, which is notorious for producing programs with bugs caused by its lack of memory safety. Apple, Microsoft, and Google have reported that at least 70% of the security vulnerabilities in their C/C++ codebases are caused by memory safety bugs.

Borrow Checker

The Rust compiler's borrow checker has a reputation as being difficult to work with. The borrow checker validates the ownership and lifetimes of values in memory at compile time, without a garbage collector. New Rust programmers often feel like they are "fighting the borrow checker" until they build intuition about how ownership works.

Ownership

Understanding ownership is hard, and sometimes the easiest way to get a Rust program to compile is by copying a value in memory, or using reference counting. This book tackles ownership head on, demonstrating clear strategies for resolving common issues with the borrow checker, enabling the reader to become productive and to write fully functional programs in Rust, without overwhelming them with more advanced concepts such as lifetimes.

Real World Code

The goal of this book is to teach a programmer with no Rust experience how to write production quality, idiomatic Rust code that safely handles real world edge cases and errors. There are no linked list exercises, made up examples (like FizzBuzz), demos (Mandelbrot), or sample code. Every chapter demonstrates how to write a real program by examining the original C source code for a classic BSD Unix CLI utility and incrementally building a fully functional version in Rust.

No C Required

Rust's syntax is designed to be familiar to programmers accustomed to languages such as C, C++, or Java, with curly braces {} around blocks of code, comments starting with // or surrounded by /* and */, and statements terminated with ;. But this book doesn't require specific experience in C programming; each chapter explains the syntax and functions used in the read-only C examples.

Idiomatic

Each chapter rewrites a C program in stylish, idiomatic Rust. Instead of mechanical, line by line translations, the book emphasizes a functional programming style, heavily focusing on iterators and avoiding mutable state. For example, rewriting the head program (which prints the first 10 lines from each filename argument):

#include <stdio.h> #include <stdlib.h> int main(int argc, char *argv[]) { FILE *fp; int ch; long cnt, linecnt = 10; for (argv++; *argv; ++argv) { if ((fp = fopen(*argv, "r")) != NULL) { for (cnt = linecnt; cnt && !feof(fp); --cnt) { while ((ch = getc(fp)) != EOF) { if (putchar(ch) == '\n') { break; } } } fclose(fp); } } }

use std::env::args; use std::fs::File; use std::io::{BufRead, BufReader}; fn main() { let args = args().skip(1); let files = args.map(|arg| { File::open(arg).map(BufReader::new).unwrap() }); let linecnt = 10; for file in files { for line in file.lines().take(linecnt).flatten() { println!("{}", line); } } }

Table of Contents

Checking the exit status of a process with the shell's $? variable
Defining a Rust function with the fn keyword
Installing the Rust toolchain with rustup
Verifying the version of Rust with the rustc compiler
Creating a new Rust project with cargo new
Building Rust programs with cargo build
Installing a linker with apt
Running a Rust program with cargo run
Formatting Rust source code with cargo fmt
Running a specific binary with cargo's --bin option
Representing signed and unsigned integer types
Specifying a function's return type with a right arrow "->"
Returning a value from a function with the return keyword
Representing an empty value with the unit type "()"
Representing fallible operations with the Result type
Separating namespace paths with "::"
Importing a function with a use declaration
Annotating the types of function parameters with ":"
Returning a status code with exit()
Representing the Never type with "!"
Linting Rust source code with clippy
Implicitly returning the unit type "()" from a function

Piping the output of one program to another with the shell's "|" operator
Outputting a line of text with the println! macro
Identifying macros with "!"
Looping infinitely with a loop expression
Building a specific program with cargo's --bin option
Constructing an Args struct with args()
Representing a group of fields as a struct
Declaring public visibility with the pub keyword
Representing a sequence of items with an iterator
Defining methods with the fn keyword
Receiving a method with the self keyword
Defining sets of methods with the trait keyword
Associating types with a trait
Representing optional values with the Option enum
Composing an Option enum of the Some and None variants
Enclosing generic types in angle brackets "<>"
Yielding the next item in an iterator with next()
Implementing a trait with the impl keyword
Yielding a heap-allocated String from the Args iterator
Returning an item at an index with nth()
Binding a value to a variable with a let statement
Terminating statements with ";"
Formatting output with format strings
Enclosing string literals in double quotes ""
Replacing placeholders "{}" in format strings
Mutably borrowing a value with &mut
Unwrapping an Option with unwrap()
Calling methods with "."
Automatically borrowing method receivers
Chaining method calls together
Terminating programs safely by panicking
Pattern matching with a match expression
Binding candidate patterns with a fat arrow "=>"
Automatically importing the prelude
Destructuring the target of a match arm
Returning errors from the writeln! macro
Obtaining a handle to stdout with stdout()
Generating code with a macro
Formatting function names in snake_case
Suppressing an expression's value with ";"
Creating a mutable variable binding with the mut keyword
Returning an unwrapped Option or a default value with unwrap_or()
Referencing a string elsewhere in memory with a string slice (&str)
Copying a static string to the heap with to_string()
Lazily computing a default value with unwrap_or_else()
Specifying a bounds on a generic parameter with a where clause
Creating an anonymous function with a closure expression
Composing a Result enum of the Ok and Err variants
Unwrapping the Ok value from a Result with unwrap()
Naming structs, enums, and variants in UpperCamelCase
Matching any value with the wildcard pattern "_"
Ignoring variable names prefixed with "_"
Implicitly borrowing the parameters to println! and writeln!
Determining the kind of error with kind()
Redirecting the output of a command with the shell's ">" operator

Defining a type alias for std::io::Result with the type keyword
Cheaply converting references with the AsRef trait's as_ref() method
Implementing AsRef converts a String to a Path
Importing a struct with use to access its associated functions
Binding the receiver of the current method to the self variable
Generating an alias to the type of a method's receiver with the Self keyword
Transforming the elements of an iterator with map()
Creating an unnamed, anonymous function with a closure expression
Processing iterators with for loops
Reading lines with the std::io::Lines iterator
Creating a Lines iterator with the BufRead traits's lines() method
Requiring a Sized type with a where clause
Creating a BufReader (implementing BufRead) with new()
Transforming an Ok Result with map()
Importing multiple paths in a single use declaration
Formatting strings with the Display trait
Iterating on a Result to yield the Ok value
Discarding the first n items from an iterator with the skip() iterator adaptor
Shadowing existing identifiers when declaring a variable with let
Replacing redundant closures with a function name
Conditionally binding a value with an if let expression
Removing one level of iteration with flatten()
Yielding up to n items from an iterator with take()
Closing files automatically with the Drop trait's drop() method
Transforming the Err value of a Result with map_err()
Capturing variables with closures
Printing to stderr with the eprintln! macro
Reducing an iterator to a single value with fold()
Returning the number of items in an ExactSizeIterator with len()
Obtaining a handle to standard input with stdin()
Reading a line from stdin with the Stdin struct's read_line() method
Creating an iterator yielding integers starting with one value up until a second with the range
operator (..)
Allocating an empty String with String::new()
Exiting a for loop with a break expression
Matching and removing a pattern from the start of a string with strip_prefix()
Tracking references to values with lifetimes
Converting a string to another type with parse()
Performing conversions by implementing the FromStr trait's from_str() method
Transforming an Option's Some value with map()
Mutably borrowing a value with &mut
Unwrapping an Option or a default value with unwrap_or()
Creating a Peekable iterator with peekable()
Peeking at the next item yielded from a Peekable iterator with peek()
Checking if an Option has Some value with is_some()

Folding an iterator into a single value
Reading bytes with the Read trait's bytes() iterator
Translating an escape sequence into a nonprinting character
Encoding characters as a single byte with a byte literal
Borrowing a String with the borrow operator
Specifying a minimum width for a format string placeholder
Defining a new function with the fn keyword
Accepting a variable number of parameters with a macro
Printing a blank line with the println! macro
Checking the size of the args() iterator with the ExactSizeIterator's len() method
Defining unique names for functions
Checking if a byte represents an ASCII whitespace character with is_ascii_whitespace()
Storing a fixed number of values in a tuple
Destructuring a tuple to bind its elements to local variables
Ignoring values with a "_" wildcard
Enclosing generic parameters in angle brackets "<>"
Constraining a generic parameter to a list of trait bounds
Monomorphizing a generic function for each parameter type
Mangling function names so they're unique
Examining compiled Rust executables with rust-gdb
Listing functions with gdb's info functions command
Extending the Rust standard library's functionality with crates
Adding a dependency for a crate to the project's Cargo.toml file
Creating a named clap App with new()
Converting types with the Into and From traits
Allocating a String from a &str with from()
Constructing a clap argument with Arg::new()
Automatic reflexive conversions with the Into trait
Implementing a fluent interface with methods that return Self
Incrementally constructing complex structs following the "builder" pattern
Chaining methods to create and configure a struct in a single expression
Parsing the command line arguments into an ArgMatches struct with get_matches()
Iterating over the values of an argument with values_of()
Binding an argument to an option letter with short()
Escaping a character literal in single quotes
Adding a description to an argument with help()
Converting any type into Some with from()
Declaring global variables with the static keyword
Specifying the return type of a function with a right arrow "->"
Evaluating a function's body to return a value
Checking for the presence of an argument with is_present()
Assigning multiple variables by destructuring a tuple
Matching on a tuple
Enabling an Arg to accept multiple values with multiple_values()
Automatically deallocating values with drop()
Verifying that the program closes files with strace
Buffering input with a BufReader
Creating a buffer with a specific capacity using with_capacity()
Reading from Stdin without a lock()
Compiling Rust programs in "release" mode
Inlining to eliminate the overhead of generic functions