book/second-edition/src/SUMMARY.md

The Rust Programming Language

Getting started

• Introduction

  • Installation
  • Hello, World!

• Guessing Game Tutorial

• Common Programming Concepts

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

• Understanding Ownership

  • What is Ownership?
  • References & Borrowing
  • Slices

• 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

• Modules

  • mod and the Filesystem
  • Controlling Visibility with pub
  • Importing Names with use

• Common Collections

  • Vectors
  • Strings
  • 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

• Testing

  • Writing tests
  • Running tests
  • Test Organization

• An I/O Project

  • Accepting Command Line Arguments
  • Reading a File
  • Improving Error Handling and Modularity
  • Testing the Library's Functionality
  • Working with Environment Variables
  • Writing to stderr instead of stdout

Thinking in Rust

• Functional Language Features in Rust

  • Closures
  • Iterators
  • Improving our I/O Project
  • Performance

• More about Cargo and Crates.io

  • 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

  • Box<T> Points to Data on the Heap and Has a Known Size
  • The Deref Trait Allows Access to the Data Through a Reference
  • The Drop Trait Runs Code on Cleanup
  • Rc<T>, the Reference Counted Smart Pointer
  • RefCell<T> and the Interior Mutability Pattern
  • Creating Reference Cycles and Leaking Memory is Safe

• Fearless Concurrency

  • Threads
  • Message Passing
  • Shared State
  • Extensible Concurrency: Sync and Send

• Is Rust an Object-Oriented Programming Language?

  • What Does Object-Oriented Mean?
  • Trait Objects for Using Values of Different Types
  • Object-Oriented Design Pattern Implementations

Advanced Topics

• Patterns Match the Structure of Values

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

• Advanced Features

  • Unsafe Rust
  • Advanced Lifetimes
  • Advanced Traits
  • Advanced Types
  • Advanced Functions & Closures

• Final Project: Building a Multithreaded Web Server

  • A Single Threaded Web Server
  • How Slow Requests Affect Throughput
  • Designing the Thread Pool Interface
  • Creating the Thread Pool and Storing Threads
  • Sending Requests to Threads Via Channels
  • Graceful Shutdown and Cleanup

• Appendix

  • A - Keywords
  • B - Operators
  • C - Derivable Traits
  • D - Nightly Rust
  • E - Macros
  • F - Translations
  • G - Newest Features