<!-- Copyright 2022 Google LLC SPDX-License-Identifier: CC-BY-4.0 --> <!-- Keep first page as index.md to avoid giving it two names. -->

Welcome to Comprehensive Rust 🦀

• Running the Course
  • Course Structure
  • Keyboard Shortcuts
  • Translations
• Using Cargo
  • Rust Ecosystem
  • Code Samples
  • Running Cargo Locally

---

Day 1: Morning

• Welcome
• Hello, World
  • What is Rust?
  • Benefits of Rust
  • Playground
• Types and Values
  • Hello, World
  • Variables
  • Values
  • Arithmetic
  • Type Inference
  • Exercise: Fibonacci
    • Solution
• Control Flow Basics
  • Blocks and Scopes
  • if Expressions
  • match Expressions
  • Loops
    • for
    • loop
  • break and continue
    • Labels
  • Functions
  • Macros
  • Exercise: Collatz Sequence
    • Solution

Day 1: Afternoon

• Welcome
• Tuples and Arrays
  • Arrays
  • Tuples
  • Array Iteration
  • Patterns and Destructuring
  • Exercise: Nested Arrays
    • Solution
• References
  • Shared References
  • Exclusive References
  • Slices
  • Strings
  • Reference Validity
  • Exercise: Geometry
    • Solution
• User-Defined Types
  • Named Structs
  • Tuple Structs
  • Enums
  • Type Aliases
  • Const
  • Static
  • Exercise: Elevator Events
    • Solution

---

Day 2: Morning

• Welcome
• Pattern Matching
  • Irrefutable Patterns
  • Matching Values
  • Destructuring Structs
  • Destructuring Enums
  • Let Control Flow
    • if let Expressions
    • while let Statements
    • let else
  • Exercise: Expression Evaluation
    • Solution
• Methods and Traits
  • Methods
  • Traits
    • Implementing Traits
    • Supertraits
    • Associated Types
  • Deriving
  • Exercise: Generic Logger
    • Solution
• Generics
  • Generic Functions
  • Trait Bounds
  • Generic Data Types
  • Generic Traits
  • impl Trait
  • dyn Trait
  • Exercise: Generic min
    • Solution

Day 2: Afternoon

• Welcome
• Closures
  • Closure Syntax
  • Capturing
  • Closure Traits
  • Exercise: Log Filter
    • Solution
• Standard Library Types
  • Standard Library
  • Documentation
  • Option
  • Result
  • String
  • Vec
  • HashMap
  • Exercise: Counter
    • Solution
• Standard Library Traits
  • Comparisons
  • Operators
  • From and Into
  • Casting
  • Read and Write
  • Default, struct update syntax
  • Exercise: ROT13
    • Solution

---

Day 3: Morning

• Welcome
• Memory Management
  • Review of Program Memory
  • Approaches to Memory Management
  • Ownership
  • Move Semantics
  • Clone
  • Copy Types
  • Drop
  • Exercise: Builder Type
    • Solution
• Smart Pointers
  • Box<T>
  • Rc
  • Owned Trait Objects
  • Exercise: Binary Tree
    • Solution

Day 3: Afternoon

• Welcome
• Borrowing
  • Borrowing a Value
  • Borrow Checking
  • Borrow Errors
  • Interior Mutability
    • Cell
    • RefCell
  • Exercise: Wizard's Inventory
    • Solution
• Lifetimes
  • Borrowing and Functions
  • Returning Borrows
  • Multiple Borrows
  • Borrow Both
  • Borrow One
  • Lifetime Elision
  • Lifetimes in Data Structures
  • Exercise: Protobuf Parsing
    • Solution

---

Day 4: Morning

• Welcome
• Iterators
  • Motivation
  • Iterator Trait
  • Iterator Helper Methods
  • collect
  • IntoIterator
  • Exercise: Iterator Method Chaining
    • Solution
• Modules
  • Modules
  • Filesystem Hierarchy
  • Visibility
  • Encapsulation
  • use, super, self
  • Exercise: Modules for a GUI Library
    • Solution
• Testing
  • Unit Tests
  • Other Types of Tests
  • Compiler Lints and Clippy
  • Exercise: Luhn Algorithm
    • Solution

Day 4: Afternoon

• Welcome
• Error Handling
  • Panics
  • Result
  • Try Operator
  • Try Conversions
  • Error Trait
  • thiserror
  • anyhow
  • Exercise: Rewriting with Result
    • Solution
• Unsafe Rust
  • Unsafe
  • Dereferencing Raw Pointers
  • Mutable Static Variables
  • Unions
  • Unsafe Functions
    • Unsafe Rust Functions
    • Unsafe External Functions
    • Calling Unsafe Functions
  • Unsafe Traits
  • Exercise: FFI Wrapper
    • Solution

