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

Description

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 applicationWho 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 Getting Started with Rust Managing Projects with Cargo Tests, Documentation, and Benchmarks Types, Generics, and Traits Memory Management and Safety Error Handling Advanced Concepts Concurrency Metaprogramming with Macros Unsafe Rust and Foreign Function Interfaces Logging Network Programming in Rust Building Web Applications with Rust Lists, Lists, and More Lists Robust Trees Exploring Maps and Sets Collections in Rust Algorithm Evaluation Ordering Things Finding Stuff Random and Combinatorial Algorithms of the Standard Library 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