This book is a complete and systematic guide to learning Rust, one of the world’s fastest-growing and most reliable systems programming languages. Designed for students, beginners, educators, and software professionals, the book takes a step-by-step approach to help learners build a strong foundation in writing efficient, safe, and high-performance Rust programs.

Covering 24 well-structured chapters, the text begins with the fundamentals of Rust, including its installation, syntax, commenting styles, printing methods, variables, data types, mutability, and control structures. As readers progress, they are introduced to Rust’s core strengths—ownership, borrowing, type safety, memory management, pattern matching, error handling, and modular programming—all explained with simple examples and practical exercises.

The book provides extensive hands-on coverage of essential data structures such as arrays, slices, tuples, structures, vectors, hashmaps, and hashsets, enabling learners to build real-world applications with confidence. Advanced chapters explore iterators, generics, traits, file handling, macros, modules, packages, and multithreading, ensuring that readers gain deep insight into Rust’s modern capabilities.

One of the unique strengths of this book is its highly practical approach—every chapter includes illustrative programs, detailed explanations of errors, and review questions to help learners strengthen conceptual understanding and debugging skills. From simple I/O operations to concurrent programming and procedural macros, each topic is presented with clarity and real-world relevance.

Comprehensive, easy to follow, and classroom ready, this book serves as an essential resource for anyone aiming to master Rust for systems programming, embedded applications, algorithm development, or high-performance computing. Whether you are a beginner or a practicing developer, this book will guide you from basics to advanced concepts in a structured and confidence-building manner.

R. Panneerselvam, PhD, served as a Professor of Computer Systems and Languages, Operations, and Quantitative Methods at Pondicherry University. He possesses a total of 41 years of teaching and research experience at Anna University and Pondicherry University put together. He served as the chairman of the Computer Society of India (Pondicherry Chapter) and a life member of the Indian Institution of Industrial Engineering and the Computer Society of India.

Prof. Panneerselvam has published more than 100 research articles in leading national and international journals and has authored 28 textbooks. He also provided consultancy, including an overseas consultancy to CEMS, Malaysia. 

Dr Panneerselvam received an academic excellence award in an international conference on Advances in Industrial Engineering Practices, an Achiever Award from Anna University for his outstanding contributions to academics, and a Best Teacher award from Pondicherry University. 
 

1. INTRODUCTION TO RUST
1.1 Importance of Programming
1.2 Significance of Rust Computer Language
1.3 Rust Compilers and Their Installations
Review Questions

2. COMMENT STATEMENTS IN RUST
2.1 Introduction
2.2 Sample Rust Program
2.3 Line Comment Statement
2.4 Block Comment
2.5 Outer Doc Comment
2.6 Inner Doc Comment
2.7 Higher Level Doc Comment
Review Questions

3. PRINT COMMANDS
3.1 Introduction
3.2 Types of Print Command
3.3 Printing Using println!()
3.4 String
3.5 Reading String from Console
3.6 Reading Integer from Console
Review Questions

4. RUST VARIABLES AND MUTABILITY
4.1 Introduction
4.2 Variables
4.3 Change of Value with Unmutability and Associated Error
4.4 Variables with Mutability
4.5 Constants in Rust
4.6 Shadowing
4.7 Shadowing and Mutability in Rust
Review Questions

5. DATA TYPES IN RUST
5.1 Introduction
5.2 Data Types
5.3 Integer Data Type
5.4 Floating Point Data Type
5.5 String Data Type
5.6 Character Data Type
5.7 Boolean Data Type
5.8 Type Inference
5.9 Arithmetic Operations in Rust
Review Questions

6. TYPE CASTING IN RUST
6.1 Introduction
6.2 Types of Type Casting
6.3 Explicit Casting: Floating Point → Unsigned Integer
6.4 Explicit Casting: Character → Integer
6.5 Explicit Casting: Integer → Character
6.6 Error When Using Non-u8 Type for Casting Numeric Data to Character
6.7 Boolean → Integer Casting
6.8 Integer → Boolean Casting
Review Questions

7. OPERATORS IN RUST
7.1 Introduction
7.2 Arithmetic Operators
7.3 Assignment Operator
7.4 Compound Assignment Operator
7.5 Comparison Operators
7.6 Logical Operators
Review Questions

8. CONTROL STRUCTURES
8.1 Introduction
8.2 If Control Structure
8.3 If–Else
8.4 Infinite Loop
8.5 While Loop
8.6 For Loop
8.7 Break Statement
8.8 Continue Statement
8.9 Pattern Matching
Review Questions

