diff --git a/po/uk.po b/po/uk.po
index 1ace97b2..758bc5c1 100644
--- a/po/uk.po
+++ b/po/uk.po
@@ -251,7 +251,7 @@ msgstr "Трейт об'єкти"
 #: src/SUMMARY.md src/methods-and-traits/exercise.md
 #, fuzzy
 msgid "Exercise: Generic Logger"
-msgstr "Вправа: узагальнений `min`"
+msgstr "Вправа: узагальнена `min`"
 
 #: src/SUMMARY.md src/generics.md
 msgid "Generics"
@@ -275,7 +275,7 @@ msgstr "`impl Trait`"
 
 #: src/SUMMARY.md src/generics/exercise.md
 msgid "Exercise: Generic `min`"
-msgstr "Вправа: узагальнений `min`"
+msgstr "Вправа: узагальнена `min`"
 
 #: src/SUMMARY.md
 msgid "Day 2: Afternoon"
@@ -1474,142 +1474,138 @@ msgstr ""
 "протікають швидко, і ми багато робимо!"
 
 #: src/running-the-course/course-structure.md
-#, fuzzy
 msgid "Course schedule:"
 msgstr "Структура курсу"
 
 #: src/running-the-course/course-structure.md
 msgid "Day 1 Morning (3 hours, including breaks)"
-msgstr ""
+msgstr "День 1 Ранок (3 години, включаючи перерви)"
 
 #: src/running-the-course/course-structure.md
 msgid "[Welcome](../welcome-day-1.md) (5 minutes)"
-msgstr ""
+msgstr "[Ласкаво просимо](../welcome-day-1.md) (5 хвилин)"
 
 #: src/running-the-course/course-structure.md
 msgid "[Hello, World](../hello-world.md) (20 minutes)"
-msgstr ""
+msgstr "[Hello, World] (../hello-world.md) (20 хвилин)"
 
 #: src/running-the-course/course-structure.md
 msgid "[Types and Values](../types-and-values.md) (1 hour and 5 minutes)"
-msgstr ""
+msgstr "[Типи та значення] (../types-and-values.md) (1 година 5 хвилин)"
 
 #: src/running-the-course/course-structure.md
 msgid "[Control Flow Basics](../control-flow-basics.md) (1 hour)"
-msgstr ""
+msgstr "[Основи потоку управління](../control-flow-basics.md) (1 година)"
 
 #: src/running-the-course/course-structure.md
 msgid "Day 1 Afternoon (2 hours and 55 minutes, including breaks)"
-msgstr ""
+msgstr "День 1 Полудень (2 години 55 хвилин, включаючи перерви)"
 
 #: src/running-the-course/course-structure.md
 msgid "[Tuples and Arrays](../tuples-and-arrays.md) (1 hour)"
-msgstr ""
+msgstr "[Кортежі та масиви](../tuples-and-arrays.md) (1 година)"
 
 #: src/running-the-course/course-structure.md
 msgid "[References](../references.md) (50 minutes)"
-msgstr ""
+msgstr "[Посилання](../references.md) (50 хвилин)"
 
 #: src/running-the-course/course-structure.md
 msgid "[User-Defined Types](../user-defined-types.md) (50 minutes)"
-msgstr ""
+msgstr "[Типи, визначені користувачем](../user-defined-types.md) (50 хвилин)"
 
 #: src/running-the-course/course-structure.md
 msgid "Day 2 Morning (3 hours and 5 minutes, including breaks)"
-msgstr ""
+msgstr "День 2 Ранок (3 години 5 хвилин, включаючи перерви)"
 
 #: src/running-the-course/course-structure.md
 msgid "[Welcome](../welcome-day-2.md) (3 minutes)"
-msgstr ""
+msgstr "[Ласкаво просимо](../welcome-day-2.md) (3 хвилини)"
 
 #: src/running-the-course/course-structure.md
-#, fuzzy
 msgid "[Pattern Matching](../pattern-matching.md) (50 minutes)"
-msgstr ""
-"Перегляньте [зіставлення шаблонів](../pattern-matching.md), щоб дізнатися "
-"більше про шаблони в Rust."
+msgstr "[Зіставлення шаблонів](../pattern-matching.md) (50 хвилин)."
 
 #: src/running-the-course/course-structure.md
 msgid "[Methods and Traits](../methods-and-traits.md) (55 minutes)"
-msgstr ""
+msgstr "[Методи та трейти] (../methods-and-traits.md) (55 хвилин)"
 
 #: src/running-the-course/course-structure.md
 msgid "[Generics](../generics.md) (45 minutes)"
-msgstr ""
+msgstr "[Узагальнення](../generics.md) (45 хвилин)"
 
 #: src/running-the-course/course-structure.md
-#, fuzzy
 msgid "Day 2 Afternoon (3 hours, including breaks)"
-msgstr "День 2 Після обіду"
+msgstr "День 2 Полудень (3 години, включаючи перерви)"
 
 #: src/running-the-course/course-structure.md
 msgid "[Standard Library Types](../std-types.md) (1 hour and 10 minutes)"
-msgstr ""
+msgstr "[Типи стандартної бібліотеки](../std-types.md) (1 година 10 хвилин)"
 
 #: src/running-the-course/course-structure.md
 msgid "[Standard Library Traits](../std-traits.md) (1 hour and 40 minutes)"
-msgstr ""
+msgstr "[Трейти стандартної бібліотек](../std-traits.md) (1 година 40 хвилин)"
 
 #: src/running-the-course/course-structure.md
 msgid "Day 3 Morning (2 hours and 15 minutes, including breaks)"
-msgstr ""
+msgstr "День 3 Ранок (2 години 15 хвилин, включаючи перерви)"
 
 #: src/running-the-course/course-structure.md
 msgid "[Welcome](../welcome-day-3.md) (3 minutes)"
-msgstr ""
+msgstr "[Ласкаво просимо](../welcome-day-3.md) (3 хвилини)"
 
 #: src/running-the-course/course-structure.md
 msgid "[Memory Management](../memory-management.md) (1 hour and 10 minutes)"
-msgstr ""
+msgstr "[Управління пам'яттю](../memory-management.md) (1 година 10 хвилин)"
 
 #: src/running-the-course/course-structure.md
 msgid "[Smart Pointers](../smart-pointers.md) (45 minutes)"
-msgstr ""
+msgstr "[Розумні покажчики](../smart-pointers.md) (45 хвилин)"
 
 #: src/running-the-course/course-structure.md
 msgid "Day 3 Afternoon (2 hours and 20 minutes, including breaks)"
-msgstr ""
+msgstr "День 3 Полудень (2 години 20 хвилин, включаючи перерви)"
 
 #: src/running-the-course/course-structure.md
 msgid "[Borrowing](../borrowing.md) (1 hour)"
-msgstr ""
+msgstr "[Запозичення](../borrowing.md) (1 година)"
 
 #: src/running-the-course/course-structure.md
 msgid ""
 "[Slices and Lifetimes](../slices-and-lifetimes.md) (1 hour and 10 minutes)"
 msgstr ""
+"[Зрізи та тривалість життя] (../slices-and-lifetimes.md) (1 година 10 хвилин)"
 
 #: src/running-the-course/course-structure.md
 msgid "Day 4 Morning (3 hours and 5 minutes, including breaks)"
-msgstr ""
+msgstr "День 4 Ранок (3 години 5 хвилин, включаючи перерви)"
 
 #: src/running-the-course/course-structure.md
 msgid "[Welcome](../welcome-day-4.md) (3 minutes)"
-msgstr ""
+msgstr "[Ласкаво просимо](../welcome-day-4.md) (3 хвилини)"
 
 #: src/running-the-course/course-structure.md
 msgid "[Iterators](../iterators.md) (45 minutes)"
-msgstr ""
+msgstr "[Ітератори](../iterators.md) (45 хвилин)"
 
 #: src/running-the-course/course-structure.md
 msgid "[Modules](../modules.md) (40 minutes)"
-msgstr ""
+msgstr "[Модулі](../modules.md) (40 хвилин)"
 
 #: src/running-the-course/course-structure.md
 msgid "[Testing](../testing.md) (1 hour and 5 minutes)"
-msgstr ""
+msgstr "[Тестування](../testing.md) (1 година 5 хвилин)"
 
 #: src/running-the-course/course-structure.md
 msgid "Day 4 Afternoon (2 hours, including breaks)"
