Multilingual Book

🇺🇸 English (Original) 🇪🇸 Spanish (Translation)

✅ All languages are included in your purchase

Publisher SAP PRESS

Year / Edition 2025 / 1

Pages 627

Authors Nouman Azam

Rust

Get “close to the machine” by programming with Rust! Discover how to effectively use this low-level language to create fast and efficient code. Set up Rust, compile your first program, and learn the language essentials: variables, functions, conditionals, and more. Walk through Rust’s unique ownership model and modular system, and then move on to more complex features, from flexibility and abstraction to web programming and text processing. Numerous code examples and exercises make this your go-to practical resource for Rust!

Your hands-on guide to Rust programming
Work with essential language elements, including variables, strings, collections, functions, structures, and traits
Explore advanced concepts, including concurrency, testing, and sizing

You'll learn about:

Language Basics:
Take your first steps with Rust! After installation and setup in Visual Studio Code, walk through the language building blocks, from variables to functions to enums. Learn how to implement ownership, define types, test your code, and more.
Intermediate Programming:
Expand your toolkit for Rust programming! Write flexible code with generics and traits, incorporate features of functional programming, manage memory, implement data structures, and handle structs.
Advanced Topics:
Become a Rust master! Tackle advanced topics, including sized and unsized types, concurrency via threading, the powerful macro system, web programming, text processing, and file and directory handling.

Key Highlights:

Language basics
Control flow
Ownership
Structs and enums
Generics and traits
Modular structure
Memory management
Testing
Concurrency
Functional programming
Web programming
Text processing and file handling

View Full 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 Environment
  - 1.1.1 Installing Rust
  - 1.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 Variables
  - 2.1.1 Definition
  - 2.1.2 Mutability of Variables
  - 2.1.3 Scope of Variables
  - 2.1.4 Shadowing
  - 2.1.5 Constants
  - 2.1.6 Statics
  - 2.1.7 Unused Variables
- 2.2 Data Types
  - 2.2.1 Primitive Data Types
  - 2.2.2 Compound Data Types
  - 2.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 Conditionals
  - 3.1.1 If Else
  - 3.1.2 If Else If Ladder
  - 3.1.3 Match
- 3.2 Control Flow
  - 3.2.1 Simple Loops
  - 3.2.2 For and While Loops
- 3.3 Comments, Outputs, and Inputs
  - 3.3.1 Comments
  - 3.3.2 Formatting Outputs with Escape Sequences and Arguments
  - 3.3.3 User Input
- 3.4 Practice Exercises
- 3.5 Solutions
- 3.6 Summary
4 Ownership
- 4.1 Ownership Basics
  - 4.1.1 Values Must Have a Single Owner
  - 4.1.2 When Owner Goes Out of Scope, the Value Is Cleaned Up
- 4.2 Ownership in Functions
  - 4.2.1 Functions Taking Ownership
  - 4.2.2 Function Returning Ownership
  - 4.2.3 Function Taking and Returning Ownership
- 4.3 Borrowing Basics
  - 4.3.1 Why Borrowing?
  - 4.3.2 Borrowing Rules
  - 4.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 Structs
  - 5.1.1 Defining Structs
  - 5.1.2 Instantiating Struct Instances
  - 5.1.3 Ownership Considerations
  - 5.1.4 Tuple Structs
  - 5.1.5 Unit Structs
  - 5.1.6 Adding Functionality to Structs
  - 5.1.7 Associated Functions
- 5.2 Enums
  - 5.2.1 Why Use Enums?
  - 5.2.2 Defining Enums
  - 5.2.3 Implementation Blocks for Enums
  - 5.2.4 Adding Data to Enum Variants
- 5.3 Option
  - 5.3.1 Why Use Option?
  - 5.3.2 Defining the Option Enum
  - 5.3.3 Matching on Option
  - 5.3.4 Use of If Let with Option
- 5.4 Result
  - 5.4.1 Why Use Result?
  - 5.4.2 Defining the Result Enum
  - 5.4.3 Matching on Result
  - 5.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 Modules
  - 6.2.2 Creating Modules
  - 6.2.3 Relative and Absolute Paths of Items
  - 6.2.4 Privacy in Modules
  - 6.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 Hierarchy
  - 6.3.2 Organizing Code Using a Typical File System
- 6.4 Re-Exporting and Privacy
  - 6.4.1 Re-Exporting with a Pub Use Expression
  - 6.4.2 Privacy of Structs
