Carlo Milanesi

Beginning Rust

Get Started with Rust 2021 Edition

2nd ed.
Carlo Milanesi
Bergamo, Italy
ISBN 978-1-4842-7207-7e-ISBN 978-1-4842-7208-4
https://doi.org/10.1007/978-1-4842-7208-4
© Carlo Milanesi 2022
This work is subject to copyright. All rights are solely and exclusively licensed by the Publisher, whether the whole or part of the material is concerned, specifically the rights of translation, reprinting, reuse of illustrations, recitation, broadcasting, reproduction on microfilms or in any other physical way, and transmission or information storage and retrieval, electronic adaptation, computer software, or by similar or dissimilar methodology now known or hereafter developed.
The use of general descriptive names, registered names, trademarks, service marks, etc. in this publication does not imply, even in the absence of a specific statement, that such names are exempt from the relevant protective laws and regulations and therefore free for general use.
The publisher, the authors and the editors are safe to assume that the advice and information in this book are believed to be true and accurate at the date of publication. Neither the publisher nor the authors or the editors give a warranty, expressed or implied, with respect to the material contained herein or for any errors or omissions that may have been made. The publisher remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.

This Apress imprint is published by the registered company APress Media, LLC part of Springer Nature.

The registered company address is: 1 New York Plaza, New York, NY 10004, U.S.A.

This book is dedicated to my mother and to my father’s memory. I owe them my interest in learning and explaining things.

Preface

Welcome to Beginning Rust. This book teaches beginners how to program with the exciting Rust programming language in an easy, step-by-step manner. It is a fully revised version of the 2018 book, with several additions, expanded clarifications for the most hard-to-master concepts, and removal of redundant sections. It utilizes the 2021 edition of the Rust language, developed by the Rust Team community.

What You Need to Know

Only a basic knowledge of programming is required. Rust is mainly targeted for systems programming tasks, a sector currently dominated by the C and C++ languages. So, to ease the transition from such languages, the text contains many comparisons with C and C++, and even code examples in those languages. Yet, this book can also be enjoyed by people who are only familiar with other programming languages, like Java or C#.

Knowledge of command-line environments is assumed, like a Linux shell, macOS Terminal, or Windows Command Prompt, because all the examples contained in this book need to be compiled and run in such environments.

How to Read This Book

It is strongly recommended you read the book from beginning to end, without skipping chapters, because every chapter assumes that the reader understands what was explained in previous chapters.

The text presents a lot of code examples, which should be read thoroughly, and possibly compiled and run on your own computer. You can type them, or use the freely available downloaded code.

Where to Find the Source Code

All of the examples used in this book can be accessed on GitHub at github.com/apress/beginning-rust-2e.

What This Book Does Not Cover

Please note that this book does not cover everything needed to develop professional programs using Rust. It just teaches the concepts of the language, including the most difficult ones. For writing professional software, you will need to download and learn some third-party frameworks and libraries. There are quite a few of them which are of good-to-outstanding quality and freely available.

