ebook img

Beginning Rust: From Novice to Professional PDF

381 Pages·2018·3.18 MB·English
Save to my drive
Quick download
Download
Most books are stored in the elastic cloud where traffic is expensive. For this reason, we have a limit on daily download.

Preview Beginning Rust: From Novice to Professional

Beginning Rust From Novice to Professional — Carlo Milanesi Beginning Rust From Novice to Professional Carlo Milanesi Beginning Rust: From Novice to Professional Carlo Milanesi Bergamo, Italy ISBN-13 (pbk): 978-1-4842-3467-9 ISBN-13 (electronic): 978-1-4842-3468-6 https://doi.org/10.1007/978-1-4842-3468-6 Library of Congress Control Number: 2018935885 Copyright © 2018 by Carlo Milanesi This work is subject to copyright. All rights are reserved 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. Trademarked names, logos, and images may appear in this book. Rather than use a trademark symbol with every occurrence of a trademarked name, logo, or image we use the names, logos, and images only in an editorial fashion and to the benefit of the trademark owner, with no intention of infringement of the trademark. The use in this publication of trade names, trademarks, service marks, and similar terms, even if they are not identified as such, is not to be taken as an expression of opinion as to whether or not they are subject to proprietary rights. While the advice and information in this book are believed to be true and accurate at the date of publication, neither the authors nor the editors nor the publisher can accept any legal responsibility for any errors or omissions that may be made. The publisher makes no warranty, express or implied, with respect to the material contained herein. Managing Director, Apress Media LLC: Welmoed Spahr Acquisitions Editor: Steve Anglin Development Editor: Matthew Moodie Coordinating Editor: Mark Powers Cover designed by eStudioCalamar Cover image designed by Freepik (www.freepik.com) Distributed to the book trade worldwide by Springer Science+Business Media New York, 233 Spring Street, 6th Floor, New York, NY 10013. Phone 1-800-SPRINGER, fax (201) 348-4505, e-mail [email protected], or visit www.springeronline.com. Apress Media, LLC is a California LLC and the sole member (owner) is Springer Science + Business Media Finance Inc (SSBM Finance Inc). SSBM Finance Inc is a Delaware corporation. For information on translations, please e-mail [email protected]; for reprint, paperback, or audio rights, please email [email protected]. Apress titles may be purchased in bulk for academic, corporate, or promotional use. eBook versions and licenses are also available for most titles. For more information, reference our Print and eBook Bulk Sales web page at http://www.apress.com/bulk-sales. Any source code or other supplementary material referenced by the author in this book is available to readers on GitHub via the book’s product page, located at www.apress.com/9781484234679. For more detailed information, please visit http://www.apress.com/source-code. Printed on acid-free paper Table of Contents About the Author ���������������������������������������������������������������������������������������������������xiii About the Technical Reviewer ���������������������������������������������������������������������������������xv Preface ������������������������������������������������������������������������������������������������������������������xvii Chapter 1: Printing on the Terminal��������������������������������������������������������������������������1 How to Start ����������������������������������������������������������������������������������������������������������������������������������1 Hello, World! ����������������������������������������������������������������������������������������������������������������������������������2 Printing Combinations of Literal Strings ���������������������������������������������������������������������������������������4 Printing Several Lines of Text ��������������������������������������������������������������������������������������������������������5 Printing Integer Numbers ��������������������������������������������������������������������������������������������������������������6 Command-Line Script �������������������������������������������������������������������������������������������������������������������7 Comments �������������������������������������������������������������������������������������������������������������������������������������8 Chapter 2: Doing Arithmetic �������������������������������������������������������������������������������������9 Adding Integer Numbers ���������������������������������������������������������������������������������������������������������������9 Other Operations Between Integer Numbers ������������������������������������������������������������������������������10 Floating-Point Arithmetic ������������������������������������������������������������������������������������������������������������11 Sequences of Statements �����������������������������������������������������������������������������������������������������������13 Breaking Literal Strings ��������������������������������������������������������������������������������������������������������������14 Chapter 3: Naming Objects �������������������������������������������������������������������������������������17 Associating Names to Values ������������������������������������������������������������������������������������������������������17 Mutable Variables �����������������������������������������������������������������������������������������������������������������������19 Not Mutated Mutable Variables ���������������������������������������������������������������������������������������������������21 Uninitialized Variables �����������������������������������������������������������������������������������������������������������������22 The Leading Underscore �������������������������������������������������������������������������������������������������������������23 iii TTaabbllee ooff CCoonnTTeennTTss Boolean Values ����������������������������������������������������������������������������������������������������������������������������25 Boolean Expressions �������������������������������������������������������������������������������������������������������������������27 Type Consistency in Assignments �����������������������������������������������������������������������������������������������28 Change of Type and of Mutability ������������������������������������������������������������������������������������������������29 Assignment Arithmetic Operators �����������������������������������������������������������������������������������������������30 Using the Functions of the Standard Library�������������������������������������������������������������������������������31 Chapter 4: Controlling Execution Flow �������������������������������������������������������������������33 Conditional Statements (if)����������������������������������������������������������������������������������������������������������33 Conditional Expressions ��������������������������������������������������������������������������������������������������������������36 Conditioned Loops (while) �����������������������������������������������������������������������������������������������������������38 Infinite Loops (loop) ��������������������������������������������������������������������������������������������������������������������40 Counting Loops (for) ��������������������������������������������������������������������������������������������������������������������40 Variables Scopes �������������������������������������������������������������������������������������������������������������������������42 Chapter 5: Using Data Sequences ���������������������������������������������������������������������������47 Arrays ������������������������������������������������������������������������������������������������������������������������������������������47 Mutable Arrays ����������������������������������������������������������������������������������������������������������������������������50 Arrays of Specified Size ��������������������������������������������������������������������������������������������������������������51 Multidimensional Arrays �������������������������������������������������������������������������������������������������������������52 Vectors ����������������������������������������������������������������������������������������������������������������������������������������53 Other Operations on Vectors �������������������������������������������������������������������������������������������������������56 Empty Arrays and Vectors �����������������������������������������������������������������������������������������������������������57 Debug Print ���������������������������������������������������������������������������������������������������������������������������������58 Copying Arrays and Vectors ��������������������������������������������������������������������������������������������������������59 Chapter 6: Using Primitive Types ����������������������������������������������������������������������������61 Non-Decimal Numeric Bases ������������������������������������������������������������������������������������������������������62 Underscore in Numeric Literals ��������������������������������������������������������������������������������������������������63 The Exponential Notation ������������������������������������������������������������������������������������������������������������64 The Various Kinds of Signed Integer Numbers ����������������������������������������������������������������������������65 iv TTaabbllee ooff CCoonnTTeennTTss Unsigned Integer Number Types �������������������������������������������������������������������������������������������������68 Target-Dependent Integer-Number Types �����������������������������������������������������������������������������������68 Type Inference �����������������������������������������������������������������������������������������������������������������������������70 The Type Inference Algorithm������������������������������������������������������������������������������������������������������72 Floating-Point Numeric Types �����������������������������������������������������������������������������������������������������73 Explicit Conversions ��������������������������������������������������������������������������������������������������������������������74 Type Suffixes of Numeric Literals �����������������������������������������������������������������������������������������������75 All the Numeric Types �����������������������������������������������������������������������������������������������������������������76 Booleans and Characters ������������������������������������������������������������������������������������������������������������77 The Empty Tuple ��������������������������������������������������������������������������������������������������������������������������79 Array and Vector Types ���������������������������������������������������������������������������������������������������������������80 Constants ������������������������������������������������������������������������������������������������������������������������������������81 Discovering the Type of an Expression ���������������������������������������������������������������������������������������81 Chapter 7: Enumerating Cases �������������������������������������������������������������������������������83 Enumerations ������������������������������������������������������������������������������������������������������������������������������83 The match Construct �������������������������������������������������������������������������������������������������������������������85 Relational Operators and Enums �������������������������������������������������������������������������������������������������87 Handling All the Cases ����������������������������������������������������������������������������������������������������������������88 Using match with Numbers ���������������������������������������������������������������������������������������������������������89 Enumerations with Data ��������������������������������������������������������������������������������������������������������������90 “match” Expressions ������������������������������������������������������������������������������������������������������������������94 Use of Guards in match Constructs ���������������������������������������������������������������������������������������������94 Chapter 8: Using Heterogeneous Data Structures ��������������������������������������������������97 The Tuples �����������������������������������������������������������������������������������������������������������������������������������97 The Structs ����������������������������������������������������������������������������������������������������������������������������������99 The Tuple-Structs ����������������������������������������������������������������������������������������������������������������������102 Lexical Conventions ������������������������������������������������������������������������������������������������������������������103 v TTaabbllee ooff CCoonnTTeennTTss Chapter 9: Defining Functions ������������������������������������������������������������������������������105 Defining and Invoking a Function����������������������������������������������������������������������������������������������105 Functions Defined After Their Use ���������������������������������������������������������������������������������������������106 Functions Shadowing Other Functions �������������������������������������������������������������������������������������107 Passing Arguments to a Function ���������������������������������������������������������������������������������������������108 Passing Arguments by Value �����������������������������������������������������������������������������������������������������110 Returning a Value from a Function �������������������������������������������������������������������������������������������111 Early Exit �����������������������������������������������������������������������������������������������������������������������������������112 Returning Several Values ����������������������������������������������������������������������������������������������������������114 How to Change a Variable of the Caller �������������������������������������������������������������������������������������115 Passing Arguments by Reference ���������������������������������������������������������������������������������������������116 Using References ����������������������������������������������������������������������������������������������������������������������118 Mutability of References �����������������������������������������������������������������������������������������������������������119 Chapter 10: Defining Generic Functions and Structs ��������������������������������������������121 Need of Generic Functions ��������������������������������������������������������������������������������������������������������121 Defining and Using Generic Functions ��������������������������������������������������������������������������������������122 Inferring the Parametric Types ��������������������������������������������������������������������������������������������������124 Defining and Using Generic Structs ������������������������������������������������������������������������������������������125 Genericity Mechanics ����������������������������������������������������������������������������������������������������������������126 Generic Arrays and Vectors �������������������������������������������������������������������������������������������������������129 Generic Enums ��������������������������������������������������������������������������������������������������������������������������129 Error Handling ���������������������������������������������������������������������������������������������������������������������������131 Enum Standard Utility Functions �����������������������������������������������������������������������������������������������133 Chapter 11: Allocating Memory ����������������������������������������������������������������������������135 The Various Kinds of Allocation �������������������������������������������������������������������������������������������������135 Linear Addressing ���������������������������������������������������������������������������������������������������������������������136 Static Allocation ������������������������������������������������������������������������������������������������������������������������138 Stack Allocation ������������������������������������������������������������������������������������������������������������������������139 Limitations of Stack Allocation ��������������������������������������������������������������������������������������������������145 vi TTaabbllee ooff CCoonnTTeennTTss Heap Allocation �������������������������������������������������������������������������������������������������������������������������148 Heap Management ��������������������������������������������������������������������������������������������������������������������149 The Behavior of Box ������������������������������������������������������������������������������������������������������������������150 Similarity with C and C++ ���������������������������������������������������������������������������������������������������������151 Boxing and Unboxing ����������������������������������������������������������������������������������������������������������������152 Register Allocation ��������������������������������������������������������������������������������������������������������������������153 Chapter 12: Data Implementation �������������������������������������������������������������������������155 Discovering the Size of Objects ������������������������������������������������������������������������������������������������155 The use Directive ����������������������������������������������������������������������������������������������������������������������156 The Sizes of the Primitive Types �����������������������������������������������������������������������������������������������157 The Representation of Primitive Types ��������������������������������������������������������������������������������������158 Location of Bytes in Memory ����������������������������������������������������������������������������������������������������159 Sizes of Composite Data Types �������������������������������������������������������������������������������������������������161 Vector Allocation �����������������������������������������������������������������������������������������������������������������������162 Chapter 13: Defining Closures ������������������������������������������������������������������������������165 The Need for “Disposable” Functions ���������������������������������������������������������������������������������������165 Capturing the Environment �������������������������������������������������������������������������������������������������������167 Closures ������������������������������������������������������������������������������������������������������������������������������������168 Other Examples �������������������������������������������������������������������������������������������������������������������������170 Chapter 14: Using Changeable Strings �����������������������������������������������������������������173 Static Strings ����������������������������������������������������������������������������������������������������������������������������173 Dynamic Strings ������������������������������������������������������������������������������������������������������������������������176 Implementation of String ����������������������������������������������������������������������������������������������������������177 Creating Strings ������������������������������������������������������������������������������������������������������������������������179 Concatenating Strings ���������������������������������������������������������������������������������������������������������������180 Chapter 15: Ranges and Slices �����������������������������������������������������������������������������183 The Ranges �������������������������������������������������������������������������������������������������������������������������������183 Passing a Sequence to a Function ��������������������������������������������������������������������������������������������185 The Slices����������������������������������������������������������������������������������������������������������������������������������187 vii TTaabbllee ooff CCoonnTTeennTTss Slicing ���������������������������������������������������������������������������������������������������������������������������������������190 Out-of-Range Slicing �����������������������������������������������������������������������������������������������������������������191 Mutable Slicing �������������������������������������������������������������������������������������������������������������������������192 Open-Ended Ranges and Slicing �����������������������������������������������������������������������������������������������193 Chapter 16: Using Iterators ����������������������������������������������������������������������������������197 String Characters ����������������������������������������������������������������������������������������������������������������������197 Scanning a String ����������������������������������������������������������������������������������������������������������������������199 Using Iterators in for Loops �������������������������������������������������������������������������������������������������������201 Iterations Without Mutation �������������������������������������������������������������������������������������������������������204 Iterations with Mutation ������������������������������������������������������������������������������������������������������������205 An Iterator Adapter: filter �����������������������������������������������������������������������������������������������������������209 The map Iterator Adapter ����������������������������������������������������������������������������������������������������������210 The enumerate Iterator Adapter ������������������������������������������������������������������������������������������������211 An Iterator Consumer: any ��������������������������������������������������������������������������������������������������������212 The all Iterator Consumer ���������������������������������������������������������������������������������������������������������214 The count Iterator Consumer ����������������������������������������������������������������������������������������������������215 The sum Iterator Consumer ������������������������������������������������������������������������������������������������������215 The min and max Iterator Consumers ���������������������������������������������������������������������������������������216 The collect Consumer ���������������������������������������������������������������������������������������������������������������217 Iterator Chains���������������������������������������������������������������������������������������������������������������������������219 Iterators Are “Lazy” �������������������������������������������������������������������������������������������������������������������220 Chapter 17: Input/Output and Error Handling �������������������������������������������������������223 Command-Line Arguments �������������������������������������������������������������������������������������������������������223 Process Return Code �����������������������������������������������������������������������������������������������������������������224 Environment Variables ��������������������������������������������������������������������������������������������������������������225 Reading from the Console ���������������������������������������������������������������������������������������������������������226 Proper Runtime Error Handling �������������������������������������������������������������������������������������������������228 Writing to the Console ���������������������������������������������������������������������������������������������������������������231 viii TTaabbllee ooff CCoonnTTeennTTss Converting a Value to a String���������������������������������������������������������������������������������������������������232 File Input/Output �����������������������������������������������������������������������������������������������������������������������233 Processing Text Files �����������������������������������������������������������������������������������������������������������������235 Chapter 18: Using Traits ���������������������������������������������������������������������������������������239 The Need for Traits ��������������������������������������������������������������������������������������������������������������������239 Traits to the Rescue ������������������������������������������������������������������������������������������������������������������242 Generic Functions with No Trait Bounds �����������������������������������������������������������������������������������244 Scope of Traits ��������������������������������������������������������������������������������������������������������������������������246 Traits with Multiple Functions ���������������������������������������������������������������������������������������������������247 Methods ������������������������������������������������������������������������������������������������������������������������������������250 The “self” and “Self” Keywords ������������������������������������������������������������������������������������������������252 Standard Traits ��������������������������������������������������������������������������������������������������������������������������254 The “Iterator” Trait ��������������������������������������������������������������������������������������������������������������������255 The “type” Keyword ������������������������������������������������������������������������������������������������������������������258 Generic Traits ����������������������������������������������������������������������������������������������������������������������������259 Using Associated Types to Simplify Generic Traits Use �������������������������������������������������������������264 The “Iterator” Standard Trait Declaration ����������������������������������������������������������������������������������267 Using Generic Iterators �������������������������������������������������������������������������������������������������������������270 Chapter 19: Object-Oriented Programming ����������������������������������������������������������273 Inherent Implementations ���������������������������������������������������������������������������������������������������������273 Peculiarities of Rust Object-Orientation ������������������������������������������������������������������������������������277 Mutating Methods ���������������������������������������������������������������������������������������������������������������������281 Constructors ������������������������������������������������������������������������������������������������������������������������������282 Composition Instead of Inheritance ������������������������������������������������������������������������������������������283 Memory Usage of Composition �������������������������������������������������������������������������������������������������286 Static Dispatch ��������������������������������������������������������������������������������������������������������������������������286 Dynamic Dispatch ���������������������������������������������������������������������������������������������������������������������290 Implementation of References to Traits ������������������������������������������������������������������������������������292 Static vs� Dynamic Dispatch �����������������������������������������������������������������������������������������������������293 ix

Description:
Learn to program with Rust in an easy, step-by-step manner on Unix, Linux shell, macOS and the Windows command line.  As you read this book, you’ll build on the knowledge you gained in previous chapters and see what Rust has to offer.  Beginning Rust starts with the basics of Rust, including ho
See more

The list of books you might like

Most books are stored in the elastic cloud where traffic is expensive. For this reason, we have a limit on daily download.