The Complete Rust Programming Reference Guide电子书

About Packt

Why subscribe?

Packt.com

Contributors

About the authors

Packt is searching for authors like you

Preface

Who this book is for

What this book covers

To get the most out of this book

Download the example code files

Conventions used

Get in touch

Reviews

Getting Started with Rust

What is Rust and why should you care?

Installing the Rust compiler and toolchain

Using rustup.rs

A tour of the language

Primitive types

Declaring variables and immutability

Functions

Closures

Strings

Conditionals and decision making

Match expressions

Loops

User-defined types

Structs

Enums

Functions and methods on types

Impl blocks on structs

Impl blocks for enums

Modules, imports, and use statements

Collections

Arrays

Tuples

Vectors

Hashmaps

Slices

Iterators

Exercise – fixing the word counter

Summary

Managing Projects with Cargo

Package managers

Modules

Nested modules

File as a module

Directory as module

Cargo and crates

Creating a new Cargo project

Cargo and dependencies

Running tests with Cargo

Running examples with Cargo

Cargo workspace

Extending Cargo and tools

Subcommands and Cargo installation

cargo-watch

cargo-edit

cargo-deb

cargo-outdated

Linting code with clippy

Exploring the manifest file – Cargo.toml

Setting up a Rust development environment

Building a project with Cargo – imgtool

Summary

Tests, Documentation, and Benchmarks

Motivation for testing

Organizing tests

Testing primitives

Attributes

Assertion macros

Unit tests

First unit test

Running tests

Isolating test code

Failing tests

Ignoring tests

Integration tests

First integration test

Sharing common code

Documentation

Writing documentation

Generating and viewing documentation

Hosting documentation

Doc attributes

Documentation tests

Benchmarks

Built-in micro-benchmark harness

Benchmarking on stable Rust

Writing and testing a crate – logic gate simulator

Continuous integration with Travis CI

Summary

Types, Generics, and Traits

Type systems and why they matter

Generics

Creating generic types

Generic functions

Generic types

Generic implementations

Using generics

Abstracting behavior with traits

Traits

The many forms of traits

Marker traits

Simple traits

Generic traits

Associated type traits

Inherited traits

Using traits with generics – trait bounds

Trait bounds on types

Trait bounds on generic functions and impl blocks

Using + to compose traits as bounds

Trait bounds with impl trait syntax

Exploring standard library traits

True polymorphism using trait objects

Dispatch

Trait objects

Summary

Memory Management and Safety

Programs and memory

How do programs use memory?

Memory management and its kinds

Approaches to memory allocation

The stack

The heap

Memory management pitfalls

Memory safety

Trifecta of memory safety

Ownership

A brief on scopes

Move and copy semantics

Duplicating types via traits

Copy

Clone

Ownership in action

Borrowing

Borrowing rules

Borrowing in action

Method types based on borrowing

Lifetimes

Lifetime parameters

Lifetime elision and the rules

Lifetimes in user defined types

Lifetime in impl blocks

Multiple lifetimes

Lifetime subtyping

Specifying lifetime bounds on generic types

Pointer types in Rust

References – safe pointers

Raw pointers

Smart pointers

Drop

Deref and DerefMut

Types of smart pointers

Box<T>

Reference counted smart pointers

Rc<T>

Interior mutability

Cell<T>

RefCell<T>

Uses of interior mutability

Summary

Error Handling

Error handling prelude

Recoverable errors

Option

Result

Combinators on Option/Result

Common combinators

Using combinators

Converting between Option and Result

Early returns and the ? operator

Non-recoverable errors

User-friendly panics

Custom errors and the Error trait

Summary

Advanced Concepts

Type system tidbits

Blocks and expressions

Let statements

Loop as an expression

Type clarity and sign distinction in numeric types

Type inference

Type aliases

Strings

Owned strings – String

Borrowed strings – &str

Slicing and dicing strings

Using strings in functions

Joining strings

When to use &str versus String ?

Global values

Constants

Statics

Compile time functions – const fn

Dynamic statics using the lazy_static! macro

Iterators

Implementing a custom iterator

Advanced types

Unsized types

Function types

Never type ! and diverging functions

Unions

Cow

Advanced traits

Sized and ?Sized

Borrow and AsRef

ToOwned

From and Into

Trait objects and object safety

Universal function call syntax

Trait rules

Closures in depth

Fn closures

FnMut closures

FnOnce closures

Consts in structs, enums, and traits

Modules, paths, and imports

Imports

Re-exports

Selective privacy

Advanced match patterns and guards

Match guards

Advanced let destructure

Casting and coercion

Types and memory

Memory alignment

Exploring the std::mem module

Serialization and deserialization using serde

Summary

Concurrency

Program execution models

Concurrency

Approaches to concurrency

Kernel-based

User-level

Pitfalls

Concurrency in Rust

Thread basics

Customizing threads

Accessing data from threads

Concurrency models with threads

Shared state model

Shared ownership with Arc