9. ARRAY DATA TYPE
9.1 Introduction
9.2 Array Structure
9.3 One-Dimensional Array with Data Type
9.4 One-Dimensional Array without Data Type
9.5 Array with Default Values
9.6 Multi-Dimensional Array
Review Questions

10. SLICING OF ARRAY
10.1 Introduction
10.2 Slicing with Start and End Index
10.3 Omitting Start Index
10.4 Omitting End Index
Review Questions

11. TUPLE
11.1 Introduction
11.2 Tuple with Data Types
11.3 Tuple without Data Types
Review Questions

12. STRUCTURE IN RUST
12.1 Introduction
12.2 Simple Structure
12.3 Destructuring Structure Members
12.4 Changing Data in Structure
12.5 Structure with Arrays
Review Questions

13. FUNCTIONS
13.1 Introduction
13.2 Syntax of Function
13.3 Adding Three Numbers (General Method)
13.4 Function Without Parameters
13.5 Function With Parameters
13.6 Function With Return Value
13.7 Recursive Functions
13.8 Monte Carlo Simulation to Estimate Product Demand
13.9 Variable Scope
13.10 Variable Shadowing
13.11 Closure in Rust
Review Questions

14. STACK, HEAP AND LINKED LIST
14.1 Introduction
14.2 Reference (Pointer) and Borrowing
14.3 Stack
14.4 Heap
14.5 Linked List
Review Questions

15. VECTOR
15.1 Introduction
15.2 Creating Vector
15.3 Accessing Vector Elements
15.4 get() Method
15.5 Appending Data
15.6 Inserting an Element
15.7 Removing an Element
15.8 Removing Rightmost Element (pop())
15.9 For Loop Over Vector
15.10 Creating Vector (Additional Examples)
15.11 Handling Vector With Functions
Review Questions

16. HASHMAP
16.1 Introduction
16.2 Creating HashMap
16.3 Adding Elements
16.4 Accessing Values
16.5 Removing a Value
16.6 Changing Value of a Key
16.7 Finding Length
16.8 Checking Existence of Key
16.9 values() Iterator
16.10 keys() Iterator
16.11 Cloning HashMap
16.12 Iterating Over HashMap
Review Questions

17. HASHSET
17.1 Introduction
17.2 Creating HashSet
17.3 Adding Values
17.4 Checking Presence of a Value
17.5 Removing a Value
17.6 Iterating Over Values
17.7 HashSet with Default Values
17.8 Finding Length
17.9 Checking Empty Status
17.10 clear() Command
17.11 drain() Command
Review Questions

18. ITERATORS
18.1 Introduction
18.2 Simple Iterator Example
18.3 Range Iterator
18.4 next() Method
18.5 iter() Method
18.6 into_iter() Method
18.7 iter_mut() Method
18.8 Iterator Adapters
Review Questions

19. ERROR HANDLING IN RUST
19.1 Introduction
19.2 Error Code E0001
19.3 Error Code E0004
19.4 Error Code E0007 / E0382
19.5 Variable-Related Errors
19.6 Errors in For Loop
19.7 Error E0384 in Shadowing
19.8 Error: Negative Sign on Unsigned Integer (E0600)
19.9 Boolean Handling Error (E0308)
19.10 Floating Point Not in Scope
19.11 Adding Variables of Different Types
19.12 Compound Operator Handling Error
19.13 Improper Comparison Operator Error
19.14 Error E0061 in Pattern Matching
19.15 Error E0599 (Enum Class Not in Scope)
19.16 Error E0608 in Tuple
19.17 Error E0560 in Structure
19.18 Error E0425 in Function
19.19 unwrap() and expect()
Review Questions

20. MODULES AND PACKAGES IN RUST
20.1 Introduction
20.2 Syntax of Module
20.3 Integrated Module Example
20.4 Nested Modules
20.5 use Keyword
20.6 Packages
20.7 Cargo Package Manager
Review Questions

21. GENERICS AND TRAITS
21.1 Introduction
21.2 Generic Applications
21.3 Traits
Review Questions

22. FILE HANDLING IN RUST
22.1 Introduction
22.2 Opening File in Write-Only Mode
22.3 Opening File in Read-Only Mode
22.4 Appending Data
22.5 Read After Append
22.6 Delete a File
22.7 Copy and Move
22.8 Handling Binary File in Rust
Review Questions

23. MACROS
23.1 Introduction
23.2 Declarative Macros
23.3 Procedural Macros
Review Questions

24. THREADS IN RUST
24.1 Introduction
24.2 Creating Threads With spawn
24.3 Join Handle
24.4 Move Closures
24.5 Sending Single Message Between Threads
24.6 Sending Multiple Messages Between Threads
Review Questions