Rust In Practice, Second Edition: A Programmers Guide to Build Rust Programs, Test Applications and Create Cargo Packages

By Rick Tim, Ralph J and B Anderson

Learn to Build Rust Programs, Test Applications and Create Your Own Cargo Packages with latest Rust 1.77

"Rust In Practice, Second Edition" is an updated book that builds on the previous edition's excellent foundation and is intended to help readers progress from novice to proficient Rust developers. This new

• Language: English
• Publisher: GitforGits
• Release date: Apr 19, 2024
• ISBN: 9788119177394

Book preview

Rust In Practice

A Programmers Guide to Build Rust Programs, Test Applications and Create Cargo Packages

(Second Edition)

Rick Tim

Preface

Rust In Practice, Second Edition is an updated book that builds on the previous edition's excellent foundation and is intended to help readers progress from novice to proficient Rust developers. This new version goes deeper into Rust's core and advanced capabilities, making it suitable for learners at all levels.

Beginning with a basic introduction to Rust syntax and semantics, the Second Edition provides a clearer and more detailed explanation of Rust's distinctive ownership model and type system. Readers will thoroughly explore control flow, error management, and Rust's main data types, laying a solid foundation for more advanced topics.

The book includes additional chapters on smart pointers, sophisticated error handling techniques, and the complexities of concurrency and parallelism, which address real-world programming issues. The book covers how to incorporate asynchronous programming features into projects, how to utilize and maintain Cargo, and a more in-depth look at Rust's standard library and the external crates ecosystem.

Rust In Practice, Second Edition is intended to serve as both a learning tool and a reference for developing high-performance applications. It is packed with professional advice, clear explanations, and practical examples. This book will not only teach you Rust programming, but it will also help you design software that is strong, simple, efficient, and easily maintainable.

In this book you will learn how to:

Master Cargo and its extensive command suite to streamline project builds and dependency management.

Deepen your grasp of Rust’s type system, emphasizing ownership and borrowing to efficiently manage memory.

Utilize advanced traits and generics to create flexible, reusable software components.

Leverage closures, iterators, and asynchronous programming for high-performance, multi-threaded applications.

Utilize collections, enhance string operations, and execute effective I/O.

Explore sophisticated macro usage for metaprogramming and strategies to avoid unsafe code.

75+ practical examples showcasing Rust's latest features and best practices.

Apply rigorous testing methods across diverse Rust applications, with new testing frameworks and methodologies.

Prologue

As the proud author of Rust In Practice, Second Edition, I am overjoyed to take you on a journey through the updated and enlarged review of Rust, a programming language that has had a profound impact on the world right now. This book expands on the topics covered in the first edition, going deeper into practical applications and exploring new features that help Rust mature into a strong tool for system-level programming and beyond.

From the start, my goal was to provide both novice and seasoned developers with a complete overview of Rust's possibilities through a practical lens. We begin by covering Rust's fundamentals—ownership, borrowing, and the type system—which are critical to understanding how Rust achieves memory safety without a garbage collector. Each chapter is designed to build on previous knowledge, ensuring that you understand both the theory and application of Rust's key principles.

We then progress to more difficult topics such as error handling, smart pointers, concurrency, and advanced characteristics. Each topic is supported by real-world examples that show how Rust may be used to build efficient, reliable, and maintainable applications. I've also added a new section on asynchronous programming, which reflects Rust's continued progress in handling concurrent processes more smoothly and effectively.

A key addition to this edition is the in-depth look at Rust's ecosystem, which includes Cargo, Crates, and the huge standard library. Understanding these tools will

help you realize Rust's full potential, whether you're creating basic utilities or big software systems.

As we conclude with smart pointers and reference cycles, I highlight Rust's distinct approach to memory management, which is both a problem and an asset in learning the language. In the latter chapters, you will find examples and exercises that will help you understand Rust better and give you the confidence to use it in your own projects or as part of your contributions to open-source software.

Rust In Practice, Second Edition is more than simply a guidebook; it's an exploration of a language that stresses safety, speed, and concurrency. It is intended for developers who are interested in furthering their Rust knowledge, as well as those who are just getting started but want to go deep. As we conclude, I hope it serves not just as an educational resource, but also as an illustration to which you will return as you progress in your Rust adventure. The future of system programming is bright, so long as we continue to produce stable software that challenges conventional wisdom.

Copyright © 2024 by GitforGits

All rights reserved. This book is protected under copyright laws and no part of it may be reproduced or transmitted in any form or by any means, electronic or mechanical, including photocopying, recording, or by any information storage and retrieval system, without the prior written permission of the publisher. Any unauthorized reproduction, distribution, or transmission of this work may result in civil and criminal penalties and will be dealt with in the respective jurisdiction at anywhere in India, in accordance with the applicable copyright laws.

