Error Handling | Learn to Code with Rust

Book Overview & Buying
Table Of Contents

Learn to Code with Rust

By : Boris Paskhaver

5 (1)

Buy this Video

Learn to Code with Rust

5 (1)

By: Boris Paskhaver

Buy this Video

Overview of this book

This course provides a comprehensive journey for mastering Rust, catering to both beginners and intermediate learners. It starts with guiding you through the setup process for macOS and Windows, ensuring you have the essential tools like Visual Studio Code, Cargo, and the Rust compiler installed. After laying a solid foundation, you'll dive into Rust's core concepts, including variables, data types, functions, and control flow. As you progress, you'll gain expertise in Rust's unique features like ownership, borrowing, and references, ensuring memory safety without a garbage collector. The course covers more advanced topics such as structs, enums, and generics, empowering you to write modular, reusable code. You'll also explore Rust's standard library, along with tools like the rand crate for randomness and Chrono for date-time handling. With practical projects and real-world examples, you'll develop confidence in using Rust to tackle real problems. The course concludes by focusing on error handling, testing, and code optimization. You'll master Rust’s error handling, implement unit and integration tests, and learn to optimize your code, preparing you for building everything from simple utilities to complex systems.

Getting Started

Intro to Rust

The Rust Compiler

[macOS] Intro to Terminal

[macOS] Installing XCode Command Line Tools

[macOS] Installing Rust

[macOS] Installing Visual Studio Code

[macOS] Add VSCode to PATH

[Windows] Intro to PowerShell

[Windows] Find Out Your Windows Operating System

[Windows] Installing Visual Studio

[Windows] Installing Rust

[Windows] Installing Visual Studio Code

Updating or Uninstalling Rust with rustup

Create Rust Project with Cargo

Hello World

Compiling and Running Rust File from the Terminal

Formatting with rustfmt and cargo fmt

The cargo build Command

The cargo run Command

The cargo check Command

Comments

Project Solution

Section Review

Variables and Mutability

Intro to Variables

Interpolation with Curly Braces

Positional Arguments to println!

Underscore with Variables

Immutable and Mutable Variables

Rust Error Codes Index

Variable Shadowing

Scopes

Constants

Type Aliases

Compiler Directives

Project Solution

Section Review

Data Types

Intro to Data Types

Integers

Using _ as Visual Separator for Numbers

The usize and isize Types

Strings and Raw Strings

Intro to Methods

Floating Point Types

Formatting Floats with Format Specifier

Casting Types with the as Keyword

Math Operations

Augmented Assignment Operator

Intro to Booleans

Boolean Inversion with !

Equality and Inequality Operators

And Logic with &&

Or Logic with

The Character Type

The Array Type

Reading and Writing Array Elements

The Display Trait

The Debug Trait

The dbg! Macro

The Tuple Type

Ranges and Range Iteration

Intro to Generics

Project Solution

Section Review

Functions

Intro to Functions

Parameters and Arguments

Explicit Return Values

Implicit Return Values

The Unit as a Return Type

Blocks in Functions

Project Solution

Section Review

Control Flow

The if Statement

The else if Statement

The else Statement

Assigning Result of if Statement to Variable

The match Statement

Underscore in a Match Arm

The match Statement with Multiple Values and Conditionals

The loop and break Keywords

The continue Keyword

While Loop

Recursion

Project Solution

Section Review

Ownership

Intro to Ownership

The Stack and Heap

Scope and Ownership

The Copy Trait

The String Type

The push_str Method on a String Type

Moves and Ownership

The drop Function

The clone Method

References and Borrowing

The Dereference Operator

String, &String, str, and &str

The Copy Trait with References

Ownership and Function Parameters

Mutable Parameters

Return Values I

Return Values II

Project Solution

Section Review

References and Borrowing

Immutable and Mutable Reference Parameters

Multiple Immutable References

Mutable Reference Restrictions

Ownership with Immutable and Mutable References

Dangling References

Ownership with Arrays and Tuples

Project Solution

Section Review

Slices

Intro to Slices

Create a String Slice from a String

String Slices and String Literals

String Slice Lengths

Syntactic Shortcuts

String Slices as Function Parameters

Array Slices

Deref Coercion with Array Slices

Mutable Array Slices

Project Solution

Section Review

Structs

Define a Struct

Create a Struct Instance