-msgstr ""
+msgstr "День 4 Полудень (2 години, включаючи перерви)"
 
 #: src/running-the-course/course-structure.md
 msgid "[Error Handling](../error-handling.md) (45 minutes)"
-msgstr ""
+msgstr "[Обробка помилок](../error-handling.md) (45 хвилин)"
 
 #: src/running-the-course/course-structure.md
 msgid "[Unsafe Rust](../unsafe-rust.md) (1 hour and 5 minutes)"
-msgstr ""
+msgstr "[Небезпечний Rust](../unsafe-rust.md) (1 година 5 хвилин)"
 
 #: src/running-the-course/course-structure.md
 msgid "Deep Dives"
@@ -1946,7 +1942,7 @@ msgid ""
 msgstr ""
 "Як результат, ви отримаэте інструмент побудови Cargo (`cargo`) та компілятор "
 "Rust (`rustc`). Ви також отримаэте `rustup`, утиліту командної стрічки, яку "
-"виможете використовувати для встановлення на різних версій компілятора."
+"виможете використовувати для встановлення різних версій компілятора."
 
 #: src/cargo.md
 msgid ""
@@ -1961,9 +1957,9 @@ msgstr ""
 "Після встановлення Rust вам слід налаштувати редактор або IDE для роботи з "
 "Rust. Більшість редакторів роблять це, звертаючись до [rust-analyzer]"
 "(https://rust-analyzer.github.io/), який забезпечує автозаповнення та "
-"функцію переходу до визначення для [VS Code](https://code .visualstudio."
+"функцію переходу до визначення для [VS Code](https://code.visualstudio."
 "com/), [Emacs](https://rust-analyzer.github.io/manual.html#emacs), [Vim/"
-"Neovim](https://rust-analyzer.github.io/manual. html#vimneovim), та багато "
+"Neovim](https://rust-analyzer.github.io/manual.html#vimneovim), та багато "
 "інших. Існує також інша доступна IDE під назвою [RustRover](https://www."
 "jetbrains.com/rust/)."
 
@@ -5237,76 +5233,81 @@ msgid "Welcome to Day 2"
 msgstr "Ласкаво просимо до Дня 2"
 
 #: src/welcome-day-2.md
-#, fuzzy
 msgid ""
 "Now that we have seen a fair amount of Rust, today will focus on Rust's type "
 "system:"
-msgstr "Тепер, коли ми побачили достатню кількість Rust, ми продовжимо:"
+msgstr ""
+"Тепер, коли ми побачили достатню кількість Rust, ми зосередимося на системі "
+"типів Rust:"
 
 #: src/welcome-day-2.md
-#, fuzzy
 msgid "Pattern matching: extracting data from structures."
-msgstr "Зіставлення шаблонів: деструктурування переліків, структур і масивів."
+msgstr "Зіставлення шаблонів: вилучення даних зі структур."
 
 #: src/welcome-day-2.md
 msgid "Methods: associating functions with types."
-msgstr ""
+msgstr "Методи: зв'язування функцій з типами."
 
 #: src/welcome-day-2.md
 msgid "Traits: behaviors shared by multiple types."
-msgstr ""
+msgstr "Трэйти: поведінка, спільна для кількох типів"
 
 #: src/welcome-day-2.md
 msgid "Generics: parameterizing types on other types."
-msgstr ""
+msgstr "Узагальнення: параметризація типів в інших типах."
 
 #: src/welcome-day-2.md
 msgid ""
 "Standard library types and traits: a tour of Rust's rich standard library."
 msgstr ""
+"Типи та властивості стандартної бібліотеки: екскурсія по багатій стандартній "
+"бібліотеці Rust."
 
 #: src/welcome-day-2.md
 msgid "[Welcome](./welcome-day-2.md) (3 minutes)"
-msgstr ""
+msgstr "[Ласкаво просимо](./welcome-day-2.md) (3 хвилини)"
 
 #: src/welcome-day-2.md
-#, fuzzy
 msgid "[Pattern Matching](./pattern-matching.md) (50 minutes)"
-msgstr ""
-"Перегляньте [зіставлення шаблонів](../pattern-matching.md), щоб дізнатися "
-"більше про шаблони в Rust."
+msgstr "[Зіставлення шаблонів](../pattern-matching.md) (50 хвилин)"
 
 #: src/welcome-day-2.md
 msgid "[Methods and Traits](./methods-and-traits.md) (55 minutes)"
-msgstr ""
+msgstr "[Методи та Трэйти] (./methods-and-traits.md) (55 хвилин)"
 
 #: src/welcome-day-2.md
 msgid "[Generics](./generics.md) (45 minutes)"
-msgstr ""
+msgstr "[Узагальнення](./generics.md) (45 хвилин)"
 
 #: src/welcome-day-2.md src/welcome-day-4.md
 msgid ""
 "Including 10 minute breaks, this session should take about 3 hours and 5 "
 "minutes"
 msgstr ""
+"Враховуючи 10-хвилинні перерви, цей сеанс має тривати близько 3 годин 5 "
+"хвилин."
 
 #: src/pattern-matching.md
 msgid "[Destructuring](./pattern-matching/destructuring.md) (10 minutes)"
-msgstr ""
+msgstr "[Деструктуризація](./pattern-matching/destructuring.md) (10 хвилин)"
 
 #: src/pattern-matching.md
 msgid "[Let Control Flow](./pattern-matching/let-control-flow.md) (10 minutes)"
 msgstr ""
+"[Потік керування let](./pattern-matching/let-control-flow.md) (10 хвилин)"
 
 #: src/pattern-matching.md
 msgid ""
 "[Exercise: Expression Evaluation](./pattern-matching/exercise.md) (30 "
 "minutes)"
 msgstr ""
+"[Вправа: Обчислення виразу](./pattern-matching/exercise.md) (30 хвилин)"
 
 #: src/pattern-matching/destructuring.md
 msgid "Like tuples, structs and enums can also be destructured by matching:"
 msgstr ""
+"Як і кортежі, структури та переліки також можуть бути деструктуровані шляхом "
+"зіставлення:"
 
 #: src/pattern-matching/destructuring.md
 msgid "Structs"
@@ -5314,15 +5315,15 @@ msgstr "Структури"
 
 #: src/pattern-matching/destructuring.md
 msgid "\"x.0 = 1, b = {b}, y = {y}\""
-msgstr ""
+msgstr "\"x.0 = 1, b = {b}, y = {y}\""
 
 #: src/pattern-matching/destructuring.md
 msgid "\"y = 2, x = {i:?}\""
-msgstr ""
+msgstr "\"y = 2, x = {i:?}\""
 
 #: src/pattern-matching/destructuring.md
 msgid "\"y = {y}, other fields were ignored\""
-msgstr ""
+msgstr "\"y = {y}, інші поля були проігноровані\""
 
 #: src/pattern-matching/destructuring.md
 msgid ""
@@ -5331,20 +5332,20 @@ msgid ""
 "`enum` type:"
 msgstr ""
 "Шаблони також можна використовувати для прив’язки змінних до частин ваших "
-"значень. Таким чином ви перевіряєте структуру ваших типів. Почнемо з "
-"простого типу `enum`:"
+"значень. Таким чином ви перевіряєте структуру ваших типів. Давайте "
+"розпочнемо з простого типу `enum`:"
 
 #: src/pattern-matching/destructuring.md
 msgid "\"cannot divide {n} into two equal parts\""
-msgstr ""
+msgstr "\"не можна поділити {n} на дві рівні частини\""
 
 #: src/pattern-matching/destructuring.md
 msgid "\"{n} divided in two is {half}\""
-msgstr ""
+msgstr "\"{n} поділена навпіл, це {half}\""
 
 #: src/pattern-matching/destructuring.md
 msgid "\"sorry, an error happened: {msg}\""
-msgstr ""
+msgstr "\"вибачте, сталася помилка: {msg}\""
 
 #: src/pattern-matching/destructuring.md
 msgid ""
@@ -5352,10 +5353,13 @@ msgid ""
 "arm, `half` is bound to the value inside the `Ok` variant. In the second "
 "arm, `msg` is bound to the error message."
 msgstr ""
