Book Image

Rust Cookbook

By : Vigneshwer Dhinakaran
Book Image

Rust Cookbook

By: Vigneshwer Dhinakaran

Overview of this book

<p>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.</p> <p>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.</p> <p>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.</p>

Related Content you might be interested in

Current Title:

Small book image
Rust Cookbook
Vigneshwer Dhinakaran
Jul, 2017 | 320 pages
Small book image
Rust Programming Cookbook
Claus Matzinger
Oct, 2019 | 444 pages
Small book image
Rust Essentials.
Ivo Balbaert
Nov, 2017 | 264 pages
Small book image
Mastering Rust.
Vesa Kaihlavirta | Rahul Sharma
Jan, 2019 | 554 pages
Table of Contents (19 chapters)
Title
Title
Credits
Credits
About the Author
About the Author
Acknowledgments
Acknowledgments
About the Reviewer
About the Reviewer
www.PacktPub.com
www.PacktPub.com
Customer Feedback
Customer Feedback
Preface
Preface
Free Chapter
1
Let us Make System Programming Great Again
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
2
Advanced Programming with Rust
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
Similar functionality for different data type
3
Deep Diving into Cargo
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
4
Creating Crates and Modules
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
5
Deep Dive into Parallelism
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
6
Efficient Error Handling
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
7
Hacking Macros
Hacking Macros
Introduction
Building macros in Rust
Implementing matching in macros
Playing with common Rust macros
Implementing designators
Overloading macros
Implementing repeat
Implementing DRY
8
Integrating Rust with Other Languages
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
9
Web Development with Rust
Web Development with Rust
Introduction
Setting up a web server
Creating endpoints
Handling JSONRequests
Building custom error handlers
Hosting templates
10
Advanced Web Development in Rust
Advanced Web Development in Rust
Introduction
Setting up the API
Saving user data in MongoDB
Fetching user data
Deleting user data
11
Advanced Rust Tools and Libraries
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

Implementing designators

Rust provides a list of designators, which help us create units, such as functions, and execute expressions in macros.

Getting ready

We will require the Rust compiler and any text editor to develop the Rust code snippet.

How to do it...

Follow the mentioned steps to implement this recipe:

  1. Create a file named sample_designator.rs, and open it in your text editor.
  2. Write the code header with the relevant information:
        //-- #########################
        //-- Task: Implementing designator
        //-- Author: Vigneshwer.D
        //-- Version: 1.0.0
        //-- Date: 26 March 17
        //-- #########################
  1. Create a macro named create_function, which accepts a designator as an argument:
        macro_rules! create_function {
          ($func_name:ident) => (
            fn $func_name() {
              // The `stringify!` macro converts an `ident`
              into a string.
              println!("You called {:?}()",
              stringify!($func_name...
Previous Section
End of Section 6
Next Section