Mutating shared data from threads

Mutex

Shared mutability with Arc and Mutex

RwLock

Communicating through message passing

Asynchronous channels

Synchronous channels

thread-safety in Rust

What is thread-safety?

Traits for thread-safety

Send

Sync

Concurrency using the actor model

Other crates

Summary

Metaprogramming with Macros

What is metaprogramming?

When to use and not use Rust macros

Macros in Rust and their types

Types of macros

Creating your first macro with macro_rules!

Built-in macros in the standard library

macro_rules! token types

Repetitions in macros

A more involved macro – writing a DSL for HashMap initialization

Macro use case – writing tests

Exercises

Procedural macros

Derive macros

Debugging macros

Useful procedural macro crates

Summary

Unsafe Rust and Foreign Function Interfaces

What is safe and unsafe really?

Unsafe functions and blocks

Unsafe traits and implementations

Calling C code from Rust

Calling Rust code from C

Using external C/C++ libraries from Rust

Creating native Python extensions with PyO3

Creating native extensions in Rust for Node.js

Summary

Logging

What is logging and why do we need it?

The need for logging frameworks

Logging frameworks and their key features

Approaches to logging

Unstructured logging

Structured logging

Logging in Rust

log – Rust's logging facade

The env_logger

log4rs

Structured logging using slog

Summary

Network Programming in Rust

Network programming prelude

Synchronous network I/O

Building a synchronous redis server

Asynchronous network I/O

Async abstractions in Rust

Mio

Futures

Tokio

Building an asynchronous redis server

Summary

Building Web Applications with Rust

Web applications in Rust

Typed HTTP with Hyper

Hyper server APIs – building a URL shortener

hyper as a client – building a URL shortener client

Web frameworks

Actix-web basics

Building a bookmarks API using Actix-web

Summary

Lists, Lists, and More Lists

Linked lists

A transaction log

Adding entries

Log replay

After use

Wrap up

Upsides

Downsides

Doubly linked list

A better transaction log

Examining the log

Reverse

Wrap up

Upsides

Downsides

Skip lists

The best transaction log

The list

Adding data

Leveling up

Jumping around

Thoughts and discussion

Upsides

Downsides

Dynamic arrays

Favorite transactions

Internal arrays

Quick access

Wrap up

Upsides

Downsides

Summary

Further reading

Robust Trees

Binary search tree

IoT device management

More devices

Finding the right one

Finding all devices

Wrap up

Upsides

Downsides

Red-black tree

Better IoT device management

Even more devices

Balancing the tree

Finding the right one, now

Wrap up

Upsides

Downsides

Heaps

A huge inbox

Getting messages in

Taking messages out

Wrap up

Upsides

Downsides

Trie

More realistic IoT device management

Adding paths

Walking

Wrap up

Upsides

Downsides

B-Tree

An IoT database

Adding stuff

Searching for stuff

Walking the tree

Wrap up

Upsides

Downsides

Graphs

The literal Internet of Things

Neighborhood search

The shortest path

Wrap up

Upsides

Downsides

Summary

Exploring Maps and Sets

Hashing

Create your own

Message digestion

Wrap up

Maps

A location cache

The hash function

Adding locations

Fetching locations

Wrap up

Upsides

Downsides

Sets

Storing network addresses

Networked operations

Union

Intersection

Difference

Wrap up

Upsides

Downsides

Summary

Further reading

Collections in Rust

Sequences

Vec<T> and VecDeque<T>

Architecture

Insert

Look up

Remove

LinkedList<T>

Architecture

Insert

Look up

Remove

Wrap up

Maps and sets

HashMap and HashSet

Architecture

Insert

Lookup

Remove

BTreeMap and BTreeSet

Architecture

Insert

Look up

Remove

Wrap up

Summary

Further reading

Algorithm Evaluation

The Big O notation

Other people's code

The Big O

Asymptotic runtime complexity

Making your own

Loops

Recursion

Complexity classes

O(1)

O(log(n))

O(n)

O(n log(n))

O(n²)

O(2n)

Comparison

In the wild

Data structures

Everyday things

Exotic things

Summary

Further reading

Ordering Things

From chaos to order

Bubble sort

Shell sort

Heap sort

Merge sort

Quicksort

Summary

Further reading

Finding Stuff

Finding the best

Linear searches

Jump search

Binary searching

Wrap up

Summary

Further reading

Random and Combinatorial

Pseudo-random numbers

LCG

Wichmann-Hill

The rand crate

Back to front

Packing bags or the 0-1 knapsack problem

N queens

Advanced problem solving

Dynamic programming

The knapsack problem improved

Metaheuristic approaches

Example metaheuristic – genetic algorithms

Summary

Further reading

Algorithms of the Standard Library

Slicing and iteration

Iterator

Slices

Search

Linear search

Binary search

Sorting

Stable sorting

Unstable sorting

Summary

Further reading

Other Books You May Enjoy

Leave a review - let other readers know what you think