Rust Cookbook

Rust Cookbook

By : Vigneshwer Dhinakaran

Buy this Book

Rust Cookbook

By: Vigneshwer Dhinakaran

Buy this Book

Overview of this book

If you are building concurrent applications, server-side programs, or high-performance applications, you will benefit from this language. This book comes with a lot of application-specific recipes to kick-start your development of real-world high-performance applications with the Rust programming language and integrating Rust units into your existing applications. In this book, you will find some 80 practical recipes written in Rust that will allow you to use the code samples right away in your existing applications. These recipes have been tested with stable rust compiler versions of 1.14.0 and above. This book will help you understand the core concepts of the Rust language, enabling you to develop efficient and high-performance applications by incorporating features such as zero cost abstraction and better memory management. We’ll delve into advanced-level concepts such as error handling, macros, crates, and parallelism in Rust. Toward the end of the book, you will learn how to create HTTP servers and web services, building a strong foundational knowledge in server-side programming and enabling you to deliver solutions to build high-performance and safer production-level web applications and services using Rust.

Title

Credits

About the Author

Acknowledgments

About the Reviewer

www.PacktPub.com

Customer Feedback

Preface

Free Chapter

Let us Make System Programming Great Again

Introduction

Setting up Rust in Linux and macOS

Setting up Rust in Windows

Creating your first Rust program

Defining a variable assignment

Setting up Boolean and the character types

Controlling decimal points, number formats, and named arguments

Performing arithmetic operations

Defining mutable variables

Declaring and performing string operations

Declaring arrays and using slices in Rust

Declaring vectors in Rust

Declaring tuples in Rust

Performing calculations on two numbers

Advanced Programming with Rust

Introduction

Defining an expression

Defining constants

Performing variable bindings

Performing type casting in Rust

Decision-making with Rust

Looping operations in Rust

Defining the enum type

Defining closures

Performing pointer operations in Rust

Defining your first user-defined data type

Adding functionality to the user-defined data type

Deep Diving into Cargo

Introduction

Creating a new project using Cargo

Downloading an external crate from crates.io

Working on existing Cargo projects

Running tests with Cargo

Configuration management of the project

Building the project on the Travis CI

Uploading to crates.io

Creating Crates and Modules

Introduction

Defining a module in Rust

Building a nested module

Creating a module with struct

Controlling modules

Accessing modules

Creating a file hierarchy

Building libraries in Rust

Calling external crates

Deep Dive into Parallelism

Introduction

Creating a thread in Rust

Spawning multiple threads

Holding threads in a vector

Sharing data between threads using channels

Implementing safe mutable access

Creating child processes

Waiting for a child process

Making sequential code parallel

Efficient Error Handling

Introduction

Implementing panic

Implementing Option

Creating map combinator

Creating and_then combinator

Creating map for the Result type

Implementing aliases

Handling multiple errors

Implementing early returns

Implementing the try! macro

Defining your own error types

Implementing the boxing of errors

Hacking Macros

Introduction

Building macros in Rust

Implementing matching in macros

Playing with common Rust macros

Implementing designators

Overloading macros

Implementing repeat

Implementing DRY

Integrating Rust with Other Languages

Introduction

Calling C operations from Rust

Calling Rust commands from C

Calling Rust operations from Node.js apps

Calling Rust operations from Python

Writing a Python module in Rust

Web Development with Rust

Introduction

Setting up a web server

Creating endpoints

Handling JSONRequests

Building custom error handlers

Hosting templates

Advanced Web Development in Rust

Introduction

Setting up the API

Saving user data in MongoDB

Fetching user data

Deleting user data

Advanced Rust Tools and Libraries

Introduction

Setting up rustup

Setting up rustfmt

Setting up rust-clippy

Setting up and testing with Servo

Generating random numbers

Writing lines to a file

Parsing unstructured JSON

Parsing URL from a string

Decompressing a tarball

Compressing a directory to a tarball

Finding file extensions recursively

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Creating a file hierarchy

This recipe discusses how to create a file structure for complex and bigger code bases so that it would be easier for the developer to manage application feature development. We will learn about the rules enforced by the Rust compiler to create a file hierarchy successfully so that the developer can utilize and get the same flexibility while using modules' units.

Getting ready

We will require the Rust compiler and any text editor to code. Also, create a file named sample_module.rs in the project workspace.

How to do it...

Create a file named sample_split.rs and a folder named sample_module in the project workspace:

      touch sample_split.rs && mkdir sample_module

Create the mod.rs, nested_mod.rs, and sample_private.rs files inside the sample_module folder:

      cd sample_module && touch mod.rs nested_mod.rs
      sample_private.rs

We should get a folder structure, as shown in the following screenshot:

Write the code header with the details of the code...

Rust Cookbook

By : Vigneshwer Dhinakaran

Rust Cookbook

By: Vigneshwer Dhinakaran

Overview of this book

Related Content you might be interested in

Current Title:

Rust Cookbook

Rust Programming Cookbook

Rust Essentials.

Mastering Rust.

Creating a file hierarchy

Getting ready

How to do it...