Rust Essentials · 2nd Edition by Balbaert, Ivo -- Read -- Imperial Library of Trantor

Index

Title Page

Second Edition

Rust Essentials

Second Edition

Credits About the Author About the Reviewer www.PacktPub.com

Why subscribe?

Customer Feedback Preface

What this book covers What you need for this book Who this book is for Conventions Customer support

Downloading the example code Errata Piracy Questions

Starting with Rust

The advantages of Rust

The trifecta of Rust - safe, fast, and concurrent Comparison with other languages

The stability of Rust and its evolution The success of Rust

Where to use Rust

Servo Installing Rust rustc--the Rust compiler Our first program

Working with Cargo

Developer tools

Using Sublime Text

The Standard Library Summary

Using Variables and Types

Comments Global constants

Printing with string interpolation

Values and primitive types

Consulting Rust documentation

Binding variables to values

Mutable and immutable variables

Scope of a variable and shadowing Type checking and conversions

Aliasing

Expressions The stack and the heap Summary

Using Functions and Control Structures

Branching on a condition Looping Functions

Documenting a function

Attributes

Conditional compilation

Testing

Testing with cargo

The tests module

Summary

Structuring Data and Matching Patterns

Strings Arrays, vectors, and slices

Vectors Slices Strings and arrays

Tuples Structs Enums

Result and Option

Getting input from the console Matching patterns Program arguments Summary

Higher Order Functions and Error-Handling

Higher order functions and closures Iterators Consumers and adapters Generic data structures and functions Error-handling

Panics Testing for failure Some more examples of error-handling The try! macro and the ? operator

Summary

Using Traits and OOP in Rust

Associated functions on structs Methods on structs Using a constructor pattern Using a builder pattern Methods on tuples and enums Traits Using trait constraints Static and dynamic dispatch Built-in traits and operator overloading OOP in Rust Inheritance with traits Using the visitor pattern Summary

Ensuring Memory Safety and Pointers

Pointers and references

Stack and heap Lifetimes Copying and moving values - The copy trait

Let's summarize

Pointers References

Match, struct, and ref

Ownership and borrowing

Ownership Moving a value Borrowing a value Implementing the Drop trait Moving closure

Boxes Reference counting Overview of pointers Summary

Organizing Code and Macros

Modules and crates

Building crates Defining a module Visibility of items Importing modules and file hierarchy Importing external crates Exporting a public interface Adding external crates to a project Working with random numbers

Macros

Why macros? Developing macros

Repetition Creating a new function Some other examples

Using macros from crates Some other built-in macros

Summary

Concurrency - Coding for Multicore Execution

Concurrency and threads

Creating threads

Setting the thread's stack size

Starting a number of threads Panicking threads Thread safety

Shared mutable states

The Sync trait

Communication through channels

Sending and receiving data

Making a channel Sending struct values over a channel Sending references over a channel Synchronous and asynchronous

Summary

Programming at the Boundaries

When is code unsafe

Using std::mem

Raw pointers Interfacing with C

Using a C library

Inlining assembly code Calling Rust from other languages Summary

Exploring the Standard Library

Exploring std and the prelude module Collections - using hashmaps and hashsets Working with files

Paths Reading a file Error-handling with try! Buffered reading Writing a file Error-handling with try! Filesystem operations

Using Rust without the Standard Library Summary

The Ecosystem of Crates

The ecosystem of crates Working with dates and times File formats and databases Web development Graphics and games OS and embedded system development Other resources for learning Rust Summary

← Prev
Back
Next →

← Prev
Back
Next →