book

Rust

Name: Rust
ISBN: 9781807785116

by Rheinwerk Publishing, Inc, Nouman Azam

April 2026

Intermediate

631 pages

16h 20m

English

Packt Publishing

Read now

Unlock full access

Notes on Usage
Table of Contents
Preface
The Purpose of This Book The Structure of This Book Target Audience Acknowledgments
Part I Basic Programming with Rust
1 Introduction
1.1 Installing Rust and Its Web-Based Environment1.1.1 Installing Rust1.1.2 Rust’s Web-Based Compiler
1.2 Running and Compiling Your First Program
1.3 Visual Studio Code Settings
1.4 Making the Most of This Book
1.5 Summary
2 Variables, Data Types, and Functions
2.1 Variables2.1.1 Definition2.1.2 Mutability of Variables2.1.3 Scope of Variables2.1.4 Shadowing2.1.5 Constants2.1.6 Statics2.1.7 Unused Variables

2.2 Data Types
2.2.1 Primitive Data Types2.2.2 Compound Data Types2.2.3 Text-Related Types
2.3 Functions
2.4 Code Blocks
2.5 Practice Exercises
2.6 Solutions
2.7 Summary
3 Conditionals and Control Flow
3.1 Conditionals3.1.1 If Else3.1.2 If Else If Ladder3.1.3 Match
3.2 Control Flow
3.2.1 Simple Loops3.2.2 For and While Loops
3.3 Comments, Outputs, and Inputs
3.3.1 Comments3.3.2 Formatting Outputs with Escape Sequences and Arguments3.3.3 User Input
3.4 Practice Exercises
3.5 Solutions
3.6 Summary
4 Ownership
4.1 Ownership Basics4.1.1 Values Must Have a Single Owner4.1.2 When Owner Goes Out of Scope, the Value Is Cleaned Up
4.2 Ownership in Functions
4.2.1 Functions Taking Ownership4.2.2 Function Returning Ownership4.2.3 Function Taking and Returning Ownership
4.3 Borrowing Basics
4.3.1 Why Borrowing?4.3.2 Borrowing Rules4.3.3 Copying of References
4.4 Borrowing in Functions
4.5 Dereferencing
4.6 Mutable and Immutable Binding of References
4.7 Practice Exercises
4.8 Solutions
4.9 Summary
5 Custom and Library-Provided Useful Types
5.1 Structs5.1.1 Defining Structs5.1.2 Instantiating Struct Instances5.1.3 Ownership Considerations5.1.4 Tuple Structs5.1.5 Unit Structs5.1.6 Adding Functionality to Structs5.1.7 Associated Functions
5.2 Enums
5.2.1 Why Use Enums?5.2.2 Defining Enums5.2.3 Implementation Blocks for Enums5.2.4 Adding Data to Enum Variants
5.3 Option
5.3.1 Why Use Option?5.3.2 Defining the Option Enum5.3.3 Matching on Option5.3.4 Use of If Let with Option
5.4 Result
5.4.1 Why Use Result?5.4.2 Defining the Result Enum5.4.3 Matching on Result5.4.4 The ? Operator
5.5 HashMaps
5.6 HashSets
5.7 Practice Exercises
5.8 Solutions
5.9 Summary
6 Organizing Your Code
6.1 Code Organization
6.2 Module Basics
6.2.1 Motivating Example for Modules6.2.2 Creating Modules6.2.3 Relative and Absolute Paths of Items6.2.4 Privacy in Modules6.2.5 The Use Declaration for Importing or Bringing Items into Scope
6.3 Visualizing and Organizing Modules
6.3.1 Cargo Modules for Visualizing Module Hierarchy6.3.2 Organizing Code Using a Typical File System
6.4 Re-Exporting and Privacy
6.4.1 Re-Exporting with a Pub Use Expression6.4.2 Privacy of Structs
6.5 Using External Dependencies
6.6 Publishing Your Crate
6.6.1 Creating an Account on crates.io6.6.2 Adding Documentation before Publishing6.6.3 Publishing Your Crate
6.7 Practice Exercises
6.8 Solutions
6.9 Summary
7 Testing Code
7.1 Unit Testing7.1.1 A Typical Test Case7.1.2 Writing a Test Function7.1.3 Executing Tests7.1.4 Testing with Result Enum7.1.5 Testing Panics
7.2 Controlling Test Execution
7.3 Integration Tests
7.4 Benchmark Testing
7.5 Practice Exercises
7.6 Solutions
7.7 Summary
Part II Intermediate Language Concepts
8 Flexibility and Abstraction with Generics and Traits
8.1 Generics8.1.1 Basics of Generics8.1.2 Generics in Implementation Blocks8.1.3 Multiple Implementations for a Type: Generics versus Concrete8.1.4 Duplicate Definitions in Implementation Blocks8.1.5 Generics and Free Functions8.1.6 Monomorphization
8.2 Traits
8.2.1 Motivating Example for Traits8.2.2 Traits Basics8.2.3 Default Implementations8.2.4 Trait Bounds8.2.5 Supertraits8.2.6 Trait Objects8.2.7 Derived Traits8.2.8 Marker Traits8.2.9 Associated Types in Traits
8.3 Choosing between Associated Types and Generic Types
8.4 Practice Exercises
8.5 Solutions
8.6 Summary
9 Functional Programming Aspects
9.1 Closures9.1.1 Motivating Example for Closures9.1.2 Basic Syntax9.1.3 Passing Closures to Functions9.1.4 Capturing Variables from the Environment
9.2 Function Pointers
9.3 Iterators
9.3.1 The Iterator Trait9.3.2 IntoIterator9.3.3 Iterating over Collections
9.4 Combinators
9.5 Iterating through Option
9.6 Practice Exercises
9.7 Solutions
9.8 Summary
10 Memory Management Features
10.1 Lifetimes10.1.1 Concrete Lifetimes10.1.2 Generic Lifetimes10.1.3 Static Lifetimes10.1.4 Lifetime Elision10.1.5 Lifetimes and Structs
10.2 Smart Pointers
10.2.1 Box Smart Pointer10.2.2 Rc Smart Pointer10.2.3 RefCell Smart Pointer
10.3 Deref Coercion
10.4 Practice Exercises
10.5 Solutions
10.6 Summary
11 Implementing Typical Data Structures
11.1 Singly Linked List11.1.1 Implementation by Modifying the List Enum11.1.2 Resolving Issues with the Implementation11.1.3 Refining the Next Field11.1.4 Adding Elements11.1.5 Removing Elements11.1.6 Printing Singly Linked Lists
11.2 Doubly Linked List
11.2.1 Setting Up the Basic Data Structure11.2.2 Adding Elements11.2.3 Adding a New Constructor Function for Node11.2.4 Removing Elements11.2.5 Printing Doubly Linked Lists
11.3 Reference Cycles Creating Memory Leakage
11.4 Practice Exercises
11.5 Solutions
11.6 Summary
12 Useful Patterns for Handling Structs
12.1 Initializing Struct Instances12.1.1 New Constructors12.1.2 Default Constructors
12.2 Builder Pattern
12.2.1 Motivating Example for the Builder Pattern12.2.2 Solving the Proliferation of Constructors
12.3 Simplifying Structs
12.4 Practice Exercises
12.5 Solutions
12.6 Summary
Part III Advanced Language Concepts
13 Understanding Size in Rust
13.1 Sized and Unsized Types13.1.1 Examples of Sized Types13.1.2 Examples of Unsized Types
13.2 References to Unsized Types
13.3 Sized and Optionally Sized Traits
13.3.1 Opting Out of Sized Trait13.3.2 Generic Bound of Sized Traits13.3.3 Flexible Generic Function with Optionally Sized Trait
13.4 Unsized Coercion
13.4.1 Deref Coercion13.4.2 Unsized Coercion13.4.3 Unsized Coercion with Traits
13.5 Zero-Sized Types
13.5.1 Never Type13.5.2 Unit Type13.5.3 Unit Structs13.5.4 PhantomData
13.6 Practice Exercises
13.7 Solutions
13.8 Summary
14 Concurrency
14.1 Thread Basics14.1.1 Fundamental Concepts14.1.2 Creating Threads14.1.3 Thread Completion Using Sleep14.1.4 Thread Completion Using Join
14.2 Ownership in Threads
14.3 Thread Communication
14.3.1 Message Passing14.3.2 Sharing States
14.4 Synchronization through Barriers
14.4.1 Motivating Example for Barriers14.4.2 Synchronizing Threads Using Barriers
14.5 Scoped Threads
14.6 Thread Parking
14.6.1 Motivating Example for Thread Parking14.6.2 Temporarily Blocking a Thread14.6.3 Park Timeout Function
14.7 Async Await
14.7.1 Creating Async Functions14.7.2 Deriving Futures to Completion with the Await Method14.7.3 Tokio
14.8 Web Scraping Using Threads
14.9 Practice Exercises
14.10 Solutions
14.11 Summary
15 Macros
15.1 Macro Basics15.1.1 Basic Syntax15.1.2 Matching Pattern in the Rule15.1.3 Captures15.1.4 Strict Matching15.1.5 Macro Expansion
15.2 Capturing Types
15.2.1 Type Capture15.2.2 Identifiers Capture
15.3 Repeating Patterns
15.4 Practice Exercises
15.5 Solutions
15.6 Summary
16 Web Programming
16.1 Creating a Server16.1.1 Server Basics16.1.2 Implementing a Server16.1.3 Handling Multiple Connections16.1.4 Adding a Connection Handling Function
16.2 Making Responses
16.2.1 Response Syntax16.2.2 Responding with Valid HTML16.2.3 Returning Different Responses
16.3 Multithreaded Server
16.4 Practice Exercises
16.5 Solutions
16.6 Summary
17 Text Processing, File Handling, and Directory Management
17.1 Basic File Handling17.1.1 Creating a File and Adding Content17.1.2 Appending a File17.1.3 Storing the Results17.1.4 Reading from a File
17.2 Path- and Directory-Related Functions
17.2.1 Working with Paths17.2.2 Working with Directories
17.3 Regular Expressions Basics
17.3.1 Basic Methods17.3.2 Dot and Character Ranges17.3.3 Starting and Ending Anchors17.3.4 Word Boundaries17.3.5 Quantifiers, Repetitions, and Capturing Groups
17.4 String Literals
17.4.1 Working with Raw String Literals17.4.2 Parsing JSON17.4.3 Using a Hash within a String
17.5 Practice Exercises
17.6 Solutions
17.7 Summary
18 Practical Problems
18.1 Problem 1: Search Results with Word Groupings18.1.1 Solution Setup18.1.2 Implementation
18.2 Problem 2: Product Popularity
18.2.1 Solution Setup18.2.2 Implementation
18.3 Problem 3: Highest Stock Price
18.3.1 Solution Setup18.3.2 Implementation
18.4 Problem 4: Identify Time Slots
18.4.1 Solution Setup18.4.2 Implementation
18.5 Problem 5: Item Suggestions
18.5.1 Solution Setup18.5.2 Implementation
18.6 Problem 6: Items in Range Using Binary Search Trees
18.6.1 Solution Setup18.6.2 Basic Data Structure18.6.3 Implementation
18.7 Problem 7: Fetching Top Products
18.7.1 Solution Setup18.7.2 Implementation
18.8 Problem 8: Effective Storage and Retrieval
18.8.1 Solution Setup18.8.2 Basic Data Structure18.8.3 Implementation
18.9 Problem 9: Most Recently Used Product
18.9.1 Solution Setup18.9.2 Basic Data Structure18.9.3 Implementation
18.10 Problem 10: Displaying Participants in an Online Meeting
18.10.1 Solution Setup18.10.2 Basic Data Structure18.10.3 Implementation
18.11 Summary
The Author
Index
Service Pages
Legal Notes

Content preview from Rust

4.2 Ownership in Functions

Ownership in Rust becomes particularly interesting when functions are involved. Functions can be categorized into three groups in the context of ownership: those that take ownership, those that give ownership, and those that take and then return ownership. Let’s examine each of these types one by one.

4.2.1 Functions Taking Ownership

Consider a case where you need a function in which the caller transfers ownership of a value to the function. This transfer ensures the function has exclusive access to the value and prevents further use of the original value. Such functions are particularly useful in contexts involving resource management. Consider the code shown in Listing 4.3.

fn main(){    let vec_1 = vec![1,

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781807785116

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Rust

by Rheinwerk Publishing, Inc, Nouman Azam

4.2 Ownership in Functions

4.2.1 Functions Taking Ownership

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

More than 5,000 organizations count on O’Reilly

Julian F.

Addison B.

Amir M.

Mark W.

You might also like

Software Architecture: The Hard Parts

Agentic Architectural Patterns for Building Multi-Agent Systems

Fundamentals of Software Architecture, 2nd Edition

Designing Data-Intensive Applications, 2nd Edition

Publisher Resources