+"Тут ми використали гілки для _деструктурування_ значення `Result`. У першій "
+"гілці `half` прив'язано до значення всередині варіанту `Ok`. У другій гілці "
+"`msg` прив'язано до повідомлення про помилку."
 
 #: src/pattern-matching/destructuring.md
 msgid "Change the literal values in `foo` to match with the other patterns."
-msgstr "Змініть значення літералів у `foo`, щоб відповідати іншим шаблонам."
+msgstr "Змініть значення літералів у `foo`, відповідно до інших шаблонів."
 
 #: src/pattern-matching/destructuring.md
 msgid "Add a new field to `Foo` and make changes to the pattern as needed."
@@ -5368,8 +5372,8 @@ msgid ""
 "subtly doesn't work. Change it to a `const` and see it working again."
 msgstr ""
 "Різницю між захопленням і постійним виразом може бути важко помітити. "
-"Спробуйте змінити `2` у другому плечі на змінну, і побачите, що це непомітно "
-"не працює. Змініть його на `const` і подивіться, як він знову запрацює."
+"Спробуйте змінити `2` у другій гілці на змінну, і побачте, що це непомітно "
+"не працює. Змініть ії на `const` і подивіться, що це знову запрацює."
 
 #: src/pattern-matching/destructuring.md
 msgid ""
@@ -5385,19 +5389,17 @@ msgid ""
 "errors when running the code. Point out the places where your code is now "
 "inexhaustive and how the compiler tries to give you hints."
 msgstr ""
-"Ви можете спробувати додати третій варіант до визначення enum і відобразити "
-"помилки під час виконання коду. Вкажіть місця, де ваш код зараз є "
-"невичерпним, і як компілятор намагається дати вам підказки."
+"Ви можете спробувати додати третій варіант до визначення переліку і "
+"відобразити помилки під час виконання коду. Вкажіть місця, де ваш код зараз "
+"є невичерпним, і як компілятор намагається дати вам підказки."
 
 #: src/pattern-matching/destructuring.md
-#, fuzzy
 msgid ""
 "The values in the enum variants can only be accessed after being pattern "
 "matched."
 msgstr ""
-"Доступ до значень у варіантах переліку можна отримати лише після "
-"відповідності шаблону. Шаблон прив’язує посилання до полів у «руці "
-"відповідності» після `=>`."
+"Доступ до значень у варіантах переліку можливий лише після зіставлення з "
+"шаблоном."
 
 #: src/pattern-matching/destructuring.md
 #, fuzzy
@@ -5406,7 +5408,7 @@ msgid ""
 "the Rust compiler provides by confirming when all cases are handled."
 msgstr ""
 "Продемонструйте, що відбувається, коли пошук є невичерпним. Зверніть увагу "
-"на перевагу, яку надає компілятор Rust, підтверджуючи, коли всі випадки "
+"на перевагу, яку надає компілятор Rust, підтверджуючи що всі випадки "
 "оброблено."
 
 #: src/pattern-matching/destructuring.md
@@ -5418,6 +5420,13 @@ msgid ""
 "io/rfcs/2005-match-ergonomics.html) appeared in Rust 2018. If you want to "
 "support older Rust, replace `msg` with `ref msg` in the pattern."
 msgstr ""
+"Збережіть результат `divide_in_two` у змінній `result` і `match` його у "
+"циклі. Це не буде скомпільовано, оскільки при порівнянні споживається `msg`. "
+"Щоб виправити це, порівняйте `&result` замість `result`. Це зробить `msg` "
+"посиланням, тому його не буде використано. Ця [\"ергономіка співставлення\"]"
+"(https://rust-lang.github.io/rfcs/2005-match-ergonomics.html) з'явилася у "
+"Rust 2018. Якщо ви хочете підтримувати попередні версії Rust, замініть `msg` "
+"на `ref msg` у шаблоні."
 
 #: src/pattern-matching/let-control-flow.md
 msgid ""
@@ -5425,7 +5434,7 @@ msgid ""
 "They are used for pattern matching:"
 msgstr ""
 "Rust має кілька конструкцій потоку керування, які відрізняються від інших "
-"мов. Вони використовуються для зіставлення зразків:"
+"мов. Вони використовуються для зіставлення шаблонів:"
 
 #: src/pattern-matching/let-control-flow.md
 msgid "`if let` expressions"
@@ -5451,12 +5460,11 @@ msgstr ""
 
 #: src/pattern-matching/let-control-flow.md
 msgid "\"slept for {:?}\""
-msgstr ""
+msgstr "\"slept for {:?}\""
 
 #: src/pattern-matching/let-control-flow.md
-#, fuzzy
 msgid "`let else` expressions"
-msgstr "вирази `while let`"
+msgstr "вирази `let else`"
 
 #: src/pattern-matching/let-control-flow.md
 msgid ""
@@ -5465,28 +5473,32 @@ msgid ""
 "let_else.html). The \"else\" case must diverge (`return`, `break`, or panic "
 "- anything but falling off the end of the block)."
 msgstr ""
+"Для загального випадку зіставлення шаблону і повернення з функції "
+"використовуйте [`let else`](https://doc.rust-lang.org/rust-by-example/"
+"flow_control/let_else.html). Випадок \"else\" повинен відрізнятися "
+"(`return`, `break` або паніка - що завгодно, але не випадання з кінця блоку)."
 
 #: src/pattern-matching/let-control-flow.md
 msgid "\"got None\""
-msgstr ""
+msgstr "\"отримав  None\""
 
 #: src/pattern-matching/let-control-flow.md
 msgid "\"got empty string\""
-msgstr ""
+msgstr "\"отримав порожній рядок\""
 
 #: src/pattern-matching/let-control-flow.md
 msgid "\"not a hex digit\""
-msgstr ""
+msgstr "не шістнадцяткова цифра"
 
 #: src/pattern-matching/let-control-flow.md src/pattern-matching/solution.md
 msgid "\"result: {:?}\""
-msgstr ""
+msgstr "\"результат: {:?}\""
 
 #: src/pattern-matching/let-control-flow.md src/generics/trait-bounds.md
 #: src/smart-pointers/solution.md src/testing/googletest.md
 #: src/testing/solution.md
 msgid "\"foo\""
-msgstr ""
+msgstr "\"foo\""
 
 #: src/pattern-matching/let-control-flow.md
 msgid ""
@@ -5496,24 +5508,23 @@ msgid ""
 msgstr ""
 "Подібно до `if let`, існує варіант [`while let`](https://doc.rust-lang.org/"
 "reference/expressions/loop-expr.html#predicate-pattern-loops), який "
-"неодноразово перевіряє значення проти шаблону:"
+"багаторазово перевіряє значення на відповідність шаблону:"
 
 #: src/pattern-matching/let-control-flow.md
-#, fuzzy
 msgid ""
 "Here [`String::pop`](https://doc.rust-lang.org/stable/std/string/struct."
 "String.html#method.pop) returns `Some(c)` until the string is empty, after "
 "which it will return `None`. The `while let` lets us keep iterating through "
 "all items."
 msgstr ""
-"Тут ітератор, який повертає `v.into_iter()`, повертатиме `Option<i32>` під "
-"час кожного виклику `next()`. Він повертає `Some(x)`, доки не буде виконано, "
-"після чого повертає `None`. `while let` дозволяє нам продовжувати "
-"повторювати всі елементи."
+"Тут [`String::pop`](https://doc.rust-lang.org/stable/std/string/struct."
+"String.html#method.pop) повертає `Some(c)` поки рядок не стане порожнім, "
+"після чого поверне `None`. Використання `while let` дозволяє нам "
+"продовжувати ітерацію по всіх елементах."
 
 #: src/pattern-matching/let-control-flow.md
 msgid "if-let"
-msgstr ""
+msgstr "if-let"
 
 #: src/pattern-matching/let-control-flow.md
 msgid ""
@@ -5532,12 +5543,12 @@ msgstr ""
 msgid ""
 "Unlike `match`, `if let` does not support guard clauses for pattern matching."
 msgstr ""
-"На відміну від `match`, `if let` не підтримує захисні пропозиції для "
-"зіставлення шаблону."
+"На відміну від `match`, `if let` не підтримує захисні вирази для збігу "
+"шаблонів."
 
 #: src/pattern-matching/let-control-flow.md
 msgid "let-else"
