Book Image

Rust Programming Cookbook

By : Claus Matzinger

Book Image

Rust Programming Cookbook

By: Claus Matzinger

Overview of this book

Rust 2018, Rust's first major milestone since version 1.0, brings more advancement in the Rust language. The Rust Programming Cookbook is a practical guide to help you overcome challenges when writing Rust code. This Rust book covers recipes for configuring Rust for different environments and architectural designs, and provides solutions to practical problems. It will also take you through Rust's core concepts, enabling you to create efficient, high-performance applications that use features such as zero-cost abstractions and improved memory management. As you progress, you'll delve into more advanced topics, including channels and actors, for building scalable, production-grade applications, and even get to grips with error handling, macros, and modularization to write maintainable code. You will then learn how to overcome common roadblocks when using Rust for systems programming, IoT, web development, and network programming. Finally, you'll discover what Rust 2018 has to offer for embedded programmers. By the end of the book, you'll have learned how to build fast and safe applications and services using Rust.

Preface

Who this book is for

What this book covers

To get the most out of this book

Free Chapter

Starting Off with Rust

Starting Off with Rust

Setting up your environment

Working with the command line I/O

Creating and using data types

Controlling execution flow

Splitting your code with crates and modules

Writing tests and benchmarks

Documenting your code

Testing your documentation

Sharing code among types

Sequence types in Rust

Going Further with Advanced Rust

Going Further with Advanced Rust

Creating meaningful numbers with enums

There is no null

Complex conditions with pattern matching

Implementing custom iterators

Filtering and transforming sequences efficiently

Reading memory the unsafe way

Shared ownership

Shared mutable ownership

Referencing with explicit lifetimes

Enforcing behavior with trait bounds

Working with generic data types

Managing Projects with Cargo

Managing Projects with Cargo

Organizing large projects with workspaces

Uploading to crates.io

Using dependencies and external crates

Extending cargo with sub-commands

Testing your project with cargo

Continuous integration with cargo

Customizing the build

Fearless Concurrency

Fearless Concurrency

Moving data into new threads

Managing multiple threads

Using channels to communicate between threads

Sharing mutable states

Multiprocessing in Rust

Making sequential code parallel

Concurrent data processing in vectors

Shared immutable states

Handling asynchronous messages with actors

Asynchronous programming with futures

Handling Errors and Other Results

Handling Errors and Other Results

Panicking responsibly

Handling multiple errors

Working with exceptional results

Seamless error handling

Customizing errors

Resilient programming

Working with external crates for error handling

Moving between Option and Result

Expressing Yourself with Macros

Expressing Yourself with Macros

Building custom macros in Rust

Implementing matching with macros

Using predefined macros

Code generation using macros

Macro overloading

Using repeat for parameter ranges

Don't Repeat Yourself

Integrating Rust with Other Languages

Integrating Rust with Other Languages

Including legacy C code

Calling into Rust from Node.js using FFI

Running Rust in the browser

Using Rust and Python

Generating bindings for legacy applications

Safe Programming for the Web

Safe Programming for the Web

Setting up a web server

Designing a RESTful API

Handling JSON payloads

Web error handling

Rendering HTML templates

Using an ORM to save data to a database

Running advanced queries using an ORM

Authentication on the web

Systems Programming Made Easy

Systems Programming Made Easy

Cross-compiling Rust

Creating I2C device drivers

Efficiently reading hardware sensors

Getting Practical with Rust

Getting Practical with Rust

Generating random numbers

Writing to and reading from files

Parsing unstructured formats like JSON

Extract text using regular expressions

Recursively searching the filesystem

Custom command-line arguments

Working with piped input data

Sending web requests

Running machine learning models

Configuring and using logging

Starting subprocesses

Other Books You May Enjoy

Other Books You May Enjoy

Leave a review - let other readers know what you think

Customer Reviews

5 star

0

4 star

0

3 star

0

2 star

0

1 star

0

Systems Programming Made Easy

Rust was originally envisioned as a systems programming language in the same way as C (and maybe C++). Although its appeal led to significant growth outside this field (somewhat like C/C++), there are still many features that significantly facilitate working on low-level projects. We suspect that the novelty aspect (as well as the powerful compiler, error messages, and community) led to very interesting projects in that space—such as operating systems. One of them is intermezzOS (https://intermezzos.github.io/), an operating system for learning programming (in Rust); another is Redox OS (https://www.redox-os.org/), a microkernel effort in pure Rust. However, it doesn't stop there—the Rust embedded working group has compiled a list of resources and highlight projects on their GitHub (https://github.com/rust-embedded/awesome-embedded...