Fundamentals Highlights Summary

Every highlight bullet from the 11 pages in this section, gathered on one page and grouped by the page it came from.

The Rust Design Philosophy

• Every distinctive piece of Rust syntax exists to give the compiler something concrete to check
• Explicit mut exists so the borrow checker has a fixed point to reason about
• No null and exhaustive match move failure handling into the type system, at compile time
• Compiler errors are the mechanism of the language, not friction around it

Rust Basics

• Bindings are immutable by default - use mut when you need to change a value
• Rust is expression-oriented: most blocks evaluate to a value
• Ownership prevents data races at compile time
• Pattern matching makes branching exhaustive and safe

Variables, Mutability & Shadowing

• Shadowing reuses a name with a new binding - handy for parsing pipelines
• Constants require a type annotation and must be compile-time evaluable
• mut mutates the binding, not deep interior data behind shared references

Scalar & Compound Types

• Integer overflow is checked in debug, wrapping in release unless you use explicit ops
• Array length is part of the type: [i32; 4] differs from [i32; 3]
• Tuples group heterogeneous values; access with .0, .1, or destructuring

Functions & Expressions

• Blocks { } are expressions - the last line without ; is the value
• Every function with a body returns a value, even () (unit)
• Closures are anonymous functions that capture their environment

Control Flow

• for loops iterate via IntoIterator - prefer them over manual index loops
• loop can return a value with break expr
• Labeled loops enable break 'outer from nested loops

Ownership Preview

• Each value has exactly one owner at a time
• Assignment moves non-Copy types, invalidating the source binding
• Borrowing with & and &mut uses data without taking ownership

References & Slices

• Slices are fat pointers: address plus length
• String slices &str point into UTF-8 data owned elsewhere
• Bounds checks prevent buffer overreads - use .get() to avoid panics

The Type System & Inference

• Types are checked at compile time - no runtime type errors on well-typed code
• Inference fills in types when unambiguous from context
• Type annotations guide inference at boundaries and in complex generics

Formatting & Printing

• {} uses Display for user-facing output; {:?} uses Debug for developers
• Implement Display for pretty printing; derive Debug for inspection
• format! builds String without printing to stdout

Rust Fundamentals Best Practices

• Prefer let without mut until mutation is required
• Use shadowing for parse/transform pipelines
• Annotate types at API boundaries, not every local
• Make the last expression the return value
• Take &str and &[T] when you only read data
• Return Result from fallible setup code in binaries