mirror of https://github.com/rust-lang/book
293 lines
15 KiB
Markdown
293 lines
15 KiB
Markdown
<!-- DO NOT EDIT THIS FILE.
|
||
|
||
This file is periodically generated from the content in the `/src/`
|
||
directory, so all fixes need to be made in `/src/`.
|
||
-->
|
||
## About the Authors
|
||
|
||
Carol Nichols is a member of the Rust Crates.io Team and a former member of the
|
||
Rust Core Team. She’s a co-founder of Integer 32, LLC, the world’s first
|
||
Rust-focused software consultancy. Nichols has also organized the Rust Belt
|
||
Rust Conference.
|
||
|
||
Steve Klabnik was the lead for the Rust documentation team and was one of
|
||
Rust’s core developers. A frequent speaker and a prolific open source
|
||
contributor, he previously worked on projects such as Ruby and Ruby on Rails.
|
||
|
||
## About the Technical Reviewer
|
||
|
||
JT is a Rust core team member and the co-creator of the Rust error message
|
||
format, Rust Language Server (RLS), and Nushell. They first started using Rust
|
||
in 2011, and in 2016 joined Mozilla to work on Rust full time, helping to shape
|
||
its direction for widespread use. These days, they are a freelance Rust trainer
|
||
and advocate for safe systems programming.
|
||
|
||
## Brief Contents
|
||
|
||
## Contents in Detail
|
||
|
||
## Foreword
|
||
|
||
It wasn’t always so clear, but the Rust programming language is fundamentally
|
||
about *empowerment*: no matter what kind of code you are writing now, Rust
|
||
empowers you to reach further, to program with confidence in a wider variety of
|
||
domains than you did before.
|
||
|
||
Take, for example, “systems-level” work that deals with low-level details of
|
||
memory management, data representation, and concurrency. Traditionally, this
|
||
realm of programming is seen as arcane, accessible to only a select few who
|
||
have devoted the necessary years learning it to avoid its infamous pitfalls.
|
||
And even those who practice it do so with caution, lest their code be open to
|
||
exploits, crashes, or corruption.
|
||
|
||
Rust breaks down these barriers by eliminating the old pitfalls and providing a
|
||
friendly, polished set of tools to help you along the way. Programmers who need
|
||
to “dip down” into lower-level control can do so with Rust, without taking on
|
||
the customary risk of crashes or security holes and without having to learn the
|
||
fine points of a fickle toolchain. Better yet, the language is designed to
|
||
guide you naturally toward reliable code that is efficient in terms of speed
|
||
and memory usage.
|
||
|
||
Programmers who are already working with low-level code can use Rust to raise
|
||
their ambitions. For example, introducing parallelism in Rust is a relatively
|
||
low-risk operation: the compiler will catch the classical mistakes for you. And
|
||
you can tackle more aggressive optimizations in your code with the confidence
|
||
that you won’t accidentally introduce crashes or vulnerabilities.
|
||
|
||
But Rust isn’t limited to low-level systems programming. It’s expressive and
|
||
ergonomic enough to make CLI apps, web servers, and many other kinds of code
|
||
quite pleasant to write—you’ll find simple examples later in the book. Working
|
||
with Rust allows you to build skills that transfer from one domain to another;
|
||
you can learn Rust by writing a web app, then apply those same skills to target
|
||
your Raspberry Pi.
|
||
|
||
This book fully embraces the potential of Rust to empower its users. It’s a
|
||
friendly and approachable text intended to help you level up not just your
|
||
knowledge of Rust, but also your reach and confidence as a programmer in
|
||
general. So dive in, get ready to learn—and welcome to the Rust community!
|
||
|
||
Nicholas Matsakis and Aaron Turon
|
||
|
||
## ACKNOWLEDGMENTS
|
||
|
||
We would like to thank everyone who has worked on the Rust language for
|
||
creating an amazing language worth writing a book about. We’re grateful to
|
||
everyone in the Rust community for being welcoming and creating an environment
|
||
worth welcoming more folks into.
|
||
|
||
We’re especially thankful for everyone who read early versions of this book
|
||
online and provided feedback, bug reports, and pull requests. Special thanks to
|
||
Eduard-Mihai Burtescu, Alex Crichton, and JT for providing technical review,
|
||
and to Karen Rustad Tölva for the cover art. Thank you to our team at No
|
||
Starch, including Bill Pollock, Liz Chadwick, and Janelle Ludowise, for
|
||
improving this book and bringing it to print.
|
||
|
||
Carol is grateful for the opportunity to work on this book. She thanks her
|
||
family for their constant love and support, especially her husband, Jake
|
||
Goulding, and her daughter, Vivian.
|
||
|
||
## Preface
|
||
|
||
This version of the text assumes you’re using Rust 1.62.0 (released 2022-06-30)
|
||
or later with `edition="2021"` in the *Cargo.toml* file of all projects to
|
||
configure them to use Rust 2021 edition idioms. See “Installation” on page XX
|
||
for instructions on installing or updating Rust, and see Appendix E for
|
||
information on editions.
|
||
|
||
The 2021 edition of the Rust language includes a number of improvements that
|
||
make Rust more ergonomic and that correct some inconsistencies. On top of a
|
||
general update to reflect these improvements, this rendition of the book has a
|
||
number of improvements to address specific feedback:
|
||
|
||
* Chapter 7 contains a new quick reference section on organizing your code into
|
||
multiple files with modules.
|
||
* Chapter 13 has new and improved closure examples that more clearly illustrate
|
||
captures, the `move` keyword, and the `Fn` traits.
|
||
* We fixed a number of small errors and imprecise wording throughout the book.
|
||
Thank you to the readers who reported them!
|
||
|
||
Note that any code from earlier renditions of this book that compiled will
|
||
continue to compile with the relevant edition in the project’s *Cargo.toml*,
|
||
even as you update the Rust compiler version you’re using. That’s Rust’s
|
||
backward-compatibility guarantees at work!
|
||
|
||
## Introduction
|
||
|
||
Welcome to *The Rust Programming Language*, an introductory book about Rust.
|
||
The Rust programming language helps you write faster, more reliable software.
|
||
High-level ergonomics and low-level control are often at odds in programming
|
||
language design; Rust challenges that conflict. Through balancing powerful
|
||
technical capacity and a great developer experience, Rust gives you the option
|
||
to control low-level details (such as memory usage) without all the hassle
|
||
traditionally associated with such control.
|
||
|
||
## Who Rust Is For
|
||
|
||
Rust is ideal for many people for a variety of reasons. Let’s look at a few of
|
||
the most important groups.
|
||
|
||
### Teams of Developers
|
||
|
||
Rust is proving to be a productive tool for collaborating among large teams of
|
||
developers with varying levels of systems programming knowledge. Low-level code
|
||
is prone to various subtle bugs, which in most other languages can only be
|
||
caught through extensive testing and careful code review by experienced
|
||
developers. In Rust, the compiler plays a gatekeeper role by refusing to
|
||
compile code with these elusive bugs, including concurrency bugs. By working
|
||
alongside the compiler, the team can spend their time focusing on the program’s
|
||
logic rather than chasing down bugs.
|
||
|
||
Rust also brings contemporary developer tools to the systems programming world:
|
||
|
||
* Cargo, the included dependency manager and build tool, makes adding,
|
||
compiling, and managing dependencies painless and consistent across the Rust
|
||
ecosystem.
|
||
* The `rustfmt` formatting tool ensures a consistent coding style across
|
||
developers.
|
||
* The Rust Language Server powers integrated development environment (IDE)
|
||
integration for code completion and inline error messages.
|
||
|
||
By using these and other tools in the Rust ecosystem, developers can be
|
||
productive while writing systems-level code.
|
||
|
||
### Students
|
||
|
||
Rust is for students and those who are interested in learning about systems
|
||
concepts. Using Rust, many people have learned about topics like operating
|
||
systems development. The community is very welcoming and happy to answer
|
||
students’ questions. Through efforts such as this book, the Rust teams want to
|
||
make systems concepts more accessible to more people, especially those new to
|
||
programming.
|
||
|
||
### Companies
|
||
|
||
Hundreds of companies, large and small, use Rust in production for a variety of
|
||
tasks, including command line tools, web services, DevOps tooling, embedded
|
||
devices, audio and video analysis and transcoding, cryptocurrencies,
|
||
bioinformatics, search engines, Internet of Things applications, machine
|
||
learning, and even major parts of the Firefox web browser.
|
||
|
||
### Open Source Developers
|
||
|
||
Rust is for people who want to build the Rust programming language, community,
|
||
developer tools, and libraries. We’d love to have you contribute to the Rust
|
||
language.
|
||
|
||
### People Who Value Speed and Stability
|
||
|
||
Rust is for people who crave speed and stability in a language. By speed, we
|
||
mean both how quickly Rust code can run and the speed at which Rust lets you
|
||
write programs. The Rust compiler’s checks ensure stability through feature
|
||
additions and refactoring. This is in contrast to the brittle legacy code in
|
||
languages without these checks, which developers are often afraid to modify. By
|
||
striving for zero-cost abstractions, higher-level features that compile to
|
||
lower-level code as fast as code written manually, Rust endeavors to make safe
|
||
code be fast code as well.
|
||
|
||
The Rust language hopes to support many other users as well; those mentioned
|
||
here are merely some of the biggest stakeholders. Overall, Rust’s greatest
|
||
ambition is to eliminate the trade-offs that programmers have accepted for
|
||
decades by providing safety *and* productivity, speed *and* ergonomics. Give
|
||
Rust a try and see if its choices work for you.
|
||
|
||
## Who This Book Is For
|
||
|
||
This book assumes that you’ve written code in another programming language, but
|
||
doesn’t make any assumptions about which one. We’ve tried to make the material
|
||
broadly accessible to those from a wide variety of programming backgrounds. We
|
||
don’t spend a lot of time talking about what programming *is* or how to think
|
||
about it. If you’re entirely new to programming, you would be better served by
|
||
reading a book that specifically provides an introduction to programming.
|
||
|
||
## How to Use This Book
|
||
|
||
In general, this book assumes that you’re reading it in sequence from front to
|
||
back. Later chapters build on concepts in earlier chapters, and earlier
|
||
chapters might not delve into details on a particular topic but will revisit
|
||
the topic in a later chapter.
|
||
|
||
You’ll find two kinds of chapters in this book: concept chapters and project
|
||
chapters. In concept chapters, you’ll learn about an aspect of Rust. In project
|
||
chapters, we’ll build small programs together, applying what you’ve learned so
|
||
far. Chapter 2, Chapter 12, and Chapter 20 are project chapters; the rest are
|
||
concept chapters.
|
||
|
||
**Chapter 1** explains how to install Rust, how to write a “Hello, world!”
|
||
program, and how to use Cargo, Rust’s package manager and build tool. **Chapter
|
||
2** is a hands-on introduction to writing a program in Rust, having you build
|
||
up a number-guessing game. Here, we cover concepts at a high level, and later
|
||
chapters will provide additional detail. If you want to get your hands dirty
|
||
right away, Chapter 2 is the place for that. **Chapter 3** covers Rust features
|
||
that are similar to those of other programming languages, and in **Chapter 4**
|
||
you’ll learn about Rust’s ownership system. If you’re a particularly meticulous
|
||
learner who prefers to learn every detail before moving on to the next, you
|
||
might want to skip Chapter 2 and go straight to Chapter 3, returning to Chapter
|
||
2 when you’d like to work on a project applying the details you’ve learned.
|
||
|
||
**Chapter 5** discusses structs and methods, and **Chapter 6** covers enums,
|
||
`match` expressions, and the `if let` control flow construct. You’ll use
|
||
structs and enums to make custom types in Rust.
|
||
|
||
In **Chapter 7**, you’ll learn about Rust’s module system and about privacy
|
||
rules for organizing your code and its public application programming interface
|
||
(API). **Chapter 8** discusses some common collection data structures that the
|
||
standard library provides, such as vectors, strings, and hash maps. **Chapter
|
||
9** explores Rust’s error-handling philosophy and techniques.
|
||
|
||
**Chapter 10** digs into generics, traits, and lifetimes, which give you the
|
||
power to define code that applies to multiple types. **Chapter 11** is all
|
||
about testing, which even with Rust’s safety guarantees is necessary to ensure
|
||
your program’s logic is correct. In **Chapter 12**, we’ll build our own
|
||
implementation of a subset of functionality from the `grep` command line tool
|
||
that searches for text within files. For this, we’ll use many of the concepts
|
||
we discussed in the previous chapters.
|
||
|
||
**Chapter 13** explores closures and iterators: features of Rust that come from
|
||
functional programming languages. In **Chapter 14**, we’ll examine Cargo in
|
||
more depth and talk about best practices for sharing your libraries with
|
||
others. **Chapter 15** discusses smart pointers that the standard library
|
||
provides and the traits that enable their functionality.
|
||
|
||
In **Chapter 16**, we’ll walk through different models of concurrent
|
||
programming and talk about how Rust helps you program in multiple threads
|
||
fearlessly. **Chapter 17** looks at how Rust idioms compare to object-oriented
|
||
programming principles you might be familiar with.
|
||
|
||
**Chapter 18** is a reference on patterns and pattern matching, which are
|
||
powerful ways of expressing ideas throughout Rust programs. **Chapter 19**
|
||
contains a smorgasbord of advanced topics of interest, including unsafe Rust,
|
||
macros, and more about lifetimes, traits, types, functions, and closures.
|
||
|
||
In **Chapter 20**, we’ll complete a project in which we’ll implement a
|
||
low-level multithreaded web server!
|
||
|
||
Finally, some appendices contain useful information about the language in a
|
||
more reference-like format**. Appendix A** covers Rust’s keywords, **Appendix
|
||
B** covers Rust’s operators and symbols, **Appendix C** covers derivable traits
|
||
provided by the standard library, **Appendix D** covers some useful development
|
||
tools, and **Appendix E** explains Rust editions.
|
||
|
||
There is no wrong way to read this book: if you want to skip ahead, go for it!
|
||
You might have to jump back to earlier chapters if you experience any
|
||
confusion. But do whatever works for you.
|
||
|
||
An important part of the process of learning Rust is learning how to read the
|
||
error messages the compiler displays: these will guide you toward working code.
|
||
As such, we’ll provide many examples that don’t compile along with the error
|
||
message the compiler will show you in each situation. Know that if you enter
|
||
and run a random example, it may not compile! Make sure you read the
|
||
surrounding text to see whether the example you’re trying to run is meant to
|
||
error. In most situations, we’ll lead you to the correct version of any code
|
||
that doesn’t compile.
|
||
|
||
## Resources and How to Contribute to This Book
|
||
|
||
This book is open source. If you find an error, please don’t hesitate to file
|
||
an issue or send a pull request on GitHub at
|
||
*https://github.com/rust-lang/book*. Please see *CONTRIBUTING.md* at
|
||
*https://github.com/rust-lang/book/blob/main/CONTRIBUTING.md* for more details.
|
||
|
||
The source code for the examples in this book, errata, and other information
|
||
are available at *https://www.nostarch.com/Rust2021*.
|
||
|