Table of Contents
Chapter 1:​ Getting Started1
How to Start1
Hello, World!2
Printing Combinations of Literal Strings4
Printing Several Lines of Text5
Printing Integer Numbers6
Comments7
Chapter 2:​ Doing Arithmetic and Writing More Code9
Adding Integer Numbers9
Other Operations Between Integer Numbers10
Floating-Point Arithmetic11
Sequences of Statements13
Breaking Literal Strings14
Chapter 3:​ Naming Objects17
Associating Names to Values17
Mutable Variables19
Not Mutated Mutable Variables21
Uninitialized Variables22
The Leading Underscore24
Boolean Values25
Boolean Expressions27
Type Consistency in Assignments28
Type Inference29
Change of Type and of Mutability30
Compound Assignment Operators31
Using the Functions of the Standard Library31
Chapter 4:​ Controlling Execution Flow33
Conditional Statements (if)33
Conditional Expressions36
Conditional Loops (while)38
Infinite Loops (loop)40
Counting Loops (for)41
Variables Scopes44
Chapter 5:​ Using Data Sequences47
Arrays47
Rust Attributes50
Panicking51
Mutable Arrays53
Arrays of Explicitly Specified Size55
Multidimensional​ Arrays56
Vectors57
Other Operations on Vectors59
Empty Arrays and Vectors61
Debug Print62
Copying Arrays and Vectors63
Chapter 6:​ Using Primitive Types65
Nondecimal Numeric Bases66
The Underscore in Numeric Literals67
The Exponential Notation67
The Various Kinds of Signed Integer Numbers69
Unsigned Integer Number Types71
Target-Dependent Integer-Number Types72
Type Inference74
The Type Inference Algorithm76
Floating-Point Numeric Types77
Explicit Conversions78
Type Suffixes of Numeric Literals79
All the Numeric Types80
Booleans and Characters81
The Empty Tuple84
Array and Vector Types85
Constants85
Discovering the Type of an Expression86
Chapter 7:​ Enumerations and Matching89
Enumerations89
The match Construct91
Relational Operators and Enums94
Handling All the Cases94
Using match with Numbers96
Enumerations with Data97
match Statements with Variables in Patterns101
match Expressions102
Use of Guards in match Constructs103
if-let and while-let Constructs104
Chapter 8:​ Using Heterogeneous Data Structures107
The Tuples107
The Structs109
The Tuple-Structs112
Lexical Conventions113
Chapter 9:​ Defining Functions115
Defining and Invoking a Function115
Functions Defined After Their Use116
Functions Shadowing Other Functions117
Passing Arguments to a Function118
Passing Arguments by Value120
Returning a Value from a Function121
Early Exit122
Returning Several Values124
How to Change a Variable of the Caller125
Passing Arguments by Reference127
Using References130
Mutability of References131
Chapter 10:​ Defining Generic Functions and Types135
Need of Generic Functions135
Defining and Using Generic Functions137
Inferring the Parametric Types138
Defining and Using Generic Structs139
Genericity Mechanics141
Generic Arrays and Vectors143
Generic Enums143
The Option<T> Standard Enum144
The Result<T, E> Standard Enum146
Enum Standard Utility Functions147
Chapter 11:​ Allocating Memory151
The Various Kinds of Allocation151
Linear Addressing152
Static Allocation154
Stack Allocation155
Limitations of Stack Allocation161
Heap Allocation164
Heap Management165
The Behavior of Box166
Similarity with C and C++167
Boxing and Unboxing168
Register Allocation170
Chapter 12:​ Data Implementation171
Discovering the Size of Objects171
The use Directive172
The Sizes of the Primitive Types173
The Representation of Primitive Types174
Location of Bytes in Memory175
Sizes of Composite Data Types177
Vector Allocation178
Chapter 13:​ Defining Closures183
The Need for Disposable Functions183
Capturing the Environment184
Closures186
Closure Invocation Syntax188
Chapter 14:​ Using Changeable Strings191
Static Strings191
Dynamic Strings194
Implementation of String195
Creating Dynamic Strings198
Converting Static Strings to Dynamic Strings199
Concatenating Strings200
Chapter 15:​ Ranges and Slices203
The Ranges203
Motivation for Slices206
The Slices207
Slicing210
Out-of-Range Slicing212
Mutable Slicing213
Open-Ended Ranges and Slicing214
Inclusive Ranges215
Chapter 16:​ Using Iterators217
String Characters217
Scanning a String219
Using String Iterators in for Loops221
The Rust Editions222
Iterators over Vectors, Arrays, and Slices223
Iterators Generating References225
Iterations without Mutation226
Iterations with Mutation226
Shorthand for Using Iterators in Loops228
Iterator Generators229
An Iterator Adapter:​ filter229
The map Iterator Adapter230
The enumerate Iterator Adapter231
An Iterator Consumer:​ any232
The all Iterator Consumer234
The count Iterator Consumer235
The sum Iterator Consumer235
The min and max Iterator Consumers236
The collect Consumer237
Iterator Chains239
Iterators Are “Lazy”241
Chapter 17:​ Input/​Output and Error Handling243
Command-Line Arguments243
Process Return Code244
Environment Variables245
Reading from the Console246
Proper Runtime Error Handling248
Writing to the Console255
Converting a Value to a String256
Converting a String to a Value256
File Input/​Output257
Processing Text Files260
Chapter 18:​ Data Encapsulation263
The Need for Methods263
Method Declarations265
The self and Self Keywords268
The mod and the pub Keywords271
The type Keyword275
Chapter 19:​ Using Traits277
The Need for Traits277
Traits to the Rescue280
Generic Functions with No Parameter Bounds283
Scope of Traits284
Traits with Multiple Methods286
Generic Parameters with Multiple Bounds287
Trait Inheritance289
Adding Methods to External Types290
Standard Traits: Display and Debug292
Generic Traits294
Using Associated Types298
The Iterator Standard Trait306
Chapter 20:​ Object-Oriented Programming309
Peculiarities of Rust Object-Orientation309
Destructors310
Operator Overloading314
Infallible Type Converters321
Fallible Type Converters323
Composition Instead of Inheritance325
Static Dispatch328
Dynamic Dispatch331
Implementation of Dynamic-Dispatch References332
Static vs.​ Dynamic Dispatch334
Chapter 21:​ Standard Library Collections337
Collections337
Measuring Execution Time338
Performing Arbitrary Insertions and Removals339
Queues342
Linked Lists346
Binary Heaps346
Ordered Sets and Unordered Sets348
Ordered Dictionaries and Unordered Dictionaries352
Collections in C++ and in Rust353
Chapter 22:​ Ownership, Moves, and Copies355
Deterministic Destruction355
Ownership358
Assignment Semantics359
Copying vs.​ Moving Performance362
Moving and Destroying Objects362
Need for Copy Semantics365
Cloning Objects366
Making Types Cloneable or Copyable369
Chapter 23:​ Borrowing and Lifetimes373
Programming Errors when Using References373
Borrowing377
Object Lifetimes378
How to Prevent Use Af ter Drop Errors379
How to Prevent Use Af ter Change by an Alias Errors380
The Need for Lifetime Specifiers in Returned References382
Usage and Meaning of Lifetime Specifiers385
Checking the Validity of Lifetime Specifiers388
Using the Lifetime Specifiers of Invoked Functions392
Advantage of Using Several Lifetime Specifiers for a Function393
Chapter 24:​ More About Lifetimes395
Lifetime Elision395
Lifetime Elision with Object-Oriented Programming397
The Need for Lifetime Specifiers in Structs Declarations398
Possible Lifetime Specifiers for Structs401
Lifetime Specifiers for Tuple-Structs and Enums404
Lifetime Specifiers for Mutable References404
Index407
About the Author
Carlo Milanesi
../images/463369_2_En_BookFrontmatter_Figb_HTML.jpg
is a professional software developer, expert in C++, graphics programming, and GUI design. He graduated from the State University of Milan and has worked in the financial and CAD/CAM software industries. He enjoys designing, writing, and testing software. He also loves teaching and acting.

He authored the book Creative Projects for Rust Programmers, and developed the Rust library https://github.com/carlomilanesi/rs-measures.

 
About the Technical Reviewer
Satej Kumar Sahu

works in the role of Senior Enterprise Architect at Honeywell. He is passionate about technology, people, and nature. He believes that through technology and conscientious decision making, each of us has the power to make this world a better place. In his free time, he can be found reading books, playing basketball, and having fun with friends and family.

 
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
3.21.104.72