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 new project using Cargo

Cargo is a unique offering from Rust and is very new in the sphere of system programming. It is also one of the selling points of Rust, as it enables developers to package, ship, and test their Rust application.

We will cover a lot of functionalities of Cargo in this chapter.

Getting ready

We require the Rust compiler, Cargo, and any text editor for coding.

How to do it...

Open the Terminal.
Go to the directory where you want to create the project:

      cd project_location

Enter the following command to create a new Rust project:

      cargo new project_name --bin

Create a project named hello_world, as shown in the following example:

      cargo new hello_world --bin

You should get the following output:

You should have a new folder created with the name of the project.

First, get into the project and examine it:

      cd hello_world
      tree .

You should get the following output:

This is the whole structure of the newly created project.

Print the content of the Cargo...

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 new project using Cargo

Getting ready

How to do it...