Book Image

The Complete Rust Programming Reference Guide

By : Rahul Sharma, Vesa Kaihlavirta, Claus Matzinger
Book Image

The Complete Rust Programming Reference Guide

By: Rahul Sharma, Vesa Kaihlavirta, Claus Matzinger

Overview of this book

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

Related Content you might be interested in

Current Title:

Small book image
The Complete Rust Programming Reference Guide
Rahul Sharma | Vesa Kaihlavirta | Claus Matzinger
May, 2019 | 11 hours 38 minutes
No titles found
Table of Contents (29 chapters)
Title Page
Title Page
Copyright
Copyright
About Packt
About Packt
Contributors
Contributors
Preface
Preface
Free Chapter
1
Getting Started with Rust
Getting Started with Rust
What is Rust and why should you care?
Installing the Rust compiler and toolchain
A tour of the language
Exercise – fixing the word counter
Summary
2
Managing Projects with Cargo
Managing Projects with Cargo
Package managers
Modules
Cargo and crates
Extending Cargo and tools
Setting up a Rust development environment
Building a project with Cargo – imgtool
Summary
3
Tests, Documentation, and Benchmarks
Tests, Documentation, and Benchmarks
Motivation for testing
Organizing tests
Unit tests
Integration tests
Documentation
Benchmarks
Writing and testing a crate – logic gate simulator
Continuous integration with Travis CI
Summary
4
Types, Generics, and Traits
Types, Generics, and Traits
Type systems and why they matter
Generics
Abstracting behavior with traits
Using traits with generics – trait bounds
Exploring standard library traits
True polymorphism using trait objects
Summary
5
Memory Management and Safety
Memory Management and Safety
Programs and memory
How do programs use memory?
Memory management and its kinds
Approaches to memory allocation
Memory management pitfalls
Memory safety
Trifecta of memory safety
Pointer types in Rust
Summary
6
Error Handling
Error Handling
Error handling prelude
Recoverable errors
Combinators on Option/Result
Early returns and the ? operator
Non-recoverable errors
Custom errors and the Error trait
Summary
7
Advanced Concepts
Advanced Concepts
Type system tidbits
Strings
Global values
Iterators
Advanced types
Advanced traits
Closures in depth
Consts in structs, enums, and traits
Modules, paths, and imports
Advanced match patterns and guards
Casting and coercion
Types and memory
Serialization and deserialization using serde
Summary
8
Concurrency
Concurrency
Program execution models
Concurrency
Concurrency in Rust
Concurrency models with threads
thread-safety in Rust
Concurrency using the actor model
Other crates
Summary
9
Metaprogramming with Macros
Metaprogramming with Macros
What is metaprogramming?
When to use and not use Rust macros
Macros in Rust and their types
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
10
Unsafe Rust and Foreign Function Interfaces
Unsafe Rust and Foreign Function Interfaces
What is safe and unsafe really?
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
11
Logging
Logging
What is logging and why do we need it?
The need for logging frameworks
Logging frameworks and their key features
Approaches to logging
Logging in Rust
Summary
12
Network Programming in Rust
Network Programming in Rust
Network programming prelude
Synchronous network I/O
Asynchronous network I/O
Summary
13
Building Web Applications with Rust
Building Web Applications with Rust
Web applications in Rust
Typed HTTP with Hyper
Actix-web basics
Building a bookmarks API using Actix-web
Summary
14
Lists, Lists, and More Lists
Lists, Lists, and More Lists
Linked lists
Doubly linked list
Skip lists
Dynamic arrays
Summary
Further reading
15
Robust Trees
Robust Trees
Binary search tree
Red-black tree
Heaps
Trie
B-Tree
Graphs
Summary
16
Exploring Maps and Sets
Exploring Maps and Sets
Hashing
Maps
Sets
Summary
Further reading
17
Collections in Rust
Collections in Rust
Sequences
Maps and sets
Summary
Further reading
18
Algorithm Evaluation
Algorithm Evaluation
The Big O notation
In the wild
Summary
Further reading
19
Ordering Things
Ordering Things
From chaos to order
Summary
Further reading
20
Finding Stuff
Finding Stuff
Finding the best
Summary
Further reading
21
Random and Combinatorial
Random and Combinatorial
Pseudo-random numbers
Back to front
Advanced problem solving
Summary
Further reading
22
Algorithms of the Standard Library
Algorithms of the Standard Library
Slicing and iteration
Search
Sorting
Summary
Further reading
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think
Index
Index

Advanced match patterns and guards

In this section, we'll take a look at some of the advanced usage of match and let patterns. First, let's look at match.

Match guards

We can also use match guards on arms (if code > 400 || code <= 500) to match on a subset of values. They start with an if expression.

Advanced let destructure

We have the following complex data that we want to match against:

// complex_destructure.rs

enum Foo {
    One, Two, Three
}

enum Bar(Foo);

struct Dummy {
    inner: Bar
}

struct ComplexStruct {
    obj: Dummy
}

fn get_complex_struct() -> ComplexStruct {
    ComplexStruct {
        obj: Dummy { inner: Bar(Foo::Three) }
    }
}

fn main() {
    let a = get_complex_struct();
}
Previous Section
End of Section 11
Next Section