Rust Essentials - Second Edition电子书

Title Page

Second Edition

Copyright

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