-msgstr ""
+msgstr "let-else"
 
 #: src/pattern-matching/let-control-flow.md
 msgid ""
@@ -5545,15 +5556,17 @@ msgid ""
 "flattening this nested code. Rewrite the awkward version for students, so "
 "they can see the transformation."
 msgstr ""
+"`if-let` може накопичуватись, як показано. Конструкція `let-else` підтримує "
+"згладжування цього вкладеного коду. Перепишіть незручну версію для "
+"студентів, щоб вони могли побачити перетворення."
 
 #: src/pattern-matching/let-control-flow.md
 msgid "The rewritten version is:"
-msgstr ""
+msgstr "Переписана версія така:"
 
 #: src/pattern-matching/let-control-flow.md
-#, fuzzy
 msgid "while-let"
-msgstr "цикли `while let`"
+msgstr "while-let"
 
 #: src/pattern-matching/let-control-flow.md
 msgid ""
@@ -5564,19 +5577,18 @@ msgstr ""
 "шаблону."
 
 #: src/pattern-matching/let-control-flow.md
-#, fuzzy
 msgid ""
 "You could rewrite the `while let` loop as an infinite loop with an if "
 "statement that breaks when there is no value to unwrap for `name.pop()`. The "
 "`while let` provides syntactic sugar for the above scenario."
 msgstr ""
-"Ви можете переписати цикл `while let` як нескінченний цикл із оператором if, "
-"який переривається, коли немає значення для розгортання для `iter.next()`. "
-"`while let` забезпечує синтаксичний цукор для вищенаведеного сценарію."
+"Ви можете переписати цикл `while let` як нескінченний цикл з оператором if, "
+"який переривається, коли для `name.pop()` немає значення для розгортання. "
+"Цикл `while let` забезпечує синтаксичний цукор для наведеного вище сценарію."
 
 #: src/pattern-matching/exercise.md
 msgid "Let's write a simple recursive evaluator for arithmetic expressions."
-msgstr ""
+msgstr "Давайте напишемо простий рекурсивний обчислювач арифметичних виразів."
 
 #: src/pattern-matching/exercise.md
 msgid ""
@@ -5585,6 +5597,10 @@ msgid ""
 "tests. To evaluate a boxed expression, use the deref operator (`*`) to "
 "\"unbox\" it: `eval(*boxed_expr)`."
 msgstr ""
+"Тип `Box` тут є розумним вказівником і буде детально розглянутий пізніше у "
+"курсі. Вираз може бути \"упаковано\" за допомогою `Box::new`, як показано у "
+"тестах. Щоб обчислити вираз, використайте оператор розіменування (`*`), щоб "
+"\"розпакувати\" його: `eval(*boxed_expr)`."
 
 #: src/pattern-matching/exercise.md
 msgid ""
@@ -5594,6 +5610,10 @@ msgid ""
 "(`Ok(Value)`) or an error (`Err(String)`). We will cover this type in detail "
 "later."
 msgstr ""
+"Деякі вирази не можуть бути обчислені і повертають помилку. Стандартний тип "
+"[`Result<Value, String>`](https://doc.rust-lang.org/std/result/enum.Result."
+"html) - це перелік, який представляє або успішне значення (`Ok(Value)`), або "
+"помилку (`Err(String)`). Ми розглянемо цей тип більш детально пізніше."
 
 #: src/pattern-matching/exercise.md
 msgid ""
@@ -5602,61 +5622,69 @@ msgid ""
 "`todo!()` and get the tests to pass one-by-one. You can also skip a test "
 "temporarily with `#[ignore]`:"
 msgstr ""
+"Скопіюйте та вставте код у середовище Rust і почніть реалізацію `eval`. "
+"Кінцевий продукт повинен пройти тести. Може бути корисно використати `todo!"
+"()` і змусити тести проходити один за одним. Ви також можете тимчасово "
+"оминути тест за допомогою `#[ignore]`:"
 
 #: src/pattern-matching/exercise.md
 msgid ""
 "If you finish early, try writing a test that results in division by zero or "
 "integer overflow. How could you handle this with `Result` instead of a panic?"
 msgstr ""
+"Якщо ви закінчили раніше, спробуйте написати тест, який призводить до "
+"ділення на нуль або цілочисельного переповнення. Як ви могли б впоратися з "
+"цим за допомогою `Result` замість того, щоб панікувати?"
 
 #: src/pattern-matching/exercise.md src/pattern-matching/solution.md
 msgid "/// An operation to perform on two subexpressions.\n"
-msgstr ""
+msgstr "/// Операція для виконання над двома під-виразами.\n"
 
 #: src/pattern-matching/exercise.md src/pattern-matching/solution.md
 msgid "/// An expression, in tree form.\n"
-msgstr ""
+msgstr "/// Вираз у вигляді дерева.\n"
 
 #: src/pattern-matching/exercise.md src/pattern-matching/solution.md
 msgid "/// An operation on two subexpressions.\n"
-msgstr ""
+msgstr "/// Операція над двома підвиразами.\n"
 
 #: src/pattern-matching/exercise.md src/pattern-matching/solution.md
 msgid "/// A literal value\n"
-msgstr ""
+msgstr "/// Літеральне значення\n"
 
 #: src/pattern-matching/exercise.md src/pattern-matching/solution.md
 msgid "\"division by zero\""
-msgstr ""
+msgstr "\"ділення на нуль\""
 
 #: src/pattern-matching/solution.md
 msgid "\"expr: {:?}\""
-msgstr ""
+msgstr "\"expr: {:?}\""
 
 #: src/methods-and-traits.md
 msgid "[Methods](./methods-and-traits/methods.md) (10 minutes)"
-msgstr ""
+msgstr "[Методи](./methods-and-traits/methods.md) (10 хвилин)"
 
 #: src/methods-and-traits.md
 msgid "[Traits](./methods-and-traits/traits.md) (10 minutes)"
-msgstr ""
+msgstr "[Трейти](./methods-and-traits/traits.md) (10 хвилин)"
 
 #: src/methods-and-traits.md
 msgid "[Deriving](./methods-and-traits/deriving.md) (5 minutes)"
-msgstr ""
+msgstr "[Виведення](./methods-and-traits/deriving.md) (5 хвилин)"
 
 #: src/methods-and-traits.md
 msgid "[Trait Objects](./methods-and-traits/trait-objects.md) (10 minutes)"
-msgstr ""
+msgstr "[Об'єкти трейтів](./methods-and-traits/trait-objects.md) (10 хвилин)"
 
 #: src/methods-and-traits.md
 msgid ""
 "[Exercise: Generic Logger](./methods-and-traits/exercise.md) (20 minutes)"
 msgstr ""
+"[Вправа: Загальний логгер](./methods-and-traits/exercise.md) (20 хвилин)"
 
 #: src/methods-and-traits.md
 msgid "This segment should take about 55 minutes"
-msgstr ""
+msgstr "Цей сегмент повинен зайняти близько 55 хвилин"
 
 #: src/methods-and-traits/methods.md
 msgid ""
@@ -5668,64 +5696,63 @@ msgstr ""
 
 #: src/methods-and-traits/methods.md
 msgid "// No receiver, a static method\n"
-msgstr ""
+msgstr "// Немає отримувача, статичний метод\n"
 
 #: src/methods-and-traits/methods.md
 msgid "// Exclusive borrowed read-write access to self\n"
-msgstr ""
+msgstr "// Ексклюзивний запозичений доступ на читання та запис до себе\n"
 
 #: src/methods-and-traits/methods.md
 msgid "// Shared and read-only borrowed access to self\n"
-msgstr ""
+msgstr "// Спільний та запозичений доступ тільки на читання до себе\n"
 
 #: src/methods-and-traits/methods.md
 msgid "\"Recorded {} laps for {}:\""
-msgstr ""
+msgstr "\"Записано {} кіл для {}:\""
 
 #: src/methods-and-traits/methods.md
 msgid "\"Lap {idx}: {lap} sec\""
-msgstr ""
+msgstr "\"Коло {idx}: {lap} sec\""
 
 #: src/methods-and-traits/methods.md
 msgid "// Exclusive ownership of self\n"
-msgstr ""
+msgstr "// Виключне володіння собою\n"
 
 #: src/methods-and-traits/methods.md
 msgid "\"Race {} is finished, total lap time: {}\""