Published by: GitforGits

Publisher: Sonal Dhandre

www.gitforgits.com

[e-mail]

Printed in India

First Printing: April 2024

Cover Design by: Kitten Publishing

For permission to use material from this book, please contact GitforGits at [e-mail].

Content

Preface

Acknowledgement

Chapter 1: Why Rust?

Why Rust?

Rust Over Other Programming Languages?

Why Choose Rust Over Python?

Performance

Concurrency

Memory Management

Safety

Why Rust Over C++?

Memory Safety

Modern Tooling

Concurrency

Community and Modern Practices

Why Rust Over Go?

Zero-Cost Abstractions

Memory Safety and Fine-Grained Control

Type System and Generics

Advanced Features

Rust Syntax

Variables

Functions

Control Flow

Structs

Traits

Writing ‘Hello world’

My First Program: A Simple Calculator

Setting up the Project

Writing Main Program

Implementing Calculation Logic

Testing the Calculator

Summary

Chapter 2: Getting Ready with Rust Environment

Introduction

Setting up Rust on Windows

Downloading and Installing Rust

Verifying the Installation

Setting up Development Environment

Creating first Rust Project

Building and Running Project

Setting up Rust on Linux

Updating System

Installing Build Essentials

Installing Rust using Rustup

Verifying Rust Installation

Setting up Environment Path

Installing Crates and Cargo on Windows

Installing Rust Compiler

Setting up Rust Environment

Verifying Cargo Installation

Using Cargo to Install Crates

Include Crates in Project

Installing Crates and Cargo on Linux

Installing Crate with Cargo

Using Crate in Project

Installing Visual Studio (VS) Code on Window

Downloading and Installing VS Code

Installing Rust Extension in VS Code

Configuring Rust Extension

Testing Setup

Installing VS Code on Linux

Downloading VS Code

Installing VS Code

Installing Rust Extension

Configuring Rust Extension

Testing Installation

Using Crate ‘clap’ for Calculator Program

Setting up the Project

Adding Dependencies

Writing Calculator Program

Running the Program

Summary

Chapter 3: Most Essentials of Rust

Introduction

Variables

Immutable Variables

Mutable Variables

Delayed Assignment

Specifying Type Annotations

Variable Shadowing

Constants

Example of Constants

Characteristics of Constants

Constants Vs Immutable Variables

Sample Program

Shadowing Vs Mutability

Shadowing

Mutability

Choosing Between Shadowing and Mutability

Functions

Types of Functions

Free Functions

Method Functions

Closure Functions

Generator Functions

Writing a Rust Function

Calling the Function

Coding a Function with an Iterator

Sample Program: Summing Values with an Iterator

Passing Function As Arguments

Function as Arguments

Using Function

Nested Function (Function Within Function)

Overview

Sample Program

Built-In Functions

Overview

Built-In Functions/Macros In Use

Sample Program

If Statements

Overview

Sample Program

How It Works?

Random Number Generation

Conditional Branching

Execution Flow

Loop Statements

Overview

Sample Program

While Statements

Overview

Sample Program

Example 1: Counting from 1 to 10

Example 2: Calculating the Sum of a Vector

Key Points

For Statements

Overview

Sample Program: Iterate through Range

Sample Program: Iterating Over an Array

Advantages

Match Expression

Overview

Sample Program

Advantages

Traits Basics

Overview

Working of Traits

Trait Usage

Advantages

Sample Program: Traits for Dynamic Dispatch

Types of Traits

Basic Traits

Marker Traits

Generic Traits with Associated Types

Operator Overloading Traits

Trait Objects for Dynamic Dispatch

Do’s and Don'ts

Do’s of Traits

Define Common Behaviors

Utilize Associated Types

Specify Type Bounds

Implement Traits with impl

Don'ts of Trait

Overuse Single-Method Traits

Misuse Traits as Types

Inappropriately Use Traits in Function Signatures

Avoid Mutable Methods in Traits

Sample Program: Using Traits Effectively

Unions

Defining Unions

Types of Unions

Enumerations

Structs

Arrays

Implementing Unions

Define the Union

Create an Instance

Access the Union Fields

Modify the Fields

Implementation Summary

Summary

Chapter 4: Structs

Introduction

Understanding Structs

Definition and Usage

Advantages

Types of Structs

Tuple Structs

Unit-Like Structs

Classic C-Style Structs

Writing Program Using Struct

Using Custom Structs

Writing Custom Struct Program

Sample Program: Custom Struct for Rectangle

Key Features and Advantages

Writing a Nested Structs

Example of Nested Structs in Rust

Benefits

Struct Inheritance

Sample Program: Composition for Struct Inheritance

Using Traits for Inheritance-like Behavior