Access Struct Fields

Overwrite Struct Fields

Create Structs in a Function

Struct Field Initialization Shorthand Syntax

Struct Update Syntax

Passing Structs into a Function

Deriving Debug Trait for Struct

Defining Struct Methods

self Parameter as Mutable Struct Instance

self Parameter as Immutable and Mutable References to Struct Instance

Methods with Multiple Parameters

Calling Methods from Other Methods

Associated Functions

Multiple impl Blocks

Builder Pattern

Tuple Structs

Unit-Like Structs

Project Solution

Section Review

Enums

Intro to Enums

Enum with Associated Values I

Enum with Associated Values II

A Brief Discussion on Enum Memory

Struct Variants

Nesting Enums in Enums

The match Keyword I

The match Keyword II

The match Keyword III

Defining Methods on Enums

The match Keyword IV - Catching Multiple Values

The match Keyword V - match with Exact Value

The if let Construct

The let else Construct

Project Solution

Section Review

Generics

Intro to Generics

The Turbofish Operator

Multiple Generics

Generics in Structs

Generics and impl Blocks I

Generics and impl Blocks II

Generics in Enums

Project Solution

Section Review

Option and Result Enums

The Option Enum

Real Example of Option Enum (The get Method on an Array)

The unwrap and expect Methods

The match Keyword with Option Enum

Returning an Option Enum from a Function

Top-Level Option Variants

The unwrap_or Method

Building Option from Scratch

The Result Enum

Real Example of Result Enum (The parse Method on a String)

Returning a Result Enum from a Function

Result Methods

Nuances of unwrap Method on Result

Project Solution

Section Review

Vectors

Create a Vector

Adding and Removing Elements

Reading Vector Elements

The get Method

Ownership with Vectors

Writing Vector Elements

Vector Capacity Behind the Scenes

Project Solution

Section Review

Project Structure

Packages and Crates

Intro to Modules

The pub Keyword

The Benefit of Namespaces

Module as File

Module as Folder

Module Ambiguity

Public Enums, Public Structs, and Public Fields

Submodules

The crate Prefix

The use Keyword I

The use Keyword II (Name Conflicts)

The self Keyword

The super Keyword

Create Aliases with the as Keyword

Using pub use to Export Names from Submodules

External Crates

The Standard Library

The Glob Operator

Create Library Crate

Multiple Binary Crates

Documentation Comments

Walking Through Sample Module Structure

Project Solution

Section Review

Strings

Review of Strings

Concatenation

The format! Macro

Common String Methods (trim, casing, replace, split)

Collecting User Input with read_line Method

Project Solution

Section Review

HashMaps

Create a HashMap with new Function

The remove Method

HashMaps and Ownership

Access a Value by Key

Overwriting a Value with an Existing Key

The entry Method

The HashSet

HashSet Operations

Project Solution

Section Review

Error Handling

The panic! Macro

The process Module and the exit Function

Standard Error (eprintln! Macro)

Opening a File

Asking the User for Input

Reading the File's Contents

Propagating Errors

Understanding Error Type Redeclaration

The ? Operator

The read_to_string Associated Function

Using ? with Option

Project Solution

Section Review

Traits

Intro to Traits

Defining a Trait

Implementing Trait for Struct I

Implementing Trait for Struct II

Default Implementations

Calling Trait Method from Another Method

Traits for Function Parameter Constraints

Trait Bound Syntax

Multiple Trait Bounds

where Clauses

Traits as Function Return Values

Trait Bounds to Conditionally Implement Methods

A Preview of Trait Objects

Trait Must be In Scope to Use its Definitions

Moving to Project Structure I

Moving to Project Structure II (Multiple Modules)

Associated Constants in a Trait

Getters in Traits

Setters in Traits

Supertraits I (Trait Inheritance)

Traits with Generics

Implementing the Display Trait on a Struct

Implementing the Display Trait on an Enum

Implementing the Debug Trait

Formatter Methods

Implementing the Drop Trait

Implementing the Clone Trait

Implementing the Copy Trait

Implementing the PartialEq Trait for Structs

Defining Equality for Different Types

Implementing the PartialEq Trait for Enums

Implementing the Eq Trait

Implementing the PartialOrd Trait

Associated Types I

Associated Types II

Project Solution

Section Review

Lifetimes

Concrete Lifetimes for Values I