-msgstr ""
+msgstr "\"Гонка {} завершена, загальний час проходження кола: {}\""
 
 #: src/methods-and-traits/methods.md
 msgid "\"Monaco Grand Prix\""
-msgstr ""
+msgstr "\"Гран-прі Монако\""
 
 #: src/methods-and-traits/methods.md
 msgid "// race.add_lap(42);\n"
-msgstr ""
+msgstr "// race.add_lap(42);\n"
 
 #: src/methods-and-traits/methods.md
-#, fuzzy
 msgid ""
 "The `self` arguments specify the \"receiver\" - the object the method acts "
 "on. There are several common receivers for a method:"
 msgstr ""
-"`&self` вище вказує на те, що метод незмінно позичає об’єкт. Існують інші "
-"можливі приймачі для методу:"
+"Аргументи `self` визначають \"отримувача\" - об'єкт, на який діє метод. "
+"Існує декілька типових отримувачів для методу:"
 
 #: src/methods-and-traits/methods.md
 msgid ""
 "`&self`: borrows the object from the caller using a shared and immutable "
 "reference. The object can be used again afterwards."
 msgstr ""
-"`&self`: запозичує об’єкт у викликаючого за допомогою загального та "
-"незмінного посилання. Після цього об’єкт можна використовувати знову."
+"`&self`: запозичує об’єкт у викликувача за допомогою спільного та незмінного "
+"посилання. Після цього об’єкт можна використовувати знову."
 
 #: src/methods-and-traits/methods.md
 msgid ""
 "`&mut self`: borrows the object from the caller using a unique and mutable "
 "reference. The object can be used again afterwards."
 msgstr ""
-"`&mut self`: запозичує об’єкт у абонента, використовуючи унікальне та змінне "
-"посилання. Після цього об’єкт можна використовувати знову."
+"`&mut self`: запозичує об’єкт у викликувача, використовуючи унікальне та "
+"мутабельне посилання. Після цього об’єкт можна використовувати знову."
 
 #: src/methods-and-traits/methods.md
 msgid ""
@@ -5734,13 +5761,12 @@ msgid ""
 "(deallocated) when the method returns, unless its ownership is explicitly "
 "transmitted. Complete ownership does not automatically mean mutability."
 msgstr ""
-"`self`: приймає право власності на об'єкт і переміщує його від абонента. "
-"Метод стає власником об'єкта. Об’єкт буде видалено (вилучено), коли метод "
-"повертається, якщо його право власності не передано явно. Повна власність не "
-"означає автоматично зміни."
+"`self`: приймає право власності на об'єкт і переміщує його від викликувача. "
+"Метод стає власником об'єкта. Об’єкт буде видалено (звільнено), коли метод "
+"завершиться, якщо володіння їм не передано явно. Повне володіння не означає "
+"автоматичної мутабельності."
 
 #: src/methods-and-traits/methods.md
-#, fuzzy
 msgid "`mut self`: same as above, but the method can mutate the object."
 msgstr "`mut self`: те саме, що й вище, але метод може змінювати об’єкт."
 
@@ -5751,7 +5777,7 @@ msgid ""
 msgstr ""
 "Немає отримувача: це стає статичним методом у структурі. Зазвичай "
 "використовується для створення конструкторів, які за домовленістю "
-"називаються «новими»."
+"називаються `new`."
 
 #: src/methods-and-traits/methods.md
 msgid "It can be helpful to introduce methods by comparing them to functions."
@@ -5762,8 +5788,8 @@ msgid ""
 "Methods are called on an instance of a type (such as a struct or enum), the "
 "first parameter represents the instance as `self`."
 msgstr ""
-"Методи викликаються для екземпляра типу (наприклад, struct або enum), перший "
-"параметр представляє екземпляр як `self`."
+"Методи викликаються для екземпляра типу (такі як структура або перелік), "
+"перший параметр представляє екземпляр як `self`."
 
 #: src/methods-and-traits/methods.md
 msgid ""
@@ -5772,14 +5798,14 @@ msgid ""
 "all the implementation code in one predictable place."
 msgstr ""
 "Розробники можуть використовувати методи, щоб скористатися перевагами "
-"синтаксису приймача методів і допомогти їм бути більш організованими. "
+"синтаксису отримувача методів і допомогти їм бути більш організованими. "
 "Використовуючи методи, ми можемо зберігати весь код реалізації в одному "
 "передбачуваному місці."
 
 #: src/methods-and-traits/methods.md
 msgid "Point out the use of the keyword `self`, a method receiver."
 msgstr ""
-"Зверніть увагу на використання ключового слова `self`, приймача методу."
+"Зверніть увагу на використання ключового слова `self`, отримувача методу."
 
 #: src/methods-and-traits/methods.md
 msgid ""
@@ -5806,13 +5832,12 @@ msgstr ""
 "нотація може використовуватися для посилання на окремі поля."
 
 #: src/methods-and-traits/methods.md
-#, fuzzy
 msgid ""
 "This might be a good time to demonstrate how the `&self` differs from `self` "
 "by trying to run `finish` twice."
 msgstr ""
 "Це може бути гарний час, щоб продемонструвати, чим `&self` відрізняється від "
-"`self`, змінивши код і спробувавши запустити say_hello двічі."
+"`self`, спробувавши запустити `finish` двічі."
 
 #: src/methods-and-traits/methods.md
 msgid ""
@@ -5820,78 +5845,82 @@ msgid ""
 "doc.rust-lang.org/reference/special-types-and-traits.html) allowed to be "
 "receiver types, such as `Box<Self>`."
 msgstr ""
-"Окрім варіантів `self`, існують також [спеціальні типи оболонки](https://doc."
+"Окрім варіантів `self`, існують також [спеціальні типи обгорток](https://doc."
 "rust-lang.org/reference/special-types-and-traits.html), які можуть бути "
-"типами приймачів, наприклад `Box <Self>`."
+"типами отримувачів, наприклад `Box<Self>`."
 
 #: src/methods-and-traits/traits.md
 msgid ""
 "Rust lets you abstract over types with traits. They're similar to interfaces:"
 msgstr ""
-"Rust дозволяє абстрагуватися від типів із рисами. Вони схожі на інтерфейси:"
+"Rust дозволяє абстрагування над типами за допомогою трейтів. Вони схожі на "
+"інтерфейси:"
 
 #: src/methods-and-traits/traits.md
 msgid "\"Oh you're a cutie! What's your name? {}\""
-msgstr ""
+msgstr "\"Який же ти милий! Як тебе звати? {}\""
 
 #: src/methods-and-traits/traits.md src/methods-and-traits/trait-objects.md
 msgid "\"Woof, my name is {}!\""
-msgstr ""
+msgstr "\"Гав, мене звуть {}!\""
 
 #: src/methods-and-traits/traits.md src/methods-and-traits/trait-objects.md
 msgid "\"Miau!\""
-msgstr ""
+msgstr "\"Мяу!\""
 
 #: src/methods-and-traits/traits.md src/methods-and-traits/trait-objects.md
 msgid "\"Fido\""
-msgstr ""
+msgstr "\"Фідо\""
 
 #: src/methods-and-traits/traits.md
 msgid ""
 "A trait defines a number of methods that types must have in order to "
 "implement the trait."
 msgstr ""
+"Трейт визначає ряд методів, які повинні мати типи, щоб реалізувати цій трейт."
 
 #: src/methods-and-traits/traits.md
 msgid "Traits are implemented in an `impl <trait> for <type> { .. }` block."
-msgstr ""
+msgstr "Трейти реалізуються у блоці `impl <trait> for <type> { .. }` блоці."
 
 #: src/methods-and-traits/traits.md
-#, fuzzy
 msgid ""
 "Traits may specify pre-implemented (provided) methods and methods that users "
 "are required to implement themselves. Provided methods can rely on required "
 "methods. In this case, `greet` is provided, and relies on `talk`."
 msgstr ""
-"Характеристики можуть визначати попередньо реалізовані (за замовчуванням) "
-"методи та методи, які користувачі повинні реалізувати самостійно. Методи з "
-"реалізаціями за замовчуванням можуть покладатися на необхідні методи."
+"Трейти можуть визначати попередньо реалізовані (попередньо надані) методи та "
+"методи, які користувачі повинні реалізувати самостійно. Попередньо надані "
+"методи можуть покладатися на обов'язкові методи. У цьому прикладі `greet` є "
+"попередньо наданим і покладається на `talk`."
 
 #: src/methods-and-traits/deriving.md
 msgid ""
 "Supported traits can be automatically implemented for your custom types, as "
 "follows:"
 msgstr ""