- 6.5 Using External Dependencies
- 6.6 Publishing Your Crate
  - 6.6.1 Creating an Account on crates.io
  - 6.6.2 Adding Documentation before Publishing
  - 6.6.3 Publishing Your Crate
- 6.7 Practice Exercises
- 6.8 Solutions
- 6.9 Summary
7 Testing Code
- 7.1 Unit Testing
  - 7.1.1 A Typical Test Case
  - 7.1.2 Writing a Test Function
  - 7.1.3 Executing Tests
  - 7.1.4 Testing with Result Enum
  - 7.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 Generics
  - 8.1.1 Basics of Generics
  - 8.1.2 Generics in Implementation Blocks
  - 8.1.3 Multiple Implementations for a Type: Generics versus Concrete
  - 8.1.4 Duplicate Definitions in Implementation Blocks
  - 8.1.5 Generics and Free Functions
  - 8.1.6 Monomorphization
- 8.2 Traits
  - 8.2.1 Motivating Example for Traits
  - 8.2.2 Traits Basics
  - 8.2.3 Default Implementations
  - 8.2.4 Trait Bounds
  - 8.2.5 Supertraits
  - 8.2.6 Trait Objects
  - 8.2.7 Derived Traits
  - 8.2.8 Marker Traits
  - 8.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 Closures
  - 9.1.1 Motivating Example for Closures
  - 9.1.2 Basic Syntax
  - 9.1.3 Passing Closures to Functions
  - 9.1.4 Capturing Variables from the Environment
- 9.2 Function Pointers
- 9.3 Iterators
  - 9.3.1 The Iterator Trait
  - 9.3.2 IntoIterator
  - 9.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 Lifetimes
  - 10.1.1 Concrete Lifetimes
  - 10.1.2 Generic Lifetimes
  - 10.1.3 Static Lifetimes
  - 10.1.4 Lifetime Elision
  - 10.1.5 Lifetimes and Structs
- 10.2 Smart Pointers
  - 10.2.1 Box Smart Pointer
  - 10.2.2 Rc Smart Pointer
  - 10.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 List
  - 11.1.1 Implementation by Modifying the List Enum
  - 11.1.2 Resolving Issues with the Implementation
  - 11.1.3 Refining the Next Field
  - 11.1.4 Adding Elements
  - 11.1.5 Removing Elements
  - 11.1.6 Printing Singly Linked Lists
- 11.2 Doubly Linked List
  - 11.2.1 Setting Up the Basic Data Structure
  - 11.2.2 Adding Elements
  - 11.2.3 Adding a New Constructor Function for Node
  - 11.2.4 Removing Elements
  - 11.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 Instances
  - 12.1.1 New Constructors
  - 12.1.2 Default Constructors
- 12.2 Builder Pattern
  - 12.2.1 Motivating Example for the Builder Pattern
  - 12.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 Types
  - 13.1.1 Examples of Sized Types
  - 13.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 Trait
  - 13.3.2 Generic Bound of Sized Traits
  - 13.3.3 Flexible Generic Function with Optionally Sized Trait
- 13.4 Unsized Coercion
  - 13.4.1 Deref Coercion
  - 13.4.2 Unsized Coercion
  - 13.4.3 Unsized Coercion with Traits
- 13.5 Zero-Sized Types
  - 13.5.1 Never Type
  - 13.5.2 Unit Type
  - 13.5.3 Unit Structs
  - 13.5.4 PhantomData
- 13.6 Practice Exercises
- 13.7 Solutions
- 13.8 Summary
14 Concurrency
- 14.1 Thread Basics
  - 14.1.1 Fundamental Concepts
  - 14.1.2 Creating Threads
  - 14.1.3 Thread Completion Using Sleep
  - 14.1.4 Thread Completion Using Join
- 14.2 Ownership in Threads
- 14.3 Thread Communication
  - 14.3.1 Message Passing
  - 14.3.2 Sharing States
- 14.4 Synchronization through Barriers
  - 14.4.1 Motivating Example for Barriers
  - 14.4.2 Synchronizing Threads Using Barriers
- 14.5 Scoped Threads
- 14.6 Thread Parking
  - 14.6.1 Motivating Example for Thread Parking
  - 14.6.2 Temporarily Blocking a Thread
  - 14.6.3 Park Timeout Function
- 14.7 Async Await
  - 14.7.1 Creating Async Functions
  - 14.7.2 Deriving Futures to Completion with the Await Method
  - 14.7.3 Tokio
