The Complete Rust Programming Reference Guide: Design, develop, and deploy effective software systems using the advanced constructs of Rust

This document was uploaded by one of our users. The uploader already confirmed that they had the permission to publish it. If you are author/publisher or own the copyright of this documents, please report to us by using this DMCA report form.

Simply click on the Download Book button.

Yes, Book downloads on Ebookily are 100% Free.

Sometimes the book is free on Amazon As well, so go ahead and hit "Search on Amazon"

Design and implement professional-level programs by leveraging modern data structures and algorithms in Rust

Key Features

  • Improve your productivity by writing more simple and easy code in Rust
  • Discover the functional and reactive implementations of traditional data structures
  • Delve into new domains of Rust, including WebAssembly, networking, and command-line tools

Book Description

Rust is a powerful language with a rare combination of safety, speed, and zero-cost abstractions. This Learning Path is filled with clear and simple explanations of its features along with real-world examples, demonstrating how you can build robust, scalable, and reliable programs.

You'll get started with an introduction to Rust data structures, algorithms, and essential language constructs. Next, you will understand how to store data using linked lists, arrays, stacks, and queues. You'll also learn to implement sorting and searching algorithms, such as Brute Force algorithms, Greedy algorithms, Dynamic Programming, and Backtracking. As you progress, you'll pick up on using Rust for systems programming, network programming, and the web. You'll then move on to discover a variety of techniques, right from writing memory-safe code, to building idiomatic Rust libraries, and even advanced macros.

By the end of this Learning Path, you'll be able to implement Rust for enterprise projects, writing better tests and documentation, designing for performance, and creating idiomatic Rust code.

This Learning Path includes content from the following Packt products:

  • Mastering Rust - Second Edition by Rahul Sharma and Vesa Kaihlavirta
  • Hands-On Data Structures and Algorithms with Rust by Claus Matzinger

What you will learn

  • Design and implement complex data structures in Rust
  • Create and use well-tested and reusable components with Rust
  • Understand the basics of multithreaded programming and advanced algorithm design
  • Explore application profiling based on benchmarking and testing
  • Study and apply best practices and strategies in error handling
  • Create efficient web applications with the Actix-web framework
  • Use Diesel for type-safe database interactions in your web application

Who this book is for

If you are already familiar with an imperative language and now want to progress from being a beginner to an intermediate-level Rust programmer, this Learning Path is for you. Developers who are already familiar with Rust and want to delve deeper into the essential data structures and algorithms in Rust will also find this Learning Path useful.

Table of Contents

  1. Getting Started with Rust
  2. Managing Projects with Cargo
  3. Tests, Documentation, and Benchmarks
  4. Types, Generics, and Traits
  5. Memory Management and Safety
  6. Error Handling
  7. Advanced Concepts
  8. Concurrency
  9. Metaprogramming with Macros
  10. Unsafe Rust and Foreign Function Interfaces
  11. Logging
  12. Network Programming in Rust
  13. Building Web Applications with Rust
  14. Lists, Lists, and More Lists
  15. Robust Trees
  16. Exploring Maps and Sets
  17. Collections in Rust
  18. Algorithm Evaluation
  19. Ordering Things
  20. Finding Stuff
  21. Random and Combinatorial
  22. Algorithms of the Standard Library

Author(s): Rahul Sharma, Vesa Kaihlavirta, Claus Matzinger
Publisher: Packt Publishing
Year: 2019

Language: English
Commentary: True PDF
Pages: 698

Cover
Title Page
Copyright
About Packt
Contributors
Table of Contents
Preface
Chapter 1: 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
Chapter 2: 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
Chapter 3: 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
Chapter 4: 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
Chapter 5: 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
Reference counted smart pointers
Rc
Interior mutability
Cell
RefCell
Uses of interior mutability
Summary
Chapter 6: 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
Chapter 7: 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
Chapter 8: 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
Chapter 9: 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
Chapter 10: 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
Chapter 11: 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
Chapter 12: 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
Chapter 13: 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
Chapter 14: 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
Chapter 15: 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
Chapter 16: 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
Chapter 17: Collections in Rust
Sequences
Vec and VecDeque
Architecture
Insert
Look up
Remove
LinkedList
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
Chapter 18: 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
Chapter 19: Ordering Things
From chaos to order
Bubble sort
Shell sort
Heap sort
Merge sort
Quicksort
Summary
Further reading
Chapter 20: Finding Stuff
Finding the best
Linear searches
Jump search
Binary searching
Wrap up
Summary
Further reading
Chapter 21: 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
Chapter 22: 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
Index