The Rust Programming Language

The Rust Programming Language Foreword Introduction

Getting started

• Getting Started

  • Installation
  • Hello, World!
  • Hello, Cargo!

• Programming a Guessing Game

• Common Programming Concepts

  • Variables and Mutability
  • Data Types
  • Functions
  • Comments
  • Control Flow

• Understanding Ownership

  • What is Ownership?
  • References and Borrowing
  • The Slice Type

• Using Structs to Structure Related Data

  • Defining and Instantiating Structs
  • An Example Program Using Structs
  • Method Syntax

• Enums and Pattern Matching

  • Defining an Enum
  • The match Control Flow Operator
  • Concise Control Flow with if let

Basic Rust Literacy

• Managing Growing Projects with Packages, Crates, and Modules

  • Packages and Crates
  • Defining Modules to Control Scope and Privacy
  • Paths for Referring to an Item in the Module Tree
  • Bringing Paths Into Scope with the use Keyword
  • Separating Modules into Different Files

• Common Collections

  • Storing Lists of Values with Vectors
  • Storing UTF-8 Encoded Text with Strings
  • Storing Keys with Associated Values in Hash Maps

• Error Handling

  • Unrecoverable Errors with panic!
  • Recoverable Errors with Result
  • To panic! or Not To panic!

• Generic Types, Traits, and Lifetimes

  • Generic Data Types
  • Traits: Defining Shared Behavior
  • Validating References with Lifetimes

• Writing Automated Tests

  • How to Write Tests
  • Controlling How Tests Are Run
  • Test Organization

• An I/O Project: Building a Command Line Program

  • Accepting Command Line Arguments
  • Reading a File
  • Refactoring to Improve Modularity and Error Handling
  • Developing the Library’s Functionality with Test Driven Development
  • Working with Environment Variables
  • Writing Error Messages to Standard Error Instead of Standard Output

Thinking in Rust

• Functional Language Features: Iterators and Closures

  • Closures: Anonymous Functions that Can Capture Their Environment
  • Processing a Series of Items with Iterators
  • Improving Our I/O Project
  • Comparing Performance: Loops vs. Iterators

• More about Cargo and Crates.io

  • Customizing Builds with Release Profiles
  • Publishing a Crate to Crates.io
  • Cargo Workspaces
  • Installing Binaries from Crates.io with cargo install
  • Extending Cargo with Custom Commands

• Smart Pointers

  • Using Box<T> to Point to Data on the Heap
  • Treating Smart Pointers Like Regular References with the Deref Trait
  • Running Code on Cleanup with the Drop Trait
  • Rc<T>, the Reference Counted Smart Pointer
  • RefCell<T> and the Interior Mutability Pattern
  • Reference Cycles Can Leak Memory

• Fearless Concurrency

  • Using Threads to Run Code Simultaneously
  • Using Message Passing to Transfer Data Between Threads
  • Shared-State Concurrency
  • Extensible Concurrency with the Sync and Send Traits

• Object Oriented Programming Features of Rust

  • Characteristics of Object-Oriented Languages
  • Using Trait Objects That Allow for Values of Different Types
  • Implementing an Object-Oriented Design Pattern

Advanced Topics

• Patterns and Matching

  • All the Places Patterns Can Be Used
  • Refutability: Whether a Pattern Might Fail to Match
  • Pattern Syntax

• Advanced Features

  • Unsafe Rust
  • Advanced Lifetimes
  • Advanced Traits
  • Advanced Types
  • Advanced Functions and Closures
  • Macros

• Final Project: Building a Multithreaded Web Server

  • Building a Single-Threaded Web Server
  • Turning Our Single-Threaded Server into a Multithreaded Server
  • Graceful Shutdown and Cleanup

• Appendix

  • A - Keywords
  • B - Operators and Symbols
  • C - Derivable Traits
  • D - Useful Development Tools
  • E - Editions
  • F - Translations of the Book
  • G - How Rust is Made and “Nightly Rust”