+"Підтримувані трейти можуть бути автоматично застосовані до ваших кастомних "
+"типів наступним чином:"
 
 #: src/methods-and-traits/deriving.md
 msgid "// Default trait adds `default` constructor.\n"
-msgstr ""
+msgstr "// Трейт Default додає `default` конструктор .\n"
 
 #: src/methods-and-traits/deriving.md
 msgid "// Clone trait adds `clone` method.\n"
-msgstr ""
+msgstr "// Трейт Clone додає `clone` метод.\n"
 
 #: src/methods-and-traits/deriving.md
 msgid "\"EldurScrollz\""
-msgstr ""
+msgstr "\"EldurScrollz\""
 
 #: src/methods-and-traits/deriving.md
 msgid "// Debug trait adds support for printing with `{:?}`.\n"
-msgstr ""
+msgstr "// Трейт Debug додає підтримку друку з `{:?}`.\n"
 
 #: src/methods-and-traits/deriving.md
 msgid "\"{:?} vs. {:?}\""
-msgstr ""
+msgstr "\"{:?} vs. {:?}\""
 
 #: src/methods-and-traits/deriving.md
 msgid ""
@@ -5899,20 +5928,25 @@ msgid ""
 "macros to add useful functionality. For example, `serde` can derive "
 "serialization support for a struct using `#[derive(Serialize)]`."
 msgstr ""
+"Виведення реалізовано за допомогою макросів, і багато крейтів надають "
+"корисні макроси виведення для додавання корисної функціональності. "
+"Наприклад, `serde` може виводити підтримку серіалізації для структури за "
+"допомогою `#[derive(Serialize)]`."
 
 #: src/methods-and-traits/trait-objects.md
 msgid ""
 "Trait objects allow for values of different types, for instance in a "
 "collection:"
-msgstr "Об’єкти ознак допускають значення різних типів, наприклад, у колекції:"
+msgstr ""
+"Об’єкти трейтів допускають значення різних типів, наприклад, у колекції:"
 
 #: src/methods-and-traits/trait-objects.md
 msgid "\"Hello, who are you? {}\""
-msgstr ""
+msgstr "\"Привіт, ви хто? {}\""
 
 #: src/methods-and-traits/trait-objects.md
 msgid "Memory layout after allocating `pets`:"
-msgstr "Розташування пам’яті після виділення «домашніх тварин»:"
+msgstr "Розташування пам’яті після виділення `pets`:"
 
 #: src/methods-and-traits/trait-objects.md
 msgid ""
@@ -5976,13 +6010,13 @@ msgid ""
 msgstr ""
 
 #: src/methods-and-traits/trait-objects.md
-#, fuzzy
 msgid ""
 "Types that implement a given trait may be of different sizes. This makes it "
 "impossible to have things like `Vec<dyn Pet>` in the example above."
 msgstr ""
-"Типи, які реалізують дану властивість, можуть бути різного розміру. Це "
-"унеможливлює наявність таких речей, як `Vec<Pet>` у прикладі вище."
+"Типи, що реалізують певний трейт, можуть бути різних розмірів. Це "
+"унеможливлює створення таких типів, як `Vec<dyn Pet>` у наведеному вище "
+"прикладі."
 
 #: src/methods-and-traits/trait-objects.md
 msgid ""
@@ -5997,25 +6031,28 @@ msgid ""
 "In the example, `pets` is allocated on the stack and the vector data is on "
 "the heap. The two vector elements are _fat pointers_:"
 msgstr ""
+"У прикладі `pets` розміщується у стеку, а векторні дані - у купі. Два "
+"векторні елементи є _жирними вказівниками_:"
 
 #: src/methods-and-traits/trait-objects.md
-#, fuzzy
 msgid ""
 "A fat pointer is a double-width pointer. It has two components: a pointer to "
 "the actual object and a pointer to the [virtual method table](https://en."
 "wikipedia.org/wiki/Virtual_method_table) (vtable) for the `Pet` "
 "implementation of that particular object."
 msgstr ""
-"У прикладі `pets` містить _жирні покажчики_ на об’єкти, які реалізують "
-"`Pet`. Жирний вказівник складається з двох компонентів, вказівника на "
-"фактичний об’єкт і вказівника на таблицю віртуальних методів для реалізації "
-"`Pet` цього конкретного об'єкта."
+"Жирний вказівник - це вказівник подвійної ширини. Він складається з двох "
+"компонентів: вказівника на власне об'єкт і вказівника на [таблицю "
+"віртуальних методів](https://en.wikipedia.org/wiki/Virtual_method_table) "
+"(vtable) для реалізації `Pet` цього конкретного об'єкта."
 
 #: src/methods-and-traits/trait-objects.md
 msgid ""
 "The data for the `Dog` named Fido is the `name` and `age` fields. The `Cat` "
 "has a `lives` field."
 msgstr ""
+"Дані для `СобаDogи` на ім'я Фідо - це поля `name` та age`. Для `Cat` є поле "
+"`lives`."
 
 #: src/methods-and-traits/trait-objects.md
 msgid "Compare these outputs in the above example:"
@@ -6023,7 +6060,7 @@ msgstr "Порівняйте ці результати в наведеному 
 
 #: src/methods-and-traits/trait-objects.md src/std-traits/closures.md
 msgid "\"{} {}\""
-msgstr ""
+msgstr "\"{} {}\""
 
 #: src/methods-and-traits/trait-objects.md src/std-traits/exercise.md
 #: src/std-traits/solution.md src/modules/exercise.md src/modules/solution.md
@@ -6031,7 +6068,7 @@ msgstr ""
 #: src/android/interoperability/cpp/rust-bridge.md
 #: src/async/pitfalls/cancellation.md
 msgid "\"{}\""
-msgstr ""
+msgstr "\"{}\""
 
 #: src/methods-and-traits/exercise.md
 msgid ""
@@ -6040,6 +6077,11 @@ msgid ""
 "In testing, this might put messages in the test logfile, while in a "
 "production build it would send messages to a log server."
 msgstr ""
+"Давайте розробимо просту утиліту для ведення логів, використовуючи трейт "
+"`Logger` з методом `log`. Код, який може реєструвати свій прогрес, може "
+"отримати `&impl Logger`. Під час тестування це може призвести до запису "
+"повідомлень до тестового лог-файлу, тоді як у виробничій збірці повідомлення "
+"надсилатимуться до сервера логів."
 
 #: src/methods-and-traits/exercise.md
 msgid ""
@@ -6047,6 +6089,9 @@ msgid ""
 "verbosity. Your task is to write a `VerbosityFilter` type that will ignore "
 "messages above a maximum verbosity."
 msgstr ""
+"Однак, наведений нижче `StderrLogger` реєструє всі повідомлення, незалежно "
+"від їхньої докладності. Ваше завдання - написати тип `VerbosityFilter`, який "
+"ігноруватиме повідомлення з максимальною докладностю."
 
 #: src/methods-and-traits/exercise.md
 msgid ""
@@ -6054,90 +6099,94 @@ msgid ""
 "implementing that same trait, adding behavior in the process. What other "
 "kinds of wrappers might be useful in a logging utility?"
 msgstr ""
+"Це поширений патерн: структура, що обгортає реалізацію трейту і реалізує той "
+"самий трейт, додаючи поведінку в процесі. Які ще типи обгорток можуть бути "
+"корисними у утиліті для ведення логів?"
 
 #: src/methods-and-traits/exercise.md src/methods-and-traits/solution.md
 msgid "/// Log a message at the given verbosity level.\n"
-msgstr ""
+msgstr "/// Запишіть повідомлення із заданим рівнем докладності.\n"
 
 #: src/methods-and-traits/exercise.md src/methods-and-traits/solution.md
 msgid "\"verbosity={verbosity}: {message}\""
-msgstr ""
+msgstr "\"verbosity={verbosity}: {message}\""
 
 #: src/methods-and-traits/exercise.md src/methods-and-traits/solution.md
 msgid "\"FYI\""
