Book Image

Mastering Rust - Second Edition

By : Rahul Sharma, Vesa Kaihlavirta
Book Image

Mastering Rust - Second Edition

By: Rahul Sharma, Vesa Kaihlavirta

Overview of this book

Rust is an empowering language that provides a rare combination of safety, speed, and zero-cost abstractions. Mastering Rust – Second Edition is filled with clear and simple explanations of the language features along with real-world examples, showing you how you can build robust, scalable, and reliable programs. This second edition of the book improves upon the previous one and touches on all aspects that make Rust a great language. We have included the features from latest Rust 2018 edition such as the new module system, the smarter compiler, helpful error messages, and the stable procedural macros. You’ll learn how Rust can be used for systems programming, network programming, and even on the web. You’ll also learn techniques such as writing memory-safe code, building idiomatic Rust libraries, writing efficient asynchronous networking code, and advanced macros. The book contains a mix of theory and hands-on tasks so you acquire the skills as well as the knowledge, and it also provides exercises to hammer the concepts in. After reading this book, you will be able to implement Rust for your enterprise projects, write better tests and documentation, design for performance, and write idiomatic Rust code.

Related Content you might be interested in

Current Title:

Small book image
Mastering Rust - Second Edition
Rahul Sharma | Vesa Kaihlavirta
Jan, 2019 | 554 pages
Small book image
Mastering Rust
Vesa Kaihlavirta
May, 2017 | 354 pages
Small book image
Rust Essentials.
Ivo Balbaert
Nov, 2017 | 264 pages
Small book image
Rust High Performance
Iban Eguia Moraza
Mar, 2018 | 272 pages
Table of Contents (19 chapters)
Preface
Preface
Who this book is for
What this book covers
Getting the most out of this book
Get in touch
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
Interacting with Databases in Rust
Interacting with Databases in Rust
Why do we need data persistence?
SQLite
PostgreSQL
Connection pooling with r2d2
Postgres and the diesel ORM
Summary
15
Rust on the Web with WebAssembly
Rust on the Web with WebAssembly
What is WebAssembly?
Design goals of WebAssembly
Getting started with WebAssembly
Rust and WebAssembly
Summary
16
Building Desktop Applications with Rust
Building Desktop Applications with Rust
Introduction to GUI development
GTK+ framework
Building a hacker news app using gtk-rs
Exercise
Other emerging GUI frameworks
Summary
17
Debugging
Debugging
Introduction to debugging
RR debugger – a quick overview
Summary
18
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

Interacting with Databases in Rust

In this chapter, we'll discuss on why databases are essential to modern applications. We'll cover a few crates that are available in the Rust ecosystem, which allows one to interact with databases. We'll then continue with our linksnap API server that we developed in the previous chapter and integrate database support into it through a convenient library. This will allow us to persist new bookmarks that are sent to our API.

In this chapter, we will cover the following topics:

  • SQLite integration using rusqlite
  • Interacting with PostgreSQL with Rust
  • Database connection pooling
  • Object-relational mapping using the diesel crate
  • Integrating diesel with the linksnap API server
Previous Section
End of Section 1
Next Section