1. Язык программирования Rust
2. Предисловие
3. Введение
4. 1. С чего начать
5. 1. 1.1. Установка
   2. 1.2. Привет, Мир!
   3. 1.3. Hello, Cargo!
6. 2. Программирование игры в загадки
7. 3. Общие концепции программирования
8. 1. 3.1. Переменные и изменяемость
   2. 3.2. Типы Данных
   3. 3.3. Функции
   4. 3.4. Комментарии
   5. 3.5. Управляющие конструкции
9. 4. Понимание владения
10. 1. 4.1. Что такое "владение"?
    2. 4.2. Ссылки и заимствование
    3. 4.3. Тип среза
11. 5. Использование структур для объединения связанных данных
12. 1. 5.1. Определение и создание экземпляров структур
    2. 5.2. Пример программы, использующей структуры
    3. 5.3. Синтаксис метода
13. 6. Перечисления и сопоставление с образцом
14. 1. 6.1. Определение Enum
    2. 6.2. Конструкция потока управления match
    3. 6.3. Лаконичный поток управления с if let
15. 7. Управление растущими проектами с помощью пакетов, крейтов и модулей
16. 1. 7.1. Пакеты и крейты
    2. 7.2. Определение модулей для управления областью действия и конфиденциальностью
    3. 7.3. Пути для ссылки на элемент в дереве модулей
    4. 7.4. Введение путей в область видимости с помощью ключевого слова use
    5. 7.5. Separating Modules into Different Files
17. 8. Общие коллекции
18. 1. 8.1. Хранение списков значений с векторами
    2. 8.2. Хранение закодированного текста UTF-8 со строками
    3. 8.3. Хранение ключей со связанными значениями в HashMap
19. 9. Обработка ошибок
20. 1. 9.1. Неустранимые ошибки с panic!
    2. 9.2. Устранимые ошибки с Result
    3. 9.3. panic! или Не panic!
21. 10. Общие типы, трейты (характеристики) и время жизни
22. 1. 10.1. Обобщённые типы данных
    2. 10.2. Трейты (характеристики): определение разделяемого поведения
    3. 10.3. Валидация ссылок посредством сроков жизни
23. 11. Написание автоматических тестов
24. 1. 11.1. Как писать тесты
    2. 11.2. Управление выполнением тестов
    3. 11.3. Организация тестов
25. 12. Проект с вводом-выводом: создание программы командной строки
26. 1. 12.1. Получение аргументов командной строки
    2. 12.2. Чтение файла
    3. 12.3. Рефакторинг для обеспечения модульности и улучшения обработки ошибок
    4. 12.4. Разработка функциональности библиотеки с помощью разработки через тестирование
    5. 12.5. Работа с переменными среды
    6. 12.6. Запись сообщений об ошибках в stderr вместо stdout
27. 13. Функциональные возможности языка: итераторы и замыкания
28. 1. 13.1. Замыкания: анонимные функции, которые захватывают своё окружение
    2. 13.2. Обработка последовательности элементов с помощью итераторов
    3. 13.3. Улучшение нашего проекта с вводом/выводом
    4. 13.4. Сравнение производительности: циклы и итераторы
29. 14. Подробнее о Cargo и Crates.io
30. 1. 14.1. Настройка билдов с помощью профилей выпуска
    2. 14.2. Публикация крейта на Crates.io
    3. 14.3. Рабочие области Cargo
    4. 14.4. Установка бинарных файлов с Crates.io с помощью cargo install
    5. 14.5. Расширение возможностей Cargo путём добавления пользовательских команд
31. 15. Умные указатели
32. 1. 15.1. Использование Box<T> для указания на данные в куче
    2. 15.2. Работа с умными указателями как с обычными ссылками с помощью трейта Deref
    3. 15.3. Выполнение кода при очистке с помощью трейта Drop
    4. 15.4. Rc<T>, умный указатель с подсчётом ссылок
    5. 15.5. RefCell<T> и внутренняя изменяемость
    6. 15.6. Ссылочные циклы могут привести к утечке памяти
33. 16. Безбоязненный параллелизм
34. 1. 16.1. Использование потоков для параллельного выполнения кода
    2. 16.2. Пересылка сообщений для передачи данных между потоками
    3. 16.3. Параллелизм с общим состоянием
    4. 16.4. Расширяемый параллелизм с помощью трейтов Sync и Send
35. 17. Возможности объектно-ориентированного программирования Rust
36. 1. 17.1. Характеристики объектно-ориентированных языков
    2. 17.2. Использование трейт-объектов, допускающих значения разных типов
    3. 17.3. Реализация шаблона объектно-ориентированного проектирования
37. 18. Шаблоны и сопоставление
38. 1. 18.1. Все места, где могут использоваться шаблоны
    2. 18.2. Опровержимость: может ли шаблон не соответствовать
    3. 18.3. Синтаксис шаблона
39. 19. Расширенные возможности
40. 1. 19.1. Небезопасный код в Rust
    2. 19.2. Продвинутые типажи
    3. 19.3. Продвинутые типы
    4. 19.4. Продвинутые функции и замыкания
    5. 19.5. Макросы
41. 20. Финальный проект: создание многопоточного веб-сервера
42. 1. 20.1. Создание однопоточного веб-сервера
    2. 20.2. Превращение нашего однопоточного сервера в многопоточный сервер
    3. 20.3. Мягкое завершение работы и очистка
43. 21. Приложения
44. 1. 21.1. А — Ключевые слова
    2. 21.2. B — Операторы и символы
    3. 21.3. C — Выводимые трейты
    4. 21.4. D — Полезные инструменты разработки
    5. 21.5. E — Редакции
    6. 21.6. F — Переводы книги
    7. 21.7. G — Как создаётся Rust и «Nightly Rust»