-msgstr ""
+msgstr "\"FYI\""
 
 #: src/methods-and-traits/exercise.md src/methods-and-traits/solution.md
 msgid "\"Uhoh\""
-msgstr ""
+msgstr "\"Uhoh\""
 
 #: src/methods-and-traits/exercise.md
 msgid "// TODO: Define and implement `VerbosityFilter`.\n"
-msgstr ""
+msgstr "// TODO: Визначте та реалізуйте `VerbosityFilter`.\n"
 
 #: src/methods-and-traits/solution.md
 msgid "/// Only log messages up to the given verbosity level.\n"
-msgstr ""
+msgstr "/// Записуйте повідомлення лише до заданого рівня докладності.\n"
 
 #: src/generics.md
 msgid "[Generic Functions](./generics/generic-functions.md) (5 minutes)"
-msgstr ""
+msgstr "[Узагальнені  функції](./generics/generic-functions.md) (5 хвилин)"
 
 #: src/generics.md
 msgid "[Generic Data Types](./generics/generic-data.md) (15 minutes)"
-msgstr ""
+msgstr "[Узагальнені типи даних](./generics/generic-data.md) (15 хвилин)"
 
 #: src/generics.md
 msgid "[Trait Bounds](./generics/trait-bounds.md) (10 minutes)"
-msgstr ""
+msgstr "[Межі трейтів](./generics/trait-bounds.md) (10 хвилин)"
 
 #: src/generics.md
 msgid "[impl Trait](./generics/impl-trait.md) (5 minutes)"
-msgstr ""
+msgstr "[impl Trait](./generics/impl-trait.md) (5 хвилин)"
 
 #: src/generics.md
 msgid "[Exercise: Generic min](./generics/exercise.md) (10 minutes)"
-msgstr ""
+msgstr "[Вправа: Узагальний min](./generics/exercise.md) (10 хвилин)"
 
 #: src/generics.md src/smart-pointers.md src/iterators.md src/error-handling.md
 msgid "This segment should take about 45 minutes"
-msgstr ""
+msgstr "Цей сегмент повинен зайняти близько 45 хвилин"
 
 #: src/generics/generic-functions.md
-#, fuzzy
 msgid ""
 "Rust supports generics, which lets you abstract algorithms or data "
 "structures (such as sorting or a binary tree) over the types used or stored."
 msgstr ""
-"Rust підтримує універсали, які дозволяють абстрактні алгоритми або структури "
-"даних (наприклад, сортування або бінарне дерево) над типами, які "
+"Rust підтримує узагальнені типи, що дозволяє абстрагувати алгоритми або "
+"структури даних (наприклад, сортування або бінарне дерево) від типів, що "
 "використовуються або зберігаються."
 
 #: src/generics/generic-functions.md
 msgid "/// Pick `even` or `odd` depending on the value of `n`.\n"
-msgstr ""
+msgstr "/// Виберіть `even` або `odd` в залежності від значення `n`.\n"
 
 #: src/generics/generic-functions.md
 msgid "\"picked a number: {:?}\""
-msgstr ""
+msgstr "\"вибраний номер: {:?}\""
 
 #: src/generics/generic-functions.md
 msgid "\"picked a tuple: {:?}\""
-msgstr ""
+msgstr "\"вибраний кортеж: {:?}\""
 
 #: src/generics/generic-functions.md
 msgid "\"dog\""
-msgstr ""
+msgstr "\"собака\""
 
 #: src/generics/generic-functions.md
 msgid "\"cat\""
-msgstr ""
+msgstr "\"кіт\""
 
 #: src/generics/generic-functions.md
 msgid ""
 "Rust infers a type for T based on the types of the arguments and return "
 "value."
 msgstr ""
+"Rust визначає тип для T на основі типів аргументів та значення, що "
+"повертається."
 
 #: src/generics/generic-functions.md
 msgid ""
@@ -6147,55 +6196,61 @@ msgid ""
 "`n == 0`. Even if only the `pick` instantiation with integers is used, Rust "
 "still considers it invalid. C++ would let you do this."
 msgstr ""
+"Це схоже на шаблони C++, але Rust частково компілює узагальнену функцію "
+"одразу, тому ця функція має бути валідною для всіх типів, що відповідають "
+"обмеженням. Наприклад, спробуйте модифікувати `pick` так, щоб вона повертала "
+"`even + odd`, якщо `n == 0`. Навіть якщо використовується лише екземпляр "
+"`pick` з цілими числами, Rust все одно вважатиме його невірним. C++ "
+"дозволить вам зробити це."
 
 #: src/generics/generic-functions.md
-#, fuzzy
 msgid ""
 "Generic code is turned into non-generic code based on the call sites. This "
 "is a zero-cost abstraction: you get exactly the same result as if you had "
 "hand-coded the data structures without the abstraction."
 msgstr ""
-"Це абстракція з нульовими витратами: ви отримуєте точно такий самий "
-"результат, ніби ви вручну кодували структури даних без абстракції."
+"Узагальнений код перетворюється на не-узагальнений на основі сайтів виклику. "
+"Це абстракція з нульовою вартістю: ви отримуєте точно такий же результат, як "
+"якщо б ви написали структури даних власноруч без абстракції."
 
 #: src/generics/generic-data.md
 msgid "You can use generics to abstract over the concrete field type:"
 msgstr ""
-"Ви можете використовувати генерики для абстрагування над конкретним типом "
-"поля:"
+"Ви можете використовувати узагальнення для абстрагування від конкретного "
+"типу поля:"
 
 #: src/generics/generic-data.md
 msgid "// fn set_x(&mut self, x: T)\n"
-msgstr ""
+msgstr "// fn set_x(&mut self, x: T)\n"
 
 #: src/generics/generic-data.md
 msgid "\"{integer:?} and {float:?}\""
-msgstr ""
+msgstr "\"{integer:?} та {float:?}\""
 
 #: src/generics/generic-data.md
 msgid "\"coords: {:?}\""
-msgstr ""
+msgstr "\"координати: {:?}\""
 
 #: src/generics/generic-data.md
 msgid ""
 "_Q:_ Why `T` is specified twice in `impl<T> Point<T> {}`? Isn't that "
 "redundant?"
-msgstr "_З:_ Чому `T` вказано двічі в `impl<T> Point<T> {}`? Хіба це не зайве?"
+msgstr ""
+"_З:_ Чому `T` вказаний двічі в `impl<T> Point<T> {}`? Хіба це не зайве?"
 
 #: src/generics/generic-data.md
 msgid ""
 "This is because it is a generic implementation section for generic type. "
 "They are independently generic."
 msgstr ""
-"Це пояснюється тим, що це розділ загальної реалізації для загального типу. "
-"Вони самостійно є родовими."
+"Це пояснюється тим, що це частина узагальненої реалізації для узагальненого "
+"типу. Вони є узагальненими незалежно один від одного.."
 
 #: src/generics/generic-data.md
 msgid "It means these methods are defined for any `T`."
 msgstr "Це означає, що ці методи визначені для будь-якого `T`."
 
 #: src/generics/generic-data.md
-#, fuzzy
 msgid "It is possible to write `impl Point<u32> { .. }`."
 msgstr "Можна написати `impl Point<u32> { .. }`."
 
@@ -6204,8 +6259,8 @@ msgid ""
 "`Point` is still generic and you can use `Point<f64>`, but methods in this "
 "block will only be available for `Point<u32>`."
 msgstr ""
-"`Point` все ще є загальним, і ви можете використовувати `Point<f64>`, але "
-"методи в цьому блоці будуть доступні лише для `Point<u32>`."
+"`Point` все ще є узагальненим типом, і ви можете використовувати "
+"`Point<f64>`, але методи в цьому блоці будуть доступні лише для `Point<u32>`."
 
 #: src/generics/generic-data.md
 msgid ""
@@ -6213,14 +6268,17 @@ msgid ""
 "code to allow points that have elements of different types, by using two "
 "type variables, e.g., `T` and `U`."
 msgstr ""
+"Спробуйте оголосити нову змінну `let p = Point { x: 5, y: 10.0 };`. Оновіть "
+"код, щоб дозволити створювати точки, які мають елементи різних типів, "
+"використовуючи дві змінні типу, наприклад, `T` і `U`."
 
 #: src/generics/trait-bounds.md
 msgid ""
 "When working with generics, you often want to require the types to implement "
 "some trait, so that you can call this trait's methods."
 msgstr ""
