Beginning Rust: Get Started with Rust 2021 Edition

Table of Contents
About the Author
About the Technical Reviewer
Preface
	What You Need to Know
	How to Read This Book
	Where to Find the Source Code
	What This Book Does Not Cover
Chapter 1: Getting Started
	How to Start
	Hello, World!
	Printing Combinations of Literal Strings
	Printing Several Lines of Text
	Printing Integer Numbers
	Comments
Chapter 2: Doing Arithmetic and Writing More Code
	Adding Integer Numbers
	Other Operations Between Integer Numbers
	Floating-Point Arithmetic
	Sequences of Statements
	Breaking Literal Strings
Chapter 3: Naming Objects
	Associating Names to Values
	Mutable Variables
	Not Mutated Mutable Variables
	Uninitialized Variables
	The Leading Underscore
	Boolean Values
	Boolean Expressions
	Type Consistency in Assignments
	Type Inference
	Change of Type and of Mutability
	Compound Assignment Operators
	Using the Functions of the Standard Library
Chapter 4: Controlling Execution Flow
	Conditional Statements (if)
	Conditional Expressions
	Conditional Loops (while)
	Infinite Loops (loop)
	Counting Loops (for)
	Variables Scopes
Chapter 5: Using Data Sequences
	Arrays
	Rust Attributes
	Panicking
	Mutable Arrays
	Arrays of Explicitly Specified Size
	Multidimensional Arrays
	Vectors
	Other Operations on Vectors
	Empty Arrays and Vectors
	Debug Print
	Copying Arrays and Vectors
Chapter 6: Using Primitive Types
	Nondecimal Numeric Bases
	The Underscore in Numeric Literals
	The Exponential Notation
	The Various Kinds of Signed Integer Numbers
	Unsigned Integer Number Types
	Target-Dependent Integer-Number Types
	Type Inference
	The Type Inference Algorithm
	Floating-Point Numeric Types
	Explicit Conversions
	Type Suffixes of Numeric Literals
	All the Numeric Types
	Booleans and Characters
	The Empty Tuple
	Array and Vector Types
	Constants
	Discovering the Type of an Expression
Chapter 7: Enumerations and Matching
	Enumerations
	The match Construct
	Relational Operators and Enums
	Handling All the Cases
	Using match with Numbers
	Enumerations with Data
	match Statements with Variables in Patterns
	match Expressions
	Use of Guards in match Constructs
	if-let and while-let Constructs
Chapter 8: Using Heterogeneous Data Structures
	The Tuples
	The Structs
	The Tuple-Structs
	Lexical Conventions
Chapter 9: Defining Functions
	Defining and Invoking a Function
	Functions Defined After Their Use
	Functions Shadowing Other Functions
	Passing Arguments to a Function
	Passing Arguments by Value
	Returning a Value from a Function
	Early Exit
	Returning Several Values
	How to Change a Variable of the Caller
	Passing Arguments by Reference
	Using References
	Mutability of References
Chapter 10: Defining Generic Functions and Types
	Need of Generic Functions
	Defining and Using Generic Functions
	Inferring the Parametric Types
	Defining and Using Generic Structs
	Genericity Mechanics
	Generic Arrays and Vectors
	Generic Enums
	The Option Standard Enum
	The Result Standard Enum
	Enum Standard Utility Functions
Chapter 11: Allocating Memory
	The Various Kinds of Allocation
	Linear Addressing
	Static Allocation
	Stack Allocation
	Limitations of Stack Allocation
	Heap Allocation
	Heap Management
	The Behavior of Box
	Similarity with C and C++
	Boxing and Unboxing
	Register Allocation
Chapter 12: Data Implementation
	Discovering the Size of Objects
	The use Directive
	The Sizes of the Primitive Types
	The Representation of Primitive Types
	Location of Bytes in Memory
	Sizes of Composite Data Types
	Vector Allocation