---

Android

• Welcome
• Setup
• Build Rules
  • Binary
  • Library
• AIDL
  • Birthday Service Tutorial
    • Interface
    • Service API
    • Service
    • Server
    • Deploy
    • Client
    • Changing API
    • Updating Implementations
  • AIDL Types
    • Primitive Types
    • Array Types
    • Sending Objects
    • Parcelables
    • Sending Files
• Testing
  • GoogleTest
  • Mocking
• Logging
• Interoperability
  • With C
    • A Simple C Library
    • Bindgen
    • Running Our Binary
    • A Simple Rust Library
    • Calling Rust from C
  • With C++
    • The Bridge Module
    • Rust Bridge
    • Generated C++
    • C++ Bridge
    • Shared Types
    • Shared Enums
    • Rust Error Handling
    • C++ Error Handling
    • Additional Types
    • Building for Android: Genrules
    • Building for Android: C++
    • Building for Android: Rust
  • With Java

---

Chromium

• Welcome
• Setup
• Comparing Chromium and Cargo Ecosystems
• Policy
• Build Rules
  • Unsafe Code
  • Depending on Rust Code from Chromium C++
  • Visual Studio Code
  • Exercise
• Testing
  • rust_gtest_interop Library
  • GN Rules for Rust Tests
  • chromium::import! Macro
  • Exercise
• Interoperability with C++
  • Example Bindings
  • Limitations of CXX
  • CXX Error Handling
    • Error Handling: QR Example
    • Error Handling: PNG Example
  • Using CXX in Chromium
  • Exercise
• Adding Third Party Crates
  • Configuring Cargo.toml
  • Configuring gnrt_config.toml
  • Downloading Crates
  • Generating gn Build Rules
  • Resolving Problems
    • Build Scripts Which Generate Code
    • Build Scripts Which Build C++ or Take Arbitrary Actions
  • Depending on a Crate
  • Reviews and Audits
  • Checking into Chromium Source Code
  • Keeping Crates Up to Date
  • Exercise
• Bringing It Together - Exercise
• Exercise Solutions

---

Bare Metal: Morning

• Welcome
• no_std
  • A Minimal Example
  • alloc
• Microcontrollers
  • Raw MMIO
  • PACs
  • HAL Crates
  • Board Support Crates
  • The Type State Pattern
  • embedded-hal
  • probe-rs and cargo-embed
    • Debugging
  • Other Projects
• Exercises
  • Compass
  • Solutions

Bare Metal: Afternoon

• Application Processors
  • Getting Ready to Rust
  • Inline Assembly
  • MMIO
  • Let's Write a UART Driver
    • More Traits
    • Using It
  • A Better UART Driver
    • Bitflags
    • Multiple Registers
    • Driver
  • safe-mmio
    • Driver
    • Using It
  • Logging
    • Using It
  • Exceptions
  • aarch64-rt
    • Exceptions
  • Other Projects
• Useful Crates
  • zerocopy
  • aarch64-paging
  • buddy_system_allocator
  • tinyvec
  • spin
• Bare-Metal on Android
  • vmbase
• Exercises
  • RTC Driver
  • Solutions

---

Concurrency: Morning

• Welcome
• Threads
  • Plain Threads
  • Scoped Threads
• Channels
  • Senders and Receivers
  • Unbounded Channels
  • Bounded Channels
• Send and Sync
  • Marker Traits
  • Send
  • Sync
  • Examples
• Shared State
  • Arc
  • Mutex
  • Example
• Exercises
  • Dining Philosophers
  • Multi-threaded Link Checker
  • Solutions

Concurrency: Afternoon

• Welcome
• Async Basics
  • async/await
  • Futures
  • State Machine
  • Runtimes
    • Tokio
  • Tasks
• Channels and Control Flow
  • Async Channels
  • Join
  • Select
• Pitfalls
  • Blocking the Executor
  • Pin
  • Async Traits
  • Cancellation
• Exercises
  • Dining Philosophers
  • Broadcast Chat Application
  • Solutions

---

Idiomatic Rust

• Welcome
• Foundations of API Design
  • Meaningful Doc Comments
    • Who Are You Writing For?
    • Library vs Application docs
    • Anatomy of a Doc Comment
    • Name Drop and Signpost
    • Avoid Redundancy
    • Name and Signature are Not Enough
    • What and Why, not How and Where
    • Exercise
  • Predictable API
    • Naming conventions
      • New
      • Get
      • Push
      • Is
      • Mut
      • With: Constructor
      • With: Copy-and-change
      • With: Closures
      • With in normal use
      • Try
      • From
      • Into
      • Into inner
      • By
      • Unchecked
      • To
      • As and Ref
      • Raw parts
      • Exercise
    • Implementing Common Traits
      • Debug
      • PartialEq and Eq
      • PartialOrd and Ord
      • Hash
      • Clone
      • Copy
      • Serialize and Deserialize
      • From and Into
      • TryFrom and TryInto
      • Display
