Sign In Start Free Trial

Book Overview & Buying
Table Of Contents
Feedback & Rating

Rust Programming Cookbook

By : Claus Matzinger

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

Preface

Who this book is for

What this book covers

To get the most out of this book

Sections

Get in touch

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

Debugging 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

Safe Programming for the Web

Ever since the popular Rails framework for the Ruby programming language, creating backend web services seemed like a domain for dynamically typed languages. This trend was only reinforced by the rise of Python and JavaScript as primary languages for these tasks. After all, the nature of these technologies made creating these services especially fast and changes to services (for example, a new field in the JSON response) are simple to do. Returning to static types for web services feels strange for many of us; after all, it takes a lot longer to get something going.

However, there is a cost to these: many services are deployed in the cloud nowadays, which means that a pay-as-you-go model is employed together with (practically) infinite scalability. Since—most notably—Python is not known for its execution speed, we can now see the cost...

Search

Your notes and bookmarks