Chapter 13: Defining Closures
	The Need for Disposable Functions
	Capturing the Environment
	Closures
	Closure Invocation Syntax
Chapter 14: Using Changeable Strings
	Static Strings
	Dynamic Strings
	Implementation of String
	Creating Dynamic Strings
	Converting Static Strings to Dynamic Strings
	Concatenating Strings
Chapter 15: Ranges and Slices
	The Ranges
	Motivation for Slices
	The Slices
	Slicing
	Out-of-Range Slicing
	Mutable Slicing
	Open-Ended Ranges and Slicing
	Inclusive Ranges
Chapter 16: Using Iterators
	String Characters
	Scanning a String
	Using String Iterators in for Loops
	The Rust Editions
	Iterators over Vectors, Arrays, and Slices
	Iterators Generating References
	Iterations without Mutation
	Iterations with Mutation
	Shorthand for Using Iterators in Loops
	Iterator Generators
	An Iterator Adapter: filter
	The map Iterator Adapter
	The enumerate Iterator Adapter
	An Iterator Consumer: any
	The all Iterator Consumer
	The count Iterator Consumer
	The sum Iterator Consumer
	The min and max Iterator Consumers
	The collect Consumer
	Iterator Chains
	Iterators Are “Lazy”
Chapter 17: Input/Output and Error Handling
	Command-Line Arguments
	Process Return Code
	Environment Variables
	Reading from the Console
	Proper Runtime Error Handling
	Writing to the Console
	Converting a Value to a String
	Converting a String to a Value
	File Input/Output
	Processing Text Files
Chapter 18: Data Encapsulation
	The Need for Methods
	Method Declarations
	The self and Self Keywords
	The mod and the pub Keywords
	The type Keyword
Chapter 19: Using Traits
	The Need for Traits
	Traits to the Rescue
	Generic Functions with No Parameter Bounds
	Scope of Traits
	Traits with Multiple Methods
	Generic Parameters with Multiple Bounds
	Trait Inheritance
	Adding Methods to External Types
	Standard Traits: Display and Debug
	Generic Traits
	Using Associated Types
	The Iterator Standard Trait
Chapter 20: Object-Oriented Programming
	Peculiarities of Rust Object-Orientation
	Destructors
	Operator Overloading
	Infallible Type Converters
	Fallible Type Converters
	Composition Instead of Inheritance
	Static Dispatch
	Dynamic Dispatch
	Implementation of Dynamic-Dispatch References
	Static vs. Dynamic Dispatch
Chapter 21: Standard Library Collections
	Collections
	Measuring Execution Time
	Performing Arbitrary Insertions and Removals
	Queues
	Linked Lists
	Binary Heaps
	Ordered Sets and Unordered Sets
	Ordered Dictionaries and Unordered Dictionaries
	Collections in C++ and in Rust
Chapter 22: Ownership, Moves, and Copies
	Deterministic Destruction
	Ownership
	Assignment Semantics
	Copying vs. Moving Performance
	Moving and Destroying Objects
	Need for Copy Semantics
	Cloning Objects
	Making Types Cloneable or Copyable
Chapter 23: Borrowing and Lifetimes
	Programming Errors when Using References
	Borrowing
	Object Lifetimes
	How to Prevent Use After Drop Errors
	How to Prevent Use After Change by an Alias Errors
	The Need for Lifetime Specifiers in Returned References
	Usage and Meaning of Lifetime Specifiers
	Checking the Validity of Lifetime Specifiers
	Using the Lifetime Specifiers of Invoked Functions
	Advantage of Using Several Lifetime Specifiers for a Function
Chapter 24: More About Lifetimes
	Lifetime Elision
	Lifetime Elision with Object-Oriented Programming
	The Need for Lifetime Specifiers in Structs Declarations
	Possible Lifetime Specifiers for Structs
	Lifetime Specifiers for Tuple-Structs and Enums
	Lifetime Specifiers for Mutable References
Index