• Leveraging the Type System
  • Newtype Pattern
    • Semantic Confusion
    • Parse, Don't Validate
    • Is It Encapsulated?
  • RAII
    • Drop Skipped
    • Mutex
    • Drop Guards
    • Drop Bomb
    • Drop Bomb Forget
    • forget and drop functions
    • Scope Guard
    • Drop Option
  • Extension Traits
    • Extending Foreign Types
    • Method Resolution Conflicts
    • Trait Method Conflicts
    • Extending Other Traits
    • Should I Define An Extension Trait?
  • Typestate Pattern
    • Typestate Pattern Example
    • Beyond Simple Typestate
    • Typestate Pattern with Generics
      • Serializer: implement Root
      • Serializer: implement Struct
      • Serializer: implement Property
      • Serializer: Complete implementation
  • Borrow checking invariants
    • Lifetimes and Borrows: the Abstract Rules
    • Single-use values
    • Mutually Exclusive References / "Aliasing XOR Mutability"
    • PhantomData and Types
    • PhantomData and Types (implementation)
    • PhantomData: Lifetimes for External Resources
    • PhantomData: OwnedFd & BorrowedFd
  • Token Types
    • Permission Tokens
    • Token Types with Data: Mutex Guards
    • Branded pt 1: Variable-specific tokens
    • Branded pt 2: PhantomData and Lifetime Subtyping
    • Branded pt 3: Implementation
    • Branded pt 4: Branded types in action.
• Polymorphism
  • Refresher
    • Traits
    • Trait Bounds
    • Deriving Traits
    • Default Implementations
    • Supertraits
    • Blanket Implementations
    • Conditional Methods
    • Orphan Rule
    • Statically Sized and Dynamically Sized types
    • Monomorphization and Binary Size
  • From OOP to Rust
    • Inheritance
    • Why no Inheritance in Rust?
    • Inheritance from Rust's Perspective
    • "Inheritance" in Rust and Supertraits
    • Composition over Inheritance
    • Trait Objects and Dynamic Dispatch
    • Dyn Compatibility
    • Generics vs Trait Objects
    • Limits of Trait Objects
    • Heterogeneous Collections
    • The Any Trait
    • Pitfall: Reaching too quickly for dyn Trait
    • Sealed Traits
    • Sealing with Enums
    • Traits for Polymorphism users can extend
    • Problem solving: Break Down the Problem

---

Unsafe

• Welcome
• Setup
• Introduction
  • Defining Unsafe Rust
  • Purpose of the unsafe keyword
  • Two roles of the unsafe keyword
  • Warm Up Examples
    • Using an unsafe block
    • Defining an unsafe function
    • Implementing an unsafe trait
    • Defining an unsafe trait
  • Characteristics of Unsafe Rust
    • Dangerous
    • Sometimes necessary
    • Sometimes useful
  • Responsibility shift
  • Stronger development workflow required
  • Example: may_overflow
• Safety Preconditions
  • Common Preconditions
    • Getter example
  • Semantic preconditions
    • Example: u8 to bool
  • Determining preconditions
    • Example: references
  • Defining your own preconditions
    • Example: ASCII Type
• Rules of the game
  • Rust is sound
  • Copying memory
    • Safe Rust
    • Encapsulated Unsafe Rust
    • Exposed Unsafe Rust
    • Documented safety preconditions
    • Crying Wolf
  • 3 shapes of sound Rust
  • Soundness Proof
    • Soundness
    • Corollary
    • Unsoundness
• Memory Lifecycle
• Initialization
  • MaybeUninit<T>
    • Arrays of uninit
    • MaybeUninit::zeroed()
    • ptr::write vs assignment
  • How to initialize memory
  • Partial initialization
• Pinning
  • What pinning is
  • What a move is
  • Definition of Pin<Ptr>
  • Why it's difficult
  • Unpin trait
  • PhantomPinned
  • Self-Referential Buffer Example
    • C++ implementation
    • Modeled in Rust
      • With a raw pointer
      • With an integer offset
      • With Pin<Ptr>
  • Pin<Ptr> and Drop
    • Worked Example
• FFI
  • Language Interop
  • Strategies
  • Consideration: Type Safety
  • Language differences
    • Different representations
    • Different semantics
    • Rust ↔ C
    • C++ ↔ C
    • Rust ↔ C++
  • abs(3)
  • rand(3)
  • Exercise:C library
  • Exercise: C++ library

---

Final Words

• Thanks!
• Glossary
• Other Resources
• Credits