Do’s and Don'ts

Do's of Using Structs

Use Structs for Fixed Data Structures

Use Named Fields for Clarity

Add Behavior with Methods

Use Associated Functions for Construction

Implement Impl Blocks

Consider Composition for Reuse

Use Trait Objects for Flexibility

Don'ts of Using Structs

Avoid Structs for Variable Data Structures

Avoid Anonymous Fields

Avoid Unnecessary Mutation

Manage Lifetime of References Carefully

Summary

Chapter 5: Enums and Pattern Matching

Introduction

Enum Basics

Definition

Enum with Associated Data

Enum Methods

Pattern Matching

Overview

Key Features

Advantages of Enum and Pattern Matching

Type Safety

Readability

Conciseness

‘match’ Expression

Matching Multiple Patterns

Matching Ranges

Destructuring for Pattern Matching

Guards in Match Arms

Matching on References

Using Control Flow

Using if let for Simple Matching

Using match for Comprehensive Pattern Matching

Control Flow with Enums having Associated Data

Do's and Don'ts

Do's of Enum and Pattern Matching

Use Enums for Defined States

Leverage Pattern Matching for Clarity

Use a Catch-All Pattern

Use if let for Single Matches

Don'ts of Enum and Pattern Matching

Don't Omit the Catch-All Pattern

Avoid Side Effects in Match Arms

Summary

Chapter 6: Exploring Ownership and Borrowing

Introduction

Ownership Basics

What is Ownership?

Features of Ownership

Memory Safety without Garbage Collection

Prevention of Data Races

Efficient Memory Use

Ownership Transfer

Copy Trait

Borrowing Overview

Immutable Borrowing

Mutable Borrowing

Rules of Borrowing

Lifetimes

Stack-allocated Variables and References

Stack-Allocated Variables

Characteristics of Stack-Allocated Variables

References

Sample Program

Libraries adopting Ownership and Borrowing

The Rust Standard Library

Serde

Rayon

Tokio

Diesel

Summary

Chapter 7: Cargo, Crates and Packages

Introduction

Understanding Cargo

Cargo's Key Features

Crate Dependencies Management

Build Automation

Testing Facilitation

Documentation Generation

Package Publishing

Sample Program

Crates Basics

Binary Crates

Library Crates

Sample Program: Using a Crate

Understanding Packages

Key Components of a Rust Package

Cargo.toml

src Folder

Target Directory

Creating and Configuring a Package

Sample Program: Using Package and Adding Dependency

Cargo vs Crates vs Packages

Cargo

Crates

Packages

Creating My First Crate

Sample Program: Creating a Library Crate

Creating the Crate

Project Structure

Developing Your Crate

Testing and Document

Publishing the Crate

Best Practices

Build My First Package

Basic Build

Release Build

Checking Build Feasibility₹

Understanding the Build Output

Debugging Build Issues

Incremental Compilation

Package and Dependency Management

Publish the Package

Cargo.toml Configuration

Documentation and Readme

Authentication

Testing and Validation

Versioning

Publishing the Crate

Post-Publication

Role of Modules and Paths

Understanding Modules in Rust

Using ‘use’ Keyword

Nested Modules

Understanding Paths

Summary

Chapter 8: Cargo Commands

Introduction

General Commands

Creating and Initializing Projects

Checking and Building Projects

Running Projects

Testing Projects

Cleaning up Build Files

Viewing Documentation Locally

Build Commands

cargo build

cargo build --release

cargo check

cargo clean

Manifest Commands

cargo metadata

cargo pkgid

cargo tree

cargo vendor

Package and Publish Commands

cargo package

cargo publish

Custom Commands

Creating Custom Commands

Deploying Custom Commands

Integrating with Build Processes

Summary

Chapter 9: Rust Standard Library

Introduction

Rust Standard Library (std)

Modules and Functionalities

std::collections

Initialization and Insertion

Accessing Values

Updating Entries

Handling Missing Entries

Iteration

Sample Program

std::error

Simplifying Error Handling

Sample Program

std::net

Setting up a Listener

Handling Incoming Connections

Reading and Writing

Responding to Clients

Error Handling

Sample Program

std::sync

Arc and Mutex

Sample Program

std::time

Key Components

Sample Program

Key Concepts

std::env

Key Functions

Sample Program

How It Works?

Sample Program

std::fmt

Customizing Textual Output

Sample Program

Key Elements

std::str

Key Functions

Sample Program

std::iter

Core Concepts

Sample Program

std::ops

Overview

Sample Program

Key Learning

std::fs

Basic File Reading

Writing to a File

Handling Errors with ?

Modifying File Metadata

Primitive Types

Understanding Rust's Primitive Types

Boolean (bool)

Characters (char)

Integer Types

Floating-Point Types (f32,