Concrete Lifetimes for Values II

Concrete Lifetimes for References

Non-Lexical Lifetimes

Invalid Lifetimes I

Invalid Lifetimes II

Functions Cannot Return References to Owned Values or Parameters

References as Function Parameters

Intro to Generic Lifetimes

Lifetimes and Referents

Lifetime Elision Rules I

Multiple Parameters I

Multiple Parameters II

Lifetime Elision Rules II

Lifetimes in Structs

Multiple Lifetimes

The static Lifetime

Project Solution

Section Review

Closures

Nested Functions

Intro to Closures

Closure Shortcuts

The Fn Trait Hierarchy

Closures that Capture Immutable References

Closures that Capture Mutable References

Closures with Ownership

The move Keyword

The unwrap_or_else Method

Defining a Method that Accepts a Closure I (FnOnce Trait)

The String.retain Method

Defining a Method that Accepts a Closure II (FnMut Trait)

The Fn Trait

Passing in a Function to Fn Trait Parameter

Project Solution

Section Review

Iterators

Manual Iteration

The Iterator and IntoIterator Traits

The IntoIterator Trait in Action

Exhausting the Iterator

The for Loop with Iterator

Why Iterator Can Be Immutable

The iter Method

The iter_mut Method

HashMap Iteration

String Iteration

Solving a Problem with Iteration

The for_each Method

The map Method I

The collect Method

The map Method II

The filter and find Methods I

The filter and find Methods II

The any and all Methods

The cloned Method

The filter_map Method

The flatten Method

The flat_map Method

The enumerate Method

The partition Method

The zip Method

The fold Method

The reduce Method

The sum, product, max, min, and count Methods

The last, nth, nth_back, and position Methods

The take, rev, skip, and step_by Methods

The sort and sort_by_key Methods

The lines Method

Collecting Command Line Arguments I

Collecting Command Line Arguments II

Reading Directory

The FromIterator Trait

Project: Wordle

Project Solution

Section Review

Testing

Intro to Testing

Writing a Test and the assert_eq! Macro

The tests Module and the cfg Attribute

Test Failures

The assert! Macro

Testing Inequality with the assert_ne! Macro

The pretty_assertions Crate

Trait Requirements for Types in Testing

Custom Failure Messages

The should_panic Attribute

Using Result Enum in Tests

Running A Subset of Tests

Ignoring Tests

Showing Printed Output from Passing Tests

Adding MovieTheater Struct

Dependency Injection I

Dependency Injection II

Integration Tests

Documentation Tests

Test Options

Fixtures with the rstest Crate

Test-Driven Development

Project Solution

Section Review

Randomness with rand Crate

Intro to the rand Crate

The ThreadRng Struct

Randomizing Vector Elements with shuffle Method

Project Solution

Section Review

Datetimes with Chrono Crate

The NaiveDate Struct

The TimeDelta Struct

Adding and Subtracting Time

The NaiveTime and NaiveDateTime Structs

The DateTime Struct

Converting Timezones

The parse_from_str Function

The Format Method

Project Solution

Section Review

Regular Expressions with Regex Crate

Intro to the Regex Crate

The Find and Find_iter Methods

Searching for Digits

Alphanumeric Characters

Whitespace

Word Boundaries

The Dot Metacharacter

Square Brackets with Characters

Number of Matches I

Number of Matches II

Or Logic

Anchors

Capture Groups

The Replace_all Method

Project Solution

Section Review

Smart Pointers: Box

Raw Pointers

Raw Pointers and Unsafe Code

Smart Pointers

The Box Smart Pointer

Intro to Linked Lists

Defining the LinkedList

Creating the LinkedList

Box vs Regular References I

Box vs Regular References II

Vectors are Smart Pointers

Intro to Binary Search Trees

Creating a Binary Search Tree

The Deref and DerefMut Traits I

The Deref and DerefMut Traits II

The Drop Trait

Deref Coercions

Trait Objects I

Trait Objects II: Handling Multiple Errors

Custom Error Types

Project Solution

Section Review

Congratulations!

Congratulations

Learn to Code with Rust

By : Boris Paskhaver

Learn to Code with Rust

By: Boris Paskhaver

Overview of this book

Confirmation

Buy this book with your credits?

Submit Your Feedback

Create a Free Account To Continue Reading

Sign in to activate your 7-day free access