rust/book
1
0
Fork 0
mirror of https://github.com/rust-lang/book.git synced 2026-06-12 17:18:35 -04:00
Code Issues Packages Projects Releases Wiki Activity

Add a description of all the other chapters

Browse Source 
We already kind of started with descriptions of 2, 3, and 4.
This commit is contained in:
Carol (Nichols || Goulding)
2018-02-20 10:55:26 -05:00
parent 4ffd69dfe9
commit 9ff02a50ad
1 changed files with 38 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

41
second-edition/src/ch00-00-introduction.md
View File

@@ -108,6 +108,44 @@ Rust’s ownership system. By contrast, if you’re a particularly meticulous
learner who prefers to learn every detail before moving onto the next, you may
want to skip Chapter 2 and go straight to Chapter 3.
Chapter 5 discusses structs and methods, and Chapter 6 covers enums, `match`
expressions, and the `if let` control flow construct. Structs and enums are the
ways to make custom types in Rust.
In Chapter 7, you'll learn about Rust's module system and privacy for
organizing your code and its public API. Chapter 8 discusses some common
collection data structures provided by the standard library: vectors, strings,
and hash maps.
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 is still necessary even with Rust's safety guarantees to ensure your
program's logic is correct. In Chapter 12, we'll build a subset of the
functionality of the `grep` command line tool that searches for text within
files and 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 explore more about Cargo
and talk about best practices for sharing your libraries with others. Chapter
15 discusses smart pointers provided by the standard library and the traits
that enable their functionality.
In Chapter 16, we'll go through different models of concurrent programming and
how Rust helps you to program using multiple threads fearlessly. Chapter 17
looks at how Rust idioms compare to Object Oriented Programming principles you
may 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 is a smorgasbord
of advanced topics that you might be interested in, including unsafe Rust and
more about lifetimes, traits, types, functions, and closures.
In Chapter 20, we'll finish up with a project where we'll implement a low-level
multithreaded web server!
Finally, there are some appendices. These contain useful information about the
language in a more reference-like format.
In the end, there’s no wrong way to read a book: if you want to skip ahead, go
for it! You may have to jump back if you find things confusing. Do whatever
works for you.
@@ -119,9 +157,6 @@ that situation. As such, if you pick a random example, it may not compile!
Please read the surrounding text to make sure that you didn’t happen to pick
one of the in-progress examples.
Finally, there are some appendices. These contain useful information about the
language in a more reference-like format.
## Contributing to the Book
This book is open source. If you find an error, please don’t hesitate to file