1. Язык программирования Rust
2. Предисловие
3. Введение
4. 1. Начало
5. 1. 1.1. Установка
   2. 1.2. Hello, World!
   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. Определение перечисления
    2. 6.2. Конструкция match
    3. 6.3. Лаконичное управление потоком с if let и let else
15. 7. Упарвление разрастающимися проектами с помощью пакетов, крейтов и модулей
16. 1. 7.1. Пакеты и крейты
    2. 7.2. Использование модулей для управления областью видимости и приватностью
    3. 7.3. Пути для ссылки на элемент в дереве модулей
    4. 7.4. Добавление путей в область видимости ключевым словом use
    5. 7.5. Размещение модулей в разных файлах
17. 8. Стандартные коллекции данных
18. 1. 8.1. Хранение списка значений с помощью векторов
    2. 8.2. Хранение текста в кодировке UTF-8 с помощью строк
    3. 8.3. Хранение пар ключ-значение с помощью хеш-таблиц
19. 9. Обработка ошибок
20. 1. 9.1. Неисправимые ошибки с panic!
    2. 9.2. Исправимые ошибки с Result
    3. 9.3. Когда следует использовать 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. Вывод сообщений об ошибках в стандартный поток ошибок
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. Fundamentals of Asynchronous Programming: Async, Await, Futures, and Streams
36. 1. 17.1. Futures and the Async Syntax
    2. 17.2. Applying Concurrency with Async
    3. 17.3. Working With Any Number of Futures
    4. 17.4. Streams: Futures in Sequence
    5. 17.5. A Closer Look at the Traits for Async
    6. 17.6. Futures, Tasks, and Threads
37. 18. Особенности объектно-ориентированного программирования в Rust
38. 1. 18.1. Характеристика объектно-ориентированных языков
    2. 18.2. Использование трейт-объектов, позволяющих использовать значения разных типов
    3. 18.3. Implementing an Object-Oriented Design Pattern
39. 19. Шаблоны и соспоставление с шаблоном
40. 1. 19.1. Где применимо соспоставление с шаблоном
    2. 19.2. Опровержимость: может ли шаблон не сопоставиться
    3. 19.3. Синтаксис шаблонов
41. 20. Продвинутые возможности
42. 1. 20.1. Небезопасный Rust
    2. 20.2. Продвинутые трейты
    3. 20.3. Продвинутые типы
    4. 20.4. Продвинутые функции и замыкания
    5. 20.5. Макросы
43. 21. Итоговый проект: создание многопоточного веб-сервера
44. 1. 21.1. Создание однопоточного веб-сервера
    2. 21.2. Превращение нашего однопоточного сервера в многопоточный
    3. 21.3. Благополучное завершение работы
45. 22. Приложения
46. 1. 22.1. A — Ключевые слова
    2. 22.2. B — Операторы и символы
    3. 22.3. C — Выводимые трейты
    4. 22.4. D — Полезные инструменты разработки
    5. 22.5. E — Редакции
    6. 22.6. F — Переводы
    7. 22.7. G — Как разрабатывается Rust и "Nightly Rust"