- 14.8 Web Scraping Using Threads
- 14.9 Practice Exercises
- 14.10 Solutions
- 14.11 Summary
15 Macros
- 15.1 Macro Basics
  - 15.1.1 Basic Syntax
  - 15.1.2 Matching Pattern in the Rule
  - 15.1.3 Captures
  - 15.1.4 Strict Matching
  - 15.1.5 Macro Expansion
- 15.2 Capturing Types
  - 15.2.1 Type Capture
  - 15.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 Server
  - 16.1.1 Server Basics
  - 16.1.2 Implementing a Server
  - 16.1.3 Handling Multiple Connections
  - 16.1.4 Adding a Connection Handling Function
- 16.2 Making Responses
  - 16.2.1 Response Syntax
  - 16.2.2 Responding with Valid HTML
  - 16.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 Handling
  - 17.1.1 Creating a File and Adding Content
  - 17.1.2 Appending a File
  - 17.1.3 Storing the Results
  - 17.1.4 Reading from a File
- 17.2 Path- and Directory-Related Functions
  - 17.2.1 Working with Paths
  - 17.2.2 Working with Directories
- 17.3 Regular Expressions Basics
  - 17.3.1 Basic Methods
  - 17.3.2 Dot and Character Ranges
  - 17.3.3 Starting and Ending Anchors
  - 17.3.4 Word Boundaries
  - 17.3.5 Quantifiers, Repetitions, and Capturing Groups
- 17.4 String Literals
  - 17.4.1 Working with Raw String Literals
  - 17.4.2 Parsing JSON
  - 17.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 Groupings
  - 18.1.1 Solution Setup
  - 18.1.2 Implementation
- 18.2 Problem 2: Product Popularity
  - 18.2.1 Solution Setup
  - 18.2.2 Implementation
- 18.3 Problem 3: Highest Stock Price
  - 18.3.1 Solution Setup
  - 18.3.2 Implementation
- 18.4 Problem 4: Identify Time Slots
  - 18.4.1 Solution Setup
  - 18.4.2 Implementation
- 18.5 Problem 5: Item Suggestions
  - 18.5.1 Solution Setup
  - 18.5.2 Implementation
- 18.6 Problem 6: Items in Range Using Binary Search Trees
  - 18.6.1 Solution Setup
  - 18.6.2 Basic Data Structure
  - 18.6.3 Implementation
- 18.7 Problem 7: Fetching Top Products
  - 18.7.1 Solution Setup
  - 18.7.2 Implementation
- 18.8 Problem 8: Effective Storage and Retrieval
  - 18.8.1 Solution Setup
  - 18.8.2 Basic Data Structure
  - 18.8.3 Implementation
- 18.9 Problem 9: Most Recently Used Product
  - 18.9.1 Solution Setup
  - 18.9.2 Basic Data Structure
  - 18.9.3 Implementation
- 18.10 Problem 10: Displaying Participants in an Online Meeting
  - 18.10.1 Solution Setup
  - 18.10.2 Basic Data Structure
  - 18.10.3 Implementation
- 18.11 Summary
The Author
Index

ℹ️ How to purchase this book?

This product has a special price upon request. You can start your order or clarify any doubts using the Contact for Price button on the page.

We have also prepared a step-by-step guide to explain how to easily request your quote.

Read the guide here →

Disclaimer

SAP, other SAP products and services mentioned herein as well as their respective logos are trademarks or registered trademarks of SAP SE (or an SAP affiliate company) in Germany and other countries. Our Company is not affiliated to SAP SE or any of its affiliated companies including but not limited to: Sybase, Business Objects, Hybris, Ariba and SuccessFactors. All other names, brands, logos, etc. are registered trade or service marks of their respective owners.

Home > SAP Books > Multilingual Books > Rust - The Practical Guide

Rust - The Practical Guide

Name: Rust - The Practical Guide
Brand: SAP
SKU: BOOK-SAPPRESS-EBOOK-2025-9781493226887
Availability: InStock

Warranty

Receive the product you were expecting or we will refund your money

Would you like to see a sample of the course or book?

If you need a sample of the course or book, request it in the chat below and we will be happy to provide it to you.

1 installment of $0.00 USD without interest		Total $0.00 USD
2 installments of $0.00 USD without interest		Total $0.00 USD
3 installments of $0.00 USD without interest		Total $0.00 USD
4 installments of $0.00 USD without interest		Total $0.00 USD
5 installments of $0.00 USD without interest		Total $0.00 USD
6 installments of $0.00 USD without interest		Total $0.00 USD