-"Працюючи з генериками, ви часто хочете вимагати, щоб типи реалізували певну "
-"ознаку, щоб ви могли викликати методи цієї ознаки."
+"При роботі з узагальненнями ви часто потребуєте, щоб типи реалізовували "
+"деякий трейт, щоб ви могли викликати методи цього трейту."
 
 #: src/generics/trait-bounds.md
 msgid "You can do this with `T: Trait` or `impl Trait`:"
@@ -6228,24 +6286,25 @@ msgstr "Ви можете зробити це за допомогою `T: Trait`
 
 #: src/generics/trait-bounds.md
 msgid "// struct NotClonable;\n"
-msgstr ""
+msgstr "// struct NotClonable;\n"
 
 #: src/generics/trait-bounds.md
 msgid "\"{pair:?}\""
-msgstr ""
+msgstr "\"{pair:?}\""
 
 #: src/generics/trait-bounds.md
 msgid "Try making a `NonClonable` and passing it to `duplicate`."
-msgstr ""
+msgstr "Спробуйте зробити `NonClonable` і передати його в `duplicate`."
 
 #: src/generics/trait-bounds.md
 msgid "When multiple traits are necessary, use `+` to join them."
 msgstr ""
+"Якщо потрібно вказати декілька трейтів, використовуйте `+`, щоб об'єднати їх."
 
 #: src/generics/trait-bounds.md
 msgid "Show a `where` clause, students will encounter it when reading code."
 msgstr ""
-"Покажіть речення `where`, студенти зустрінуть його під час читання коду."
+"Покажіть вираз `where`, студенти зустрінуться з ним під час читання коду."
 
 #: src/generics/trait-bounds.md
 msgid "It declutters the function signature if you have many parameters."
@@ -6260,21 +6319,24 @@ msgid ""
 "If someone asks, the extra feature is that the type on the left of \":\" can "
 "be arbitrary, like `Option<T>`."
 msgstr ""
-"Якщо хтось запитає, додаткова функція полягає в тому, що тип ліворуч від \":"
-"\" може бути довільним, наприклад `Option<T>`."
+"Якщо хтось запитає, додаткова можливість полягає в тому, що тип ліворуч від "
+"\":\" може бути довільним, наприклад `Option<T>`."
 
 #: src/generics/trait-bounds.md
 msgid ""
 "Note that Rust does not (yet) support specialization. For example, given the "
 "original `duplicate`, it is invalid to add a specialized `duplicate(a: u32)`."
 msgstr ""
+"Зауважте, що Rust (поки що) не підтримує спеціалізацію. Наприклад, за "
+"наявності оригінального `duplicate` додавання спеціалізованого `duplicate(a: "
+"u32)` є некоректним."
 
 #: src/generics/impl-trait.md
 msgid ""
 "Similar to trait bounds, an `impl Trait` syntax can be used in function "
 "arguments and return values:"
 msgstr ""
-"Подібно до меж ознак, синтаксис `impl Trait` можна використовувати в "
+"Подібно до меж трейтів, синтаксис `impl Trait` можна використовувати в "
 "аргументах функції та значеннях, що повертаються:"
 
 #: src/generics/impl-trait.md
@@ -6282,33 +6344,36 @@ msgid ""
 "// Syntactic sugar for:\n"
 "//   fn add_42_millions<T: Into<i32>>(x: T) -> i32 {\n"
 msgstr ""
+"// Синтаксичний цукор для:\n"
+"//   fn add_42_millions<T: Into<i32>>(x: T) -> i32 {\n"
 
 #: src/generics/impl-trait.md
 msgid "\"{many}\""
-msgstr ""
+msgstr "\"{many}\""
 
 #: src/generics/impl-trait.md
 msgid "\"{many_more}\""
-msgstr ""
+msgstr "\"{many_more}\""
 
 #: src/generics/impl-trait.md
 msgid "\"debuggable: {debuggable:?}\""
-msgstr ""
+msgstr "\"debuggable: {debuggable:?}\""
 
 #: src/generics/impl-trait.md
-#, fuzzy
 msgid ""
 "`impl Trait` allows you to work with types which you cannot name. The "
 "meaning of `impl Trait` is a bit different in the different positions."
-msgstr "Значення \"impl Trait\" дещо відрізняється в різних позиціях."
+msgstr ""
+"`impl Trait` дозволяє працювати з типами, які ви не можете назвати. Значення "
+"`impl Trait` дещо відрізняється у різних позиціях."
 
 #: src/generics/impl-trait.md
 msgid ""
 "For a parameter, `impl Trait` is like an anonymous generic parameter with a "
 "trait bound."
 msgstr ""
-"Для параметра `impl Trait` схожий на анонімний загальний параметр із "
-"прив’язкою ознаки."
+"У випадку параметра, `impl Trait` - це як анонімний загальний параметрp з "
+"обмеженням трейту."
 
 #: src/generics/impl-trait.md
 msgid ""
@@ -6317,8 +6382,8 @@ msgid ""
 "don't want to expose the concrete type in a public API."
 msgstr ""
 "Для типу, що повертається, це означає, що тип, що повертається, є деяким "
-"конкретним типом, який реалізує властивість, без назви типу. Це може бути "
-"корисно, коли ви не хочете показувати конкретний тип у публічному API."
+"конкретним типом, який реалізує трейт, без назви типу. Це може бути корисно, "
+"коли ви не хочете викривати конкретний тип у публічному API."
 
 #: src/generics/impl-trait.md
 msgid ""
@@ -6329,40 +6394,44 @@ msgid ""
 "`let x: Vec<_> = foo.collect()` or with the turbofish, `foo.collect::"
 "<Vec<_>>()`."
 msgstr ""
-"У зворотній позиції важко зробити висновок. Функція, що повертає `impl Foo`, "
-"вибирає конкретний тип, який вона повертає, не записуючи його в коді. "
-"Функція, що повертає загальний тип, як-от `collect<B>() -> B`, може "
-"повертати будь-який тип, який задовольняє `B`, і абоненту може знадобитися "
-"вибрати один, наприклад, `let x: Vec<_> = foo. collect()` або з turbofish, "
-"`foo.collect::<Vec<_>>()`."
+"У позиції повернення виведення є складним. Функція, що повертає `impl Foo`, "
+"вибирає конкретний тип, який вона повертає, не записуючи його у вихідному "
+"коді. Функція, що повертає узагальнений тип, наприклад, `collect<B>() -> B`, "
+"може повернути будь-який тип, що задовольняє `B`, і користувачеві може "
+"знадобитися вибрати один з них, наприклад, за допомогою `let x: Vec<_> = foo."
+"collect()` або turbofish, `foo.collect::<Vec<_>>()`."
 
 #: src/generics/impl-trait.md
 msgid ""
 "What is the type of `debuggable`? Try `let debuggable: () = ..` to see what "
 "the error message shows."
 msgstr ""
+"Який тип `debuggable`? Спробуйте `let debuggable: () = ..`, щоб побачити "
+"повідомлення про помилку."
 
 #: src/generics/exercise.md
 msgid ""
 "In this short exercise, you will implement a generic `min` function that "
 "determines the minimum of two values, using a `LessThan` trait."
 msgstr ""
+"У цій короткій вправі ви реалізуєте узагальнену функцію `min`, яка визначає "
+"мінімальне з двох значень, використовуючи трейт `LessThan`."
 
 #: src/generics/exercise.md src/generics/solution.md
 msgid "/// Return true if self is less than other.\n"
-msgstr ""
+msgstr "/// Повертає true, якщо власник менший за іншого.\n"
 
 #: src/generics/exercise.md
 msgid "// TODO: implement the `min` function used in `main`.\n"
-msgstr ""
+msgstr "// TODO: реалізуйте функцію `min`, яка використовується в `main`.\n"
 
 #: src/generics/exercise.md src/generics/solution.md
 msgid "\"Shapiro\""
-msgstr ""
+msgstr "\"Shapiro\""
 
 #: src/generics/exercise.md src/generics/solution.md
 msgid "\"Baumann\""
-msgstr ""
+msgstr "\"Baumann\""
 
 #: src/welcome-day-2-afternoon.md
 msgid "[Standard Library Types](./std-types.md) (1 hour and 10 minutes)"