The Rust Programming Language

Rust incorporates functional programming techniques that allow functions to be treated as values. This includes passing functions as arguments, returning them from other functions, and assigning them to variables for later execution. The primary functional features in Rust are:

• Closures: Function-like constructs that can be stored in variables.
• Iterators: A mechanism for processing a series of elements.

Mastering these features is essential for writing idiomatic and high-performance Rust code.

The Rust learning path is divided into three main stages:

1. Getting started: Covers installation, basic syntax (variables, data types, functions), ownership, structs, and enums.
2. Basic Rust Literacy: Focuses on modules, collections (vectors, strings, hash maps), error handling, generics, traits, lifetimes, and testing.
3. Thinking in Rust: Covers advanced concepts like functional features (iterators, closures), smart pointers, concurrency, and object-oriented patterns.

For complete mastery, the curriculum also includes advanced topics like Unsafe Rust and building a multithreaded web server.

Rust provides a suite of contemporary developer tools designed to bring productivity to systems programming. Key tools include:

• Cargo: The official dependency manager and build tool. It handles adding, compiling, and managing dependencies consistently across the ecosystem.
• rustfmt: A formatting tool that ensures a consistent coding style across different developers and projects.
• Rust Language Server: Powers IDE integration, providing features like code completion and inline error messages.

Rust's compiler acts as a gatekeeper, preventing common low-level and concurrency bugs from compiling, allowing developers to focus on program logic.

Rust is a systems programming language designed to provide high-level ergonomics alongside low-level control. It aims to eliminate the traditional trade-offs between safety and productivity, speed and ergonomics. Key features include:

• Memory Safety: The compiler acts as a gatekeeper, preventing common bugs like concurrency issues and memory mismanagement.
• Zero-Cost Abstractions: Higher-level features are designed to compile into machine code that is as efficient as manually written low-level code.
• Developer Tooling: The ecosystem includes built-in tools to maintain productivity and consistency.

Rust is suitable for teams of developers, students learning systems concepts, companies building production services (web, embedded, CLI, etc.), and open-source contributors.

Enums (enumerations) allow you to define a type by enumerating its possible variants. They are used to encode meaning along with data. This chapter covers:

• Defining Enums: Creating a type that can be one of several distinct variants.
• The Option Enum: A specialized enum used to express that a value can either be Some(T) (containing a value) or None (representing nothing).
• Pattern Matching with match: Using the match expression to execute different code paths based on which enum variant a value holds.
• The if let Construct: A concise idiom for handling enums when you only care about one specific variant.

The Rust Programming Language book is available in two versions.

• Second edition: This is a complete rewrite and is the recommended version for learning most of Rust. Note that it is still under construction.
• First edition: Use this version to pick up more esoteric parts of the language after you have finished the second edition.

It is suggested to start with the second edition and refer back to the first edition later for advanced or niche topics.

Enums (enumerations) allow you to define a type by enumerating its possible variants. They are used to encode meaning along with data. This chapter covers:

• Defining Enums: Creating types that represent one of several possible variants.
• The Option Enum: A specialized enum used to express that a value can be either Some(T) (containing a value) or None (representing nothing).
• Pattern Matching with match: Using the match expression to execute different code blocks based on which enum variant a value holds.
• The if let Construct: A concise idiom for handling specific enum variants when you only care about one case.

The trpl crate is a convenience dependency designed for readers of The Rust Programming Language book. Instead of managing multiple individual dependencies and import sets, you can add trpl to your Cargo.toml.

It serves two primary purposes:

1. Simplified Dependency Management: It re-exports various crates used throughout the book, allowing you to use a single dependency and a unified set of imports.
2. Stability: It acts as a buffer against upstream breaking changes. Because the crate contents are controlled, your book-related code remains functional even if the underlying libraries (like tokio) release breaking updates.

[dependencies]
trpl = "..."

The mdbook_trpl package provides specialized mdbook preprocessors used for rendering content in The Rust Programming Language book. These preprocessors allow for advanced formatting of notes and code listings within your mdBook project.

To use these, you must have the preprocessor binaries available in your path and configured in your book.toml file according to the mdBook preprocessor documentation.

Available preprocessor binaries:
- `mdbook-trpl-note`
- `mdbook-trpl-listing`

Unsafe Rust is a subset of the language that allows you to perform operations that the Rust compiler cannot statically verify as memory-safe. It is used when the compiler's conservative analysis rejects valid programs or when performing low-level systems programming (e.g., interacting with hardware or the OS).

Key Characteristics:

• unsafe does not disable the borrow checker or other safety checks; references used within an unsafe block are still checked.
• It provides access to five specific "superpowers" that are not available in safe Rust.
• The programmer assumes responsibility for upholding memory safety invariants.

Best Practices:

• Keep unsafe blocks as small as possible to isolate potential memory bugs.
• Enclose unsafe code within a safe abstraction that provides a safe API to users, preventing unsafe usage from leaking into the rest of the codebase.