Book Image

Rust Quick Start Guide

By : Daniel Arbuckle
Book Image

Rust Quick Start Guide

By: Daniel Arbuckle

Overview of this book

Rust is an emerging programming language applicable to areas such as embedded programming, network programming, system programming, and web development. This book will take you from the basics of Rust to a point where your code compiles and does what you intend it to do! This book starts with an introduction to Rust and how to get set for programming, including the rustup and cargo tools for managing a Rust installation and development work?ow. Then you'll learn about the fundamentals of structuring a Rust program, such as functions, mutability, data structures, implementing behavior for types, and many more. You will also learn about concepts that Rust handles differently from most other languages. After understanding the Basics of Rust programming, you will learn about the core ideas, such as variable ownership, scope, lifetime, and borrowing. After these key ideas, you will explore making decisions in Rust based on data types by learning about match and if let expressions. After that, you'll work with different data types in Rust, and learn about memory management and smart pointers.

Related Content you might be interested in

Current Title:

Small book image
Rust Quick Start Guide
Daniel Arbuckle
Oct, 2018 | 180 pages
Small book image
Learning Rust
Vesa Kaihlavirta | Paul Johnson
Nov, 2017 | 308 pages
Small book image
Mastering Rust.
Vesa Kaihlavirta | Rahul Sharma
Jan, 2019 | 554 pages
Small book image
Rust High Performance
Iban Eguia Moraza
Mar, 2018 | 272 pages
Table of Contents (10 chapters)
Preface
Preface
Who this book is for
What this book covers
To get the most out of this book
Get in touch
Free Chapter
1
Getting Ready
Getting Ready
Installing Rust
Starting a new project
Compiling our project
Using crates.io
Summary
2
Basics of the Rust Language
Basics of the Rust Language
Functions
Modules
Expressions
Variables, types, and mutability
Data structures
More about functions
Implementing behavior for types
Summary
3
The Big Ideas – Ownership and Borrowing
The Big Ideas – Ownership and Borrowing
Scope and ownership
Transferring ownership
Copying
Lending
Accessing borrowed data
The lifetime of borrowed data
Ownership and the self parameter
Summary
4
Making Decisions by Pattern Matching
Making Decisions by Pattern Matching
Variable assignment with pattern matching
Using if let expressions to test whether a pattern matches
Using match to choose one of several patterns
Using don't care in patterns
Moving and borrowing in pattern matches
Matching tuples and other more complex patterns
Gotchas
Summary
5
One Data Type Representing Multiple Kinds of Data
One Data Type Representing Multiple Kinds of Data
Enumerations
Traits and trait objects
Any
Comparison of these techniques
Summary
6
Heap Memory and Smart Pointers
Heap Memory and Smart Pointers
Box
Vec and String
Rc
Cell and RefCell
Arc
Mutex and RwLock
Summary
7
Generic Types
Generic Types
Types with generic type parameters
Limiting what types can be used for type parameters
Implementing functionality for types with generic type parameters
Using generic types as function return values
Compiler errors involving generic type parameters
Generic types on functions outside of implementation blocks
Alternative ways to write trait bounds
Generic types versus trait objects
Higher-order functions and trait bounds that represent functions
Complete implementation of a binary tree with generic type parameters
Summary
8
Important Standard Traits
Important Standard Traits
Traits that can be derived
Traits that enable operators
Traits that are implemented automatically
Summary
9
Other Books You May Enjoy
Other Books You May Enjoy
Leave a review - let other readers know what you think

What this book covers

Chapter 1, Getting Ready, teaches how to install Rust and use the supporting tools cargo and rustup.

Chapter 2, Basics of the Rust Language, teaches the basic language syntax and fundamental semantic constructs.

Chapter 3, The Big Ideas – Ownership and Borrowing, discusses the things that set Rust apart from other programming languages.

Chapter 4, Making Decisions by Pattern Matching, explains how to use if let and match expressions.

Chapter 5, One Date Type Representing Multiple Kinds of Data, covers enumerations and trait objects.

Chapter 6, Heap Memory and Smart Pointers, explores the Box, Rc, RefCell, Arc, Mutex, and RwLock smart pointers.

Chapter 7, Generic Types, explains how to use generic type parameters with our data types.

Chapter 8, Important Standard Traits, covers traits that integrate with the language syntax and affect the behavior of the compiler.

Previous Section
Next Section