diff --git a/po/ko.po b/po/ko.po
index ae5b4155..33bd39ea 100644
--- a/po/ko.po
+++ b/po/ko.po
@@ -2,7 +2,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: [한국어]Comprehensive Rust 🦀\n"
 "POT-Creation-Date: \n"
-"PO-Revision-Date: 2023-02-19 06:58+0000\n"
+"PO-Revision-Date: 2023-02-20 13:05+0900\n"
 "Last-Translator: keispace <keispace.kyj@google.com>\n"
 "Language-Team: \n"
 "Language: ko\n"
@@ -124,8 +124,8 @@ msgstr "메서드"
 msgid "Overloading"
 msgstr "오버로딩"
 
-#: src/SUMMARY.md:36 src/SUMMARY.md:65 src/SUMMARY.md:89 src/SUMMARY.md:118 src/SUMMARY.md:147
-#: src/SUMMARY.md:175 src/SUMMARY.md:198 src/SUMMARY.md:225
+#: src/SUMMARY.md:36 src/SUMMARY.md:65 src/SUMMARY.md:89 src/SUMMARY.md:118
+#: src/SUMMARY.md:147 src/SUMMARY.md:175 src/SUMMARY.md:198 src/SUMMARY.md:225
 msgid "Exercises"
 msgstr "연습문제"
 
@@ -832,8 +832,7 @@ msgid ""
 "writing code for Android itself, the operating system. "
 msgstr ""
 "이 강의에서는 러스트로 안드로이드 **어플리케이션**을 개발하는 것은 다루지 않습니다.\n"
-"이 강의에서 다루는 안드로이드 특화된 내용은 안드로이드 OS의 일부를 러스트로개발하는 것에 대한 것입"
-"니다."
+"이 강의에서 다루는 안드로이드 특화된 내용은 안드로이드 OS의 일부를 러스트로개발하는 것에 대한 것입니다."
 
 #: src/welcome.md:24
 msgid "## Non-Goals"
@@ -843,9 +842,7 @@ msgstr "## 제외사항"
 msgid ""
 "Rust is a large language and we won't be able to cover all of it in a few days.\n"
 "Some non-goals of this course are:"
-msgstr ""
-"러스트는 몇일만에 모든 것을 다루기에는 너무 큰 언어입니다. 그래서 아래와 같은것을 목표로 하지 않습"
-"니다."
+msgstr "러스트는 몇일만에 모든 것을 다루기에는 너무 큰 언어입니다. 그래서 아래와 같은것을 목표로 하지 않습니다."
 
 #: src/welcome.md:29
 msgid ""
@@ -857,11 +854,8 @@ msgid ""
 "  Book](https://doc.rust-lang.org/book/ch19-06-macros.html) and [Rust by\n"
 "  Example](https://doc.rust-lang.org/rust-by-example/macros.html) instead."
 msgstr ""
-"* 비동기적 러스트 사용법 --- 간단하게 언급정도는 하겠지만 좀 더 자세한 내용은 [Asynchronous "
-"Programming in Rust](https://rust-lang.github.io/async-book/)를 참조해주세요.\n"
-"* 매크로를 개발하는 방법. [Chapter 19.5 in the Rust Book](https://doc.rust-lang.org/book/ch19-06-"
-"macros.html)와 [Rust by Example](https://doc.rust-lang.org/rust-by-example/macros.html)를 참조하세"
-"요."
+"* 비동기적 러스트 사용법 --- 간단하게 언급정도는 하겠지만 좀 더 자세한 내용은 [Asynchronous Programming in Rust](https://rust-lang.github.io/async-book/)를 참조해주세요.\n"
+"* 매크로를 개발하는 방법. [Chapter 19.5 in the Rust Book](https://doc.rust-lang.org/book/ch19-06-macros.html)와 [Rust by Example](https://doc.rust-lang.org/rust-by-example/macros.html)를 참조하세요."
 
 #: src/welcome.md:37
 msgid "## Assumptions"
@@ -884,44 +878,56 @@ msgstr ""
 "C/C++을 모르더라도 동적 타입 언어(Python이나 JavaScript 등) 프로그래밍 경험이 \n"
 "있다면 따라오는데 큰 문제는 없을 것입니다."
 
-#: src/welcome.md:46 src/cargo/rust-ecosystem.md:19 src/cargo/code-samples.md:22
-#: src/cargo/running-locally.md:68 src/welcome-day-1.md:14 src/welcome-day-1/what-is-rust.md:19
+#: src/welcome.md:46 src/cargo/rust-ecosystem.md:19
+#: src/cargo/code-samples.md:22 src/cargo/running-locally.md:68
+#: src/welcome-day-1.md:14 src/welcome-day-1/what-is-rust.md:19
 #: src/hello-world.md:20 src/hello-world/small-example.md:21 src/why-rust.md:9
-#: src/why-rust/compile-time.md:14 src/why-rust/runtime.md:8 src/why-rust/modern.md:19
-#: src/basic-syntax/compound-types.md:28 src/basic-syntax/slices.md:18
-#: src/basic-syntax/string-slices.md:25 src/basic-syntax/functions.md:33
-#: src/basic-syntax/functions-interlude.md:25 src/exercises/day-1/morning.md:9
-#: src/exercises/day-1/for-loops.md:90 src/basic-syntax/variables.md:15
-#: src/basic-syntax/type-inference.md:24 src/basic-syntax/static-and-const.md:46
+#: src/why-rust/compile-time.md:14 src/why-rust/runtime.md:8
+#: src/why-rust/modern.md:19 src/basic-syntax/compound-types.md:28
+#: src/basic-syntax/slices.md:18 src/basic-syntax/string-slices.md:25
+#: src/basic-syntax/functions.md:33 src/basic-syntax/functions-interlude.md:25
+#: src/exercises/day-1/morning.md:9 src/exercises/day-1/for-loops.md:90
+#: src/basic-syntax/variables.md:15 src/basic-syntax/type-inference.md:24
+#: src/basic-syntax/static-and-const.md:46
 #: src/basic-syntax/scopes-shadowing.md:23 src/memory-management/stack.md:26
 #: src/memory-management/rust.md:12 src/ownership/move-semantics.md:20
 #: src/ownership/moves-function-calls.md:18 src/ownership/copy-clone.md:33
 #: src/ownership/borrowing.md:25 src/ownership/shared-unique-borrows.md:23
-#: src/ownership/lifetimes-function-calls.md:27 src/ownership/lifetimes-data-structures.md:23
+#: src/ownership/lifetimes-function-calls.md:27
+#: src/ownership/lifetimes-data-structures.md:23
 #: src/exercises/day-1/afternoon.md:9 src/structs/tuple-structs.md:35
-#: src/structs/field-shorthand.md:25 src/enums/variant-payloads.md:33 src/methods.md:28
-#: src/pattern-matching/destructuring-enums.md:33 src/pattern-matching/destructuring-arrays.md:18
+#: src/structs/field-shorthand.md:25 src/enums/variant-payloads.md:33
+#: src/methods.md:28 src/pattern-matching/destructuring-enums.md:33
+#: src/pattern-matching/destructuring-arrays.md:18
 #: src/pattern-matching/match-guards.md:20 src/exercises/day-2/morning.md:9
 #: src/exercises/day-2/points-polygons.md:115 src/control-flow/blocks.md:40
-#: src/control-flow/if-expressions.md:29 src/control-flow/if-let-expressions.md:19
-#: src/control-flow/while-let-expressions.md:25 src/control-flow/match-expressions.md:25
-#: src/std/option-result.md:16 src/std/string.md:28 src/std/vec.md:35 src/std/hashmap.md:36
-#: src/std/box.md:32 src/std/box-recursive.md:31 src/std/rc.md:29 src/modules.md:26
-#: src/modules/visibility.md:37 src/modules/filesystem.md:24 src/exercises/day-2/afternoon.md:5
-#: src/traits.md:39 src/traits/iterator.md:30 src/traits/from-iterator.md:15
+#: src/control-flow/if-expressions.md:29
+#: src/control-flow/if-let-expressions.md:19
+#: src/control-flow/while-let-expressions.md:25
+#: src/control-flow/match-expressions.md:25 src/std/option-result.md:16
+#: src/std/string.md:28 src/std/vec.md:35 src/std/hashmap.md:36
+#: src/std/box.md:32 src/std/box-recursive.md:31 src/std/rc.md:29
+#: src/modules.md:26 src/modules/visibility.md:37 src/modules/filesystem.md:24
+#: src/exercises/day-2/afternoon.md:5 src/traits.md:39
+#: src/traits/iterator.md:30 src/traits/from-iterator.md:15
 #: src/traits/operators.md:24 src/traits/drop.md:32 src/traits/default.md:38
-#: src/generics/methods.md:23 src/generics/trait-bounds.md:33 src/generics/impl-trait.md:22
-#: src/generics/closures.md:23 src/exercises/day-3/morning.md:5 src/error-handling/result.md:25
-#: src/error-handling/try-operator.md:48 src/error-handling/converting-error-types-example.md:48
-#: src/error-handling/deriving-error-enums.md:37 src/error-handling/dynamic-errors.md:34
-#: src/error-handling/error-contexts.md:33 src/unsafe.md:26 src/unsafe/raw-pointers.md:24
-#: src/unsafe/mutable-static-variables.md:30 src/unsafe/unions.md:19
-#: src/unsafe/writing-unsafe-functions.md:31 src/unsafe/extern-functions.md:19
-#: src/unsafe/unsafe-traits.md:28 src/exercises/day-3/afternoon.md:5 src/concurrency/threads.md:28
+#: src/generics/methods.md:23 src/generics/trait-bounds.md:33
+#: src/generics/impl-trait.md:22 src/generics/closures.md:23
+#: src/exercises/day-3/morning.md:5 src/error-handling/result.md:25
+#: src/error-handling/try-operator.md:48
+#: src/error-handling/converting-error-types-example.md:48
+#: src/error-handling/deriving-error-enums.md:37
+#: src/error-handling/dynamic-errors.md:34
+#: src/error-handling/error-contexts.md:33 src/unsafe.md:26
+#: src/unsafe/raw-pointers.md:24 src/unsafe/mutable-static-variables.md:30
+#: src/unsafe/unions.md:19 src/unsafe/writing-unsafe-functions.md:31
+#: src/unsafe/extern-functions.md:19 src/unsafe/unsafe-traits.md:28
+#: src/exercises/day-3/afternoon.md:5 src/concurrency/threads.md:28
 #: src/concurrency/channels.md:25 src/concurrency/shared_state/arc.md:27
 #: src/concurrency/shared_state/example.md:21 src/concurrency/send-sync.md:18
 #: src/concurrency/send-sync/sync.md:12 src/exercises/day-4/morning.md:10
-#: src/android/interoperability/with-c/rust.md:81 src/exercises/day-4/afternoon.md:10
+#: src/android/interoperability/with-c/rust.md:81
+#: src/exercises/day-4/afternoon.md:10
 msgid "<details>"
 msgstr "<details>"
 
@@ -934,37 +940,49 @@ msgstr ""
 "이것은 _발표자 노트_의 예제입니다. 이 부분을 이용해서 추가 정보를 제공합니다.\n"
 "주로 강의실에서 제기되는 일반적인 질문에 대한 답변과 강사가 다루어야 할 키 포인트일 수 있습니다."
 
-#: src/welcome.md:52 src/cargo/rust-ecosystem.md:67 src/cargo/code-samples.md:35
-#: src/cargo/running-locally.md:74 src/welcome-day-1.md:42 src/welcome-day-1/what-is-rust.md:29
+#: src/welcome.md:52 src/cargo/rust-ecosystem.md:67
+#: src/cargo/code-samples.md:35 src/cargo/running-locally.md:74
+#: src/welcome-day-1.md:42 src/welcome-day-1/what-is-rust.md:29
 #: src/hello-world.md:36 src/hello-world/small-example.md:44 src/why-rust.md:24
-#: src/why-rust/compile-time.md:35 src/why-rust/runtime.md:22 src/why-rust/modern.md:66
-#: src/basic-syntax/compound-types.md:62 src/basic-syntax/references.md:28
-#: src/basic-syntax/slices.md:36 src/basic-syntax/functions.md:54 src/exercises/day-1/morning.md:28
+#: src/why-rust/compile-time.md:35 src/why-rust/runtime.md:22
+#: src/why-rust/modern.md:66 src/basic-syntax/compound-types.md:62
+#: src/basic-syntax/references.md:28 src/basic-syntax/slices.md:36
+#: src/basic-syntax/functions.md:54 src/exercises/day-1/morning.md:28
 #: src/exercises/day-1/for-loops.md:95 src/basic-syntax/variables.md:20
-#: src/basic-syntax/type-inference.md:48 src/basic-syntax/static-and-const.md:52
+#: src/basic-syntax/type-inference.md:48
+#: src/basic-syntax/static-and-const.md:52
 #: src/basic-syntax/scopes-shadowing.md:39 src/memory-management/stack.md:49
 #: src/memory-management/rust.md:18 src/ownership/move-semantics.md:26
 #: src/ownership/moves-function-calls.md:26 src/ownership/borrowing.md:51
-#: src/ownership/shared-unique-borrows.md:29 src/ownership/lifetimes-function-calls.md:60
-#: src/exercises/day-1/afternoon.md:15 src/exercises/day-1/book-library.md:103 src/structs.md:41
-#: src/enums/variant-payloads.md:41 src/enums/sizes.md:136 src/methods/example.md:53
-#: src/pattern-matching/destructuring-enums.md:39 src/exercises/day-2/morning.md:15
-#: src/exercises/day-2/points-polygons.md:125 src/control-flow/if-let-expressions.md:26
-#: src/control-flow/for-expressions.md:29 src/control-flow/loop-expressions.md:27 src/std.md:31
-#: src/std/option-result.md:25 src/std/string.md:33 src/std/vec.md:49 src/std/hashmap.md:66
-#: src/std/rc.md:66 src/modules.md:32 src/modules/visibility.md:48 src/modules/filesystem.md:53
-#: src/exercises/day-2/afternoon.md:11 src/traits.md:54 src/traits/from-iterator.md:26
-#: src/traits/operators.md:38 src/traits/drop.md:42 src/traits/default.md:47
-#: src/generics/methods.md:31 src/generics/closures.md:38 src/exercises/day-3/morning.md:11
-#: src/error-handling/try-operator.md:55 src/error-handling/converting-error-types-example.md:60
-#: src/error-handling/deriving-error-enums.md:45 src/error-handling/dynamic-errors.md:41
-#: src/error-handling/error-contexts.md:42 src/unsafe.md:32 src/unsafe/raw-pointers.md:42
-#: src/unsafe/mutable-static-variables.md:35 src/unsafe/unions.md:28
-#: src/unsafe/writing-unsafe-functions.md:38 src/unsafe/extern-functions.md:28
-#: src/unsafe/unsafe-traits.md:37 src/exercises/day-3/afternoon.md:11 src/concurrency/threads.md:45
+#: src/ownership/shared-unique-borrows.md:29
+#: src/ownership/lifetimes-function-calls.md:60
+#: src/exercises/day-1/afternoon.md:15 src/exercises/day-1/book-library.md:103
+#: src/structs.md:41 src/enums/variant-payloads.md:41 src/enums/sizes.md:136
+#: src/methods/example.md:53 src/pattern-matching/destructuring-enums.md:39
+#: src/exercises/day-2/morning.md:15 src/exercises/day-2/points-polygons.md:125
+#: src/control-flow/if-let-expressions.md:26
+#: src/control-flow/for-expressions.md:29
+#: src/control-flow/loop-expressions.md:27 src/std.md:31
+#: src/std/option-result.md:25 src/std/string.md:33 src/std/vec.md:49
+#: src/std/hashmap.md:66 src/std/rc.md:66 src/modules.md:32
+#: src/modules/visibility.md:48 src/modules/filesystem.md:53
+#: src/exercises/day-2/afternoon.md:11 src/traits.md:54
+#: src/traits/from-iterator.md:26 src/traits/operators.md:38
+#: src/traits/drop.md:42 src/traits/default.md:47 src/generics/methods.md:31
+#: src/generics/closures.md:38 src/exercises/day-3/morning.md:11
+#: src/error-handling/try-operator.md:55
+#: src/error-handling/converting-error-types-example.md:60
+#: src/error-handling/deriving-error-enums.md:45
+#: src/error-handling/dynamic-errors.md:41
+#: src/error-handling/error-contexts.md:42 src/unsafe.md:32
+#: src/unsafe/raw-pointers.md:42 src/unsafe/mutable-static-variables.md:35
+#: src/unsafe/unions.md:28 src/unsafe/writing-unsafe-functions.md:38
+#: src/unsafe/extern-functions.md:28 src/unsafe/unsafe-traits.md:37
+#: src/exercises/day-3/afternoon.md:11 src/concurrency/threads.md:45
 #: src/concurrency/channels.md:32 src/concurrency/shared_state/arc.md:38
-#: src/concurrency/shared_state/example.md:60 src/concurrency/send-sync/sync.md:18
-#: src/exercises/day-4/morning.md:16 src/android/interoperability/with-c/rust.md:86
+#: src/concurrency/shared_state/example.md:60
+#: src/concurrency/send-sync/sync.md:18 src/exercises/day-4/morning.md:16
+#: src/android/interoperability/with-c/rust.md:86
 #: src/exercises/day-4/afternoon.md:15
 msgid "</details>"
 msgstr "</details>"
@@ -994,10 +1012,7 @@ msgid ""
 "   contributing more speaker notes!). You should make sure to open the speaker\n"
 "   notes in a popup (click the link with a little arrow next to \"Speaker\n"
 "   Notes\"). This way you have a clean screen to present to the class."
-msgstr ""
-"1. 강의 자료를 숙지합니다. 주요 요점을 강조하기 위해 일부 페이지에 강의 참조노트를 포함하였습니다. "
-"(추가적인 노트를 작성하여 제공해 주시면 감사하겠습니다.) 강의 참조 노트의 링크를 누르면 강의노트가 "
-"별도의 팝업으로 분리가 되며, 메인 화면에서는 사라집니다."
+msgstr "1. 강의 자료를 숙지합니다. 주요 요점을 강조하기 위해 일부 페이지에 강의 참조노트를 포함하였습니다. (추가적인 노트를 작성하여 제공해 주시면 감사하겠습니다.) 강의 참조 노트의 링크를 누르면 강의노트가 별도의 팝업으로 분리가 되며, 메인 화면에서는 사라집니다."
 
 #: src/running-the-course.md:16
 msgid ""
@@ -1005,9 +1020,7 @@ msgid ""
 "   schedule the four days over two weeks. Course participants have said that\n"
 "   they find it helpful to have a gap in the course since it helps them process\n"
 "   all the information we give them."
-msgstr ""
-"2. 강의 날짜를 정합니다. 강의 내용이 많고 수강생들이 모든 정보를 공부할 수 있도록 중간에 틈을 두어 "
-"2주에 걸쳐 4일을 잡는 것을 추천합니다. "
+msgstr "2. 강의 날짜를 정합니다. 강의 내용이 많고 수강생들이 모든 정보를 공부할 수 있도록 중간에 틈을 두어 2주에 걸쳐 4일을 잡는 것을 추천합니다. "
 
 #: src/running-the-course.md:21
 msgid ""
@@ -1015,16 +1028,13 @@ msgid ""
 "   class size of 15-20 people. That's small enough that people are comfortable\n"
 "   asking questions --- it's also small enough that one instructor will have\n"
 "   time to answer the questions."
-msgstr ""
-"3. 충분한 공간을 확보합니다. 수강생과 강사가 질의를 하기에 충분한 시간과 공간이어야 합니다. 15에서 "
-"20명 규모의 공간을 추천합니다."
+msgstr "3. 충분한 공간을 확보합니다. 수강생과 강사가 질의를 하기에 충분한 시간과 공간이어야 합니다. 15에서 20명 규모의 공간을 추천합니다."
 
 #: src/running-the-course.md:26
 msgid ""
 "4. On the day of your course, show up to the room a little early to set things\n"
 "   up. We recommend presenting directly using `mdbook serve` running on your\n"
-"   laptop (see the [installation instructions][5]). This ensures optimal performance with no lag "
-"as you change pages.\n"
+"   laptop (see the [installation instructions][5]). This ensures optimal performance with no lag as you change pages.\n"
 "   Using your laptop will also allow you to fix typos as you or the course\n"
 "   participants spot them."
 msgstr ""
@@ -1040,12 +1050,9 @@ msgid ""
 "   and offer a solution, e.g., by showing people where to find the relevant\n"
 "   information in the standard library."
 msgstr ""
-"5. 수강생들이 직접 (개별 혹은 그룹으로) 연습문제를 풀도록 합니다. 진행이 막혀 도움을 필요로 하는 수"
-"강생이\n"
-"   없는지 수시로 확인합니다. 만약 같은 문제를 여러 사람이 겪고 있다면, 그 문제를 강의실 전체 인원에"
-"게 알리고\n"
-"   해결책을 제시합니다. 예를 들어 표준 라이브러리 어디에 가면 그 문제에 대한 해답을 찾을 수 있는지 "
-"알려 줍니다."
+"5. 수강생들이 직접 (개별 혹은 그룹으로) 연습문제를 풀도록 합니다. 진행이 막혀 도움을 필요로 하는 수강생이\n"
+"   없는지 수시로 확인합니다. 만약 같은 문제를 여러 사람이 겪고 있다면, 그 문제를 강의실 전체 인원에게 알리고\n"
+"   해결책을 제시합니다. 예를 들어 표준 라이브러리 어디에 가면 그 문제에 대한 해답을 찾을 수 있는지 알려 줍니다."
 
 #: src/running-the-course.md:38
 msgid ""
@@ -1055,11 +1062,9 @@ msgid ""
 "   checkout. This will ensure that the Android build system sees the\n"
 "   `Android.bp` files in `src/android/`."
 msgstr ""
-"6. 4일차에 있을 안드로이드 부분을 건너띄지 않는다면 [AOSP 코드][1]를 체크아웃해야 합니다. 그런 다"
-"음,\n"
+"6. 4일차에 있을 안드로이드 부분을 건너띄지 않는다면 [AOSP 코드][1]를 체크아웃해야 합니다. 그런 다음,\n"
 "   같은 컴퓨터에서 [과정 저장소][2]를 체크아웃하고 `src/android/` 디렉터리를 AOSP 코드의 루트로\n"
-"   이동합니다. 이렇게 하면 안드로이드 빌드 시스템에서 과제용으로 추가된 `Android.bp`파일을 인식할 "
-"수 있습니다."
+"   이동합니다. 이렇게 하면 안드로이드 빌드 시스템에서 과제용으로 추가된 `Android.bp`파일을 인식할 수 있습니다."
 
 #: src/running-the-course.md:44
 msgid ""
@@ -1128,8 +1133,7 @@ msgid ""
 "> which we could attempt to move to Rust? The fewer dependencies the better.\n"
 "> Parsing code would be ideal."
 msgstr ""
-"> **4일차 연습문제:** 러스트 프로젝트에서 C/C++로 작성된 코드를 이전해서 연결하려고 한다면 종속성"
-"이\n"
+"> **4일차 연습문제:** 러스트 프로젝트에서 C/C++로 작성된 코드를 이전해서 연결하려고 한다면 종속성이\n"
 "> 적을 수록 좋습니다. 구문 분석 코드라면 이상적입니다."
 
 #: src/running-the-course/course-structure.md:16
@@ -1224,16 +1228,13 @@ msgstr "# 카고(Cargo) 사용하기"
 
 #: src/cargo.md:3
 msgid ""
-"When you start reading about Rust, you will soon meet [Cargo](https://doc.rust-lang.org/cargo/), "
-"the standard tool\n"
+"When you start reading about Rust, you will soon meet [Cargo](https://doc.rust-lang.org/cargo/), the standard tool\n"
 "used in the Rust ecosystem to build and run Rust applications. Here we want to\n"
 "give a brief overview of what Cargo is and how it fits into the wider ecosystem\n"
 "and how it fits into this training."
 msgstr ""
-"러스트를 시작하려고하면 당신은 곧 [Cargo](https://doc.rust-lang.org/cargo/)라는, 러스트 생태계에서 "
-"사용하는 표준 빌드/실행 도구를 만날 것 입니다. \n"
-"여기서는 카고가 무엇인지, 그리고 카고가 러스트 생태계에서 어떤 역할을 하는지, 그리고 이 강의에서 어"
-"떻게 사용될 지에 대해 간략히 설명하겠습니다."
+"러스트를 시작하려고하면 당신은 곧 [Cargo](https://doc.rust-lang.org/cargo/)라는, 러스트 생태계에서 사용하는 표준 빌드/실행 도구를 만날 것 입니다. \n"
+"여기서는 카고가 무엇인지, 그리고 카고가 러스트 생태계에서 어떤 역할을 하는지, 그리고 이 강의에서 어떻게 사용될 지에 대해 간략히 설명하겠습니다."
 
 #: src/cargo.md:8
 msgid "## Installation"
@@ -1244,17 +1245,11 @@ msgid "### Rustup (Recommended)"
 msgstr "#### Rustup (추천)"
 
 #: src/cargo.md:12
-msgid ""
-"You can follow the instructions to install cargo and rust compiler, among other standard ecosystem "
-"tools with the [rustup][3] tool, which is maintained by the Rust Foundation."
-msgstr ""
-"러스트 재단에서 관리하고 있는 [rustup][3] 도구를 사용하여 카고 및 러스트 컴파일러 등 표준 도구를 설"
-"치 할 수 있습니다."
+msgid "You can follow the instructions to install cargo and rust compiler, among other standard ecosystem tools with the [rustup][3] tool, which is maintained by the Rust Foundation."
+msgstr "러스트 재단에서 관리하고 있는 [rustup][3] 도구를 사용하여 카고 및 러스트 컴파일러 등 표준 도구를 설치 할 수 있습니다."
 
 #: src/cargo.md:14
-msgid ""
-"Along with cargo and rustc, Rustup will install itself as a command line utility that you can use "
-"to install/switch toolchains, setup cross compilation, etc."
+msgid "Along with cargo and rustc, Rustup will install itself as a command line utility that you can use to install/switch toolchains, setup cross compilation, etc."
 msgstr ""
 "카고(cargo)와 러스트 컴파일러(rustc)와 함께, rustup은 툴체인을 설치하고, 다른 \n"
 "툴체인으로 전환하고, 크로스 컴파일 설정을 하는 일을 담당하는 커맨드 라인 유틸리티 \n"
@@ -1292,15 +1287,8 @@ msgstr ""
 "를 지원한다면 어떤 에디터도 무방합니다."
 
 #: src/cargo.md:29
-msgid ""
-"Some folks also like to use the [JetBrains][4] family of IDEs, which do their own analysis but "
-"have their own tradeoffs. If you prefer them, you can install the [Rust Plugin][5]. Please take "
-"note that as of January 2023 debugging only works on the CLion version of the JetBrains IDEA suite."
-msgstr ""
-"어떤 사람들은 [Jetbrains][4] 제품군을 선호하기도 합니다. 이 제품들은 rust-analyzer 를 활용하지 않"
-"고 IDE 자체적으로 구분분석을 합니다. 만약 이 IDE를 설치하셨다면 [Rust Plugin][5]를 설치하시기 바랍"
-"니다. 다만 2023년 1월 기준, 디버깅은 Jetbrains IDEA suite의 CLion 버전에서만 작동한다는 점에 유의하"
-"시기 바랍니다."
+msgid "Some folks also like to use the [JetBrains][4] family of IDEs, which do their own analysis but have their own tradeoffs. If you prefer them, you can install the [Rust Plugin][5]. Please take note that as of January 2023 debugging only works on the CLion version of the JetBrains IDEA suite."
+msgstr "어떤 사람들은 [Jetbrains][4] 제품군을 선호하기도 합니다. 이 제품들은 rust-analyzer 를 활용하지 않고 IDE 자체적으로 구분분석을 합니다. 만약 이 IDE를 설치하셨다면 [Rust Plugin][5]를 설치하시기 바랍니다. 다만 2023년 1월 기준, 디버깅은 Jetbrains IDEA suite의 CLion 버전에서만 작동한다는 점에 유의하시기 바랍니다."
 
 #: src/cargo.md:31
 msgid ""
@@ -1330,8 +1318,7 @@ msgstr "러스트의 생태계는 여러가지 도구들로 구성되어 있으
 msgid ""
 "* `rustc`: the Rust compiler which turns `.rs` files into binaries and other\n"
 "  intermediate formats."
-msgstr ""
-"* `rustc`: `.rs` 확장자 파일을 바이너리 혹은 다른 중간 형식으로 변환해주는 Rust 컴파일러입니다."
+msgstr "* `rustc`: `.rs` 확장자 파일을 바이너리 혹은 다른 중간 형식으로 변환해주는 Rust 컴파일러입니다."
 
 #: src/cargo/rust-ecosystem.md:8
 msgid ""
@@ -1356,12 +1343,13 @@ msgstr ""
 "* `rustup`: 러스트 툴체인 설치 프로그램 및 업데이트 프로그램. \n"
 "  이 도구는 새 버전의 러스트가 출시될 때 `rustc` 및 `cargo` 설치하고 업데이트하는 데 사용됩니다. \n"
 "  또한 `rustup`은 표준 라이브러리에 대한 문서를 다운로드할 수도 있습니다. \n"
-"  한 번에 여러 버전의 러스트를 설치할 수 있으며 `rustup`을 통해 필요에 따라 이들 버전을 전환할 수 "
-"있습니다."
+"  한 번에 여러 버전의 러스트를 설치할 수 있으며 `rustup`을 통해 필요에 따라 이들 버전을 전환할 수 있습니다."
 
-#: src/cargo/rust-ecosystem.md:21 src/hello-world.md:25 src/hello-world/small-example.md:27
-#: src/why-rust/runtime.md:10 src/why-rust/modern.md:21 src/basic-syntax/compound-types.md:30
-#: src/error-handling/try-operator.md:50 src/error-handling/converting-error-types-example.md:50
+#: src/cargo/rust-ecosystem.md:21 src/hello-world.md:25
+#: src/hello-world/small-example.md:27 src/why-rust/runtime.md:10
+#: src/why-rust/modern.md:21 src/basic-syntax/compound-types.md:30
+#: src/error-handling/try-operator.md:50
+#: src/error-handling/converting-error-types-example.md:50
 #: src/concurrency/threads.md:30
 msgid "Key points:"
 msgstr "키 포인트:"
@@ -1416,16 +1404,12 @@ msgstr ""
 "    있습니다."
 
 #: src/cargo/rust-ecosystem.md:44
-msgid ""
-"  * Mention that it is quite rare to ever use the compiler directly not through `cargo` (most "
-"users never do)."
-msgstr ""
-"  * `cargo`를 사용하지 않고 컴파일러를 직접 사용하는 경우는 거의 없음을 언급해 주시기 바랍니다."
+msgid "  * Mention that it is quite rare to ever use the compiler directly not through `cargo` (most users never do)."
+msgstr "  * `cargo`를 사용하지 않고 컴파일러를 직접 사용하는 경우는 거의 없음을 언급해 주시기 바랍니다."
 
 #: src/cargo/rust-ecosystem.md:46
 msgid ""
-"  * It might be worth alluding that Cargo itself is an extremely powerful and comprehensive tool.  "
-"It is capable of many advanced features including but not limited to: \n"
+"  * It might be worth alluding that Cargo itself is an extremely powerful and comprehensive tool.  It is capable of many advanced features including but not limited to: \n"
 "      * Project/package structure\n"
 "      * [workspaces]\n"
 "      * Dev Dependencies and Runtime Dependency management/caching\n"
@@ -1488,8 +1472,7 @@ msgid ""
 "exercises. On the last day, we will do a larger exercise which shows you how to\n"
 "work with dependencies and for that you need Cargo."
 msgstr ""
-"그럼에도 불구하고, 카고(cargo)를 직접 설치하는 것을 강력 권장합니다. 이게 과제 작성에 더 도움이 될"
-"겁니다. \n"
+"그럼에도 불구하고, 카고(cargo)를 직접 설치하는 것을 강력 권장합니다. 이게 과제 작성에 더 도움이 될겁니다. \n"
 "또한, 마지막 날에는 의존성이 있는 예제를 작업하게 될 텐데, 그 때에는 어차피 \n"
 "카고가 필요합니다."
 
@@ -1521,17 +1504,13 @@ msgstr "코드 블록에 포커스를 두고 <kbd>Ctrl-Enter</kbd>를 눌러 실
 msgid ""
 "Most code samples are editable like shown above. A few code samples\n"
 "are not editable for various reasons:"
-msgstr ""
-"강의에서 대부분의 코드 샘플은 위와 같이 수정할수 있지만 일부 코드는 다음과  같은 이유로 수정할 수 "
-"없습니다: "
+msgstr "강의에서 대부분의 코드 샘플은 위와 같이 수정할수 있지만 일부 코드는 다음과  같은 이유로 수정할 수 없습니다: "
 
 #: src/cargo/code-samples.md:27
 msgid ""
 "* The embedded playgrounds cannot execute unit tests. Copy-paste the\n"
 "  code and open it in the real Playground to demonstrate unit tests."
-msgstr ""
-"* 유닛 테스트는 내장 플레이그라운드에서 실행이 안됩니다. 외부 플레이그라운드 사이트에 붙여넣어 테스"
-"트를 실행하시기 바랍니다."
+msgstr "* 유닛 테스트는 내장 플레이그라운드에서 실행이 안됩니다. 외부 플레이그라운드 사이트에 붙여넣어 테스트를 실행하시기 바랍니다."
 
 #: src/cargo/code-samples.md:30
 msgid ""
@@ -1539,9 +1518,7 @@ msgid ""
 "  away from the page! This is the reason that the students should\n"
 "  solve the exercises using a local Rust installation or via the\n"
 "  Playground."
-msgstr ""
-"* 내장된 플레이그라운드에서는 페이지 이동시 작성된 모든 내용이 사라집니다.  따라서 로컬 환경이나 외"
-"부 플레이그라운드 사이트에서 연습문제를 해결하는 것이 좋습니다."
+msgstr "* 내장된 플레이그라운드에서는 페이지 이동시 작성된 모든 내용이 사라집니다.  따라서 로컬 환경이나 외부 플레이그라운드 사이트에서 연습문제를 해결하는 것이 좋습니다."
 
 #: src/cargo/running-locally.md:1
 msgid "# Running Code Locally with Cargo"
@@ -1572,8 +1549,7 @@ msgstr ""
 msgid ""
 "With this is in place, then follow these steps to build a Rust binary from one\n"
 "of the examples in this training:"
-msgstr ""
-"정상적으로 설치가 되었으면 강의의 코드 블록중 하나를 아래 단계를 따라 로컬에서 실행할 수 있습니다."
+msgstr "정상적으로 설치가 되었으면 강의의 코드 블록중 하나를 아래 단계를 따라 로컬에서 실행할 수 있습니다."
 
 #: src/cargo/running-locally.md:18
 msgid "1. Click the \"Copy to clipboard\" button on the example you want to copy."
@@ -1611,9 +1587,7 @@ msgstr ""
 msgid ""
 "4. Replace the boiler-plate code in `src/main.rs` with your own code. For\n"
 "   example, using the example on the previous page, make `src/main.rs` look like"
-msgstr ""
-"4. `src/main.rs`에 코드를 작성합니다. 예를 들어 이전 페이지의 소스를 아래와 같이 `src/main.rs`에 작"
-"성합니다."
+msgstr "4. `src/main.rs`에 코드를 작성합니다. 예를 들어 이전 페이지의 소스를 아래와 같이 `src/main.rs`에 작성합니다."
 
 #: src/cargo/running-locally.md:41
 msgid ""
@@ -1647,10 +1621,8 @@ msgid ""
 "   release build in `target/release/`."
 msgstr ""
 "6. `cargo check`커맨드는 빠르게 에러를 확인할 수 있습니다.\n"
-"    * `cargo build`는 실행없이 컴파일만 합니다. 이 경우에 `target/debug/`폴더에서 output을 확인 할 "
-"수 있습니다. \n"
-"    * `cargo build --release`커맨드는 릴리즈 버전용 최적화를 켜서 컴파일하며 `target/release/`폴더"
-"에서 확인 할 수 있습니다."
+"    * `cargo build`는 실행없이 컴파일만 합니다. 이 경우에 `target/debug/`폴더에서 output을 확인 할 수 있습니다. \n"
+"    * `cargo build --release`커맨드는 릴리즈 버전용 최적화를 켜서 컴파일하며 `target/release/`폴더에서 확인 할 수 있습니다."
 
 #: src/cargo/running-locally.md:62
 msgid ""
@@ -1720,14 +1692,11 @@ msgid ""
 msgstr ""
 "* 궁금한 점이 있으면 주저하지 말고 질문 해야 합니다.\n"
 "* 이 수업은 상호작용이 중요하고 토론을 권장합니다.\n"
-"  * 강사로서 토론이 옆길로 새지 않게 주의하세요. 예를 들어 러스트와 다른 언어들을 비교한다든지 하"
-"는 것은\n"
-"    좋습니다. 적절한 균형을 찾기 애매한 경우라면 토론을 허용하는 쪽이 일방적인 강의보다는 더 많은 "
-"사람들의\n"
+"  * 강사로서 토론이 옆길로 새지 않게 주의하세요. 예를 들어 러스트와 다른 언어들을 비교한다든지 하는 것은\n"
+"    좋습니다. 적절한 균형을 찾기 애매한 경우라면 토론을 허용하는 쪽이 일방적인 강의보다는 더 많은 사람들의\n"
 "    참여를 이끌어 낼 수 있습니다.\n"
 "* 질문이 슬라이드보다 앞서가도 괜찮습니다.\n"
-"  * 학습에 있어서 반복은 매우 중요합니다. 슬라이드는 그저 도움을 줄 뿐, 원하는 대로 건너띄어도 됩니"
-"다."
+"  * 학습에 있어서 반복은 매우 중요합니다. 슬라이드는 그저 도움을 줄 뿐, 원하는 대로 건너띄어도 됩니다."
 
 #: src/welcome-day-1.md:29
 msgid ""
@@ -1735,10 +1704,8 @@ msgid ""
 "about the famous borrow checker. The way Rust handles memory is a major feature\n"
 "and we should show students this right away."
 msgstr ""
-"첫 날 강의의 목표는, 러스트에서 그 유명한 빌림 확인에 대해서 이야기 할 수 있을 정도 까지만 러스트"
-"를 소개하는 것입니다.\n"
-"러스트의 가장 독특한 특징이 메모리를 다루는 방식이기 때문에, 학생들에게 이 부분 을 우선적으로 보여"
-"주려 합니다."
+"첫 날 강의의 목표는, 러스트에서 그 유명한 빌림 확인에 대해서 이야기 할 수 있을 정도 까지만 러스트를 소개하는 것입니다.\n"
+"러스트의 가장 독특한 특징이 메모리를 다루는 방식이기 때문에, 학생들에게 이 부분 을 우선적으로 보여주려 합니다."
 
 #: src/welcome-day-1.md:33
 msgid ""
@@ -1746,8 +1713,7 @@ msgid ""
 "schedule. We suggest splitting the day into two parts (following the slides):"
 msgstr ""
 "만약 당신이 강의실에서 가르치고 있다면, 이 슬라이드는 일정을 검토하기에 적합한 곳입니다. \n"
-"하루치 강의를 아래처럼 오전 오후로 나누어 진행하는 것을 추천합니다. (슬라이드가 그런식으로나뉘어 있"
-"습니다.)"
+"하루치 강의를 아래처럼 오전 오후로 나누어 진행하는 것을 추천합니다. (슬라이드가 그런식으로나뉘어 있습니다.)"
 
 #: src/welcome-day-1.md:36
 msgid ""
@@ -1863,9 +1829,7 @@ msgstr ""
 msgid ""
 "This slide tries to make the students comfortable with Rust code. They will see\n"
 "a ton of it over the next four days so we start small with something familiar."
-msgstr ""
-"이 슬라이드는 학생들이 러스트 코드에 익숙해지기 위해 작성되었습니다. 앞으로 4일 동안 많은 코드를 접"
-"할 것이기 때문에 우선 친숙한 코드부터 시작합니다."
+msgstr "이 슬라이드는 학생들이 러스트 코드에 익숙해지기 위해 작성되었습니다. 앞으로 4일 동안 많은 코드를 접할 것이기 때문에 우선 친숙한 코드부터 시작합니다."
 
 #: src/hello-world.md:27
 msgid ""
@@ -1885,9 +1849,7 @@ msgstr "* 러스트는 유니코드 지원과 같은 현대 언어의 특징을
 msgid ""
 "* Rust uses macros for situations where you want to have a variable number of\n"
 "  arguments (no function [overloading](basic-syntax/functions-interlude.md))."
-msgstr ""
-"* 러스트는 인자의 개수를 사전에 지정할 수 없는 상황에서 함수 [오버로딩](basic-syntax/functions-"
-"interlude.md)대신 매크로를 사용합니다."
+msgstr "* 러스트는 인자의 개수를 사전에 지정할 수 없는 상황에서 함수 [오버로딩](basic-syntax/functions-interlude.md)대신 매크로를 사용합니다."
 
 #: src/hello-world/small-example.md:1
 msgid "# Small Example"
@@ -1936,17 +1898,13 @@ msgid ""
 "The code implements the Collatz conjecture: it is believed that the loop will\n"
 "always end, but this is not yet proved. Edit the code and play with different\n"
 "inputs."
-msgstr ""
-"이 코드는 콜라츠 추측(Collatz conjecture)으로 구현됩니다:반복문이 언제나 종료될 것이라고 믿지만 증"
-"명된 것은 아닙니다. 코드를 수정하고 실행해 보시기 바랍니다."
+msgstr "이 코드는 콜라츠 추측(Collatz conjecture)으로 구현됩니다:반복문이 언제나 종료될 것이라고 믿지만 증명된 것은 아닙니다. 코드를 수정하고 실행해 보시기 바랍니다."
 
 #: src/hello-world/small-example.md:29
 msgid ""
 "* Explain that all variables are statically typed. Try removing `i32` to trigger\n"
 "  type inference. Try with `i8` instead and trigger a runtime integer overflow."
-msgstr ""
-"* 모든 변수가 컴파일 시 정해진 타입을 가짐을 설명합니다. i32를 삭제하여  컴파일러가 타입 추론을 하"
-"도록 해 봅니다.  i32을 i8로 변경하여 런타임 오버플로를 유발해 볼 수 있습니다."
+msgstr "* 모든 변수가 컴파일 시 정해진 타입을 가짐을 설명합니다. i32를 삭제하여  컴파일러가 타입 추론을 하도록 해 봅니다.  i32을 i8로 변경하여 런타임 오버플로를 유발해 볼 수 있습니다."
 
 #: src/hello-world/small-example.md:32
 msgid "* Change `let mut x` to `let x`, discuss the compiler error."
@@ -1956,9 +1914,7 @@ msgstr "* `let mut x`를 `let x`로 수정하여 컴파일 오류에 대해 토
 msgid ""
 "* Show how `print!` gives a compilation error if the arguments don't match the\n"
 "  format string."
-msgstr ""
-"* 인자가 포맷 문자열과 일치하지 않는 경우 `print!`에서 컴파일 오류가 발생함을 언급하는 것도 좋습니"
-"다."
+msgstr "* 인자가 포맷 문자열과 일치하지 않는 경우 `print!`에서 컴파일 오류가 발생함을 언급하는 것도 좋습니다."
 
 #: src/hello-world/small-example.md:37
 msgid ""
@@ -1971,10 +1927,7 @@ msgid ""
 "* Show the students the standard library, show them how to search for `std::fmt`\n"
 "  which has the rules of the formatting mini-language. It's important that the\n"
 "  students become familiar with searching in the standard library."
-msgstr ""
-"학생들에게 표준 라이브러리가 어디 있는지 알려 주고는, `print!`가 지원하는 포맷팅 언어의 문법을 알"
-"기 위해 `std::fmt`를 검색해야 한다는 것을 가르치세요.학생들이 표준 라이브러리의 검색 기능에 익숙해 "
-"지도록 하는 것이 중요합니다."
+msgstr "학생들에게 표준 라이브러리가 어디 있는지 알려 주고는, `print!`가 지원하는 포맷팅 언어의 문법을 알기 위해 `std::fmt`를 검색해야 한다는 것을 가르치세요.학생들이 표준 라이브러리의 검색 기능에 익숙해 지도록 하는 것이 중요합니다."
 
 #: src/why-rust.md:1
 msgid "# Why Rust?"
@@ -1998,9 +1951,7 @@ msgstr ""
 msgid ""
 "Make sure to ask the class which languages they have experience with. Depending\n"
 "on the answer you can highlight different features of Rust:"
-msgstr ""
-"수강생들에게 어떤 프로그래밍 언어를 사용했는지 물어보시기 바랍니다. 어떤 언어를 사용했느냐에 따라 "
-"러스트에서 어떤 점을 강조해야 할지를 고민해 보세요."
+msgstr "수강생들에게 어떤 프로그래밍 언어를 사용했는지 물어보시기 바랍니다. 어떤 언어를 사용했느냐에 따라 러스트에서 어떤 점을 강조해야 할지를 고민해 보세요."
 
 #: src/why-rust.md:14
 msgid ""
@@ -2008,11 +1959,7 @@ msgid ""
 "  via the borrow checker. You get performance like in C and C++, but you don't\n"
 "  have the memory unsafety issues. In addition, you get a modern language with\n"
 "  constructs like pattern matching and built-in dependency management."
-msgstr ""
-"* C/C++: 러스트는 '빌림'검사기를 통해서 수행중에 발생할 수 있는 모든 에러를  제거합니다. 러스트는 C"
-"와 C++과 비슷한 수준의 성능을 보여주면서도, 그 언어들에서 종종 발생하는 메모리 관련 오류가 없습니"
-"다. 또한, 패턴 매칭이나, 기본적으로 제공되는 종속성 관리와 같은 현대적인 언어의 기능들을 제공합니"
-"다."
+msgstr "* C/C++: 러스트는 '빌림'검사기를 통해서 수행중에 발생할 수 있는 모든 에러를  제거합니다. 러스트는 C와 C++과 비슷한 수준의 성능을 보여주면서도, 그 언어들에서 종종 발생하는 메모리 관련 오류가 없습니다. 또한, 패턴 매칭이나, 기본적으로 제공되는 종속성 관리와 같은 현대적인 언어의 기능들을 제공합니다."
 
 #: src/why-rust.md:19
 msgid ""
@@ -2020,10 +1967,7 @@ msgid ""
 "  as in those languages, plus a similar high-level language feeling. In addition\n"
 "  you get fast and predictable performance like C and C++ (no garbage collector)\n"
 "  as well as access to low-level hardware (should you need it)"
-msgstr ""
-"* Java, Go, Python, JaveScript: 이 언어들과 동일한 메모리 안정성과 함께, '하이레벨'언어의 느낌을 느"
-"낄 수 있습니다. 거기에 더해, 가비지 컬렉터가 없는 C/C++와 유사한 수준의 빠르고 예측 가능한 성능을 "
-"기대할 수 있습니다. 그리고 필요한 경우 저수준 하드웨어를 다루는 코드로 작성할 수 있습니다."
+msgstr "* Java, Go, Python, JaveScript: 이 언어들과 동일한 메모리 안정성과 함께, '하이레벨'언어의 느낌을 느낄 수 있습니다. 거기에 더해, 가비지 컬렉터가 없는 C/C++와 유사한 수준의 빠르고 예측 가능한 성능을 기대할 수 있습니다. 그리고 필요한 경우 저수준 하드웨어를 다루는 코드로 작성할 수 있습니다."
 
 #: src/why-rust/compile-time.md:1
 msgid "# Compile Time Guarantees"
@@ -2070,10 +2014,8 @@ msgid ""
 "* In fact, some will consider infinitely populating a collection a memory\n"
 "  leak and Rust does not protect from those."
 msgstr ""
-"* [`Box::leak`]을 이용하여 포인터를 의도적으로 누출시킬 수 있습니다. 이를 이용해서   런타임이 생성"
-"하고 런타임이 크기를 정한 정적 변수를 가져올 수 있습니다.\n"
-"* [`std::mem::forget`]을 사용하여 컴파일러가 값에 대해 \"잊도록\" 만들 수 있습니다(소멸자가 실행되"
-"지 않음을 의미합니다).\n"
+"* [`Box::leak`]을 이용하여 포인터를 의도적으로 누출시킬 수 있습니다. 이를 이용해서   런타임이 생성하고 런타임이 크기를 정한 정적 변수를 가져올 수 있습니다.\n"
+"* [`std::mem::forget`]을 사용하여 컴파일러가 값에 대해 \"잊도록\" 만들 수 있습니다(소멸자가 실행되지 않음을 의미합니다).\n"
 "* `Rc` 또는 `Arc`를 사용하여 실수로 [순환참조][reference cycle]을 생성할 수도 있습니다.\n"
 "* 컬렉션을 무한정 채우는 것을 메모리 누출로 간주할 수도 있지만, 러스트는 이를 보호하진 못합니다."
 
@@ -2112,10 +2054,7 @@ msgid ""
 "  either a panic (a controlled crash of the program) or wrap-around\n"
 "  semantics. By default, you get panics in debug mode (`cargo build`)\n"
 "  and wrap-around in release mode (`cargo build --release`)."
-msgstr ""
-"* 정수형 오버플로우는 컴파일 타임 플레그를 통해 정의됩니다. 옵션은 패닉(프로그램 크레시) 혹은 올림"
-"(wrap-around)입니다. 기본적으로 디버그 모드(`cargo build`)에서는 패닉이, 릴리즈 모드(`cargo build "
-"--release`)에서는 wrap-around가 발생합니다."
+msgstr "* 정수형 오버플로우는 컴파일 타임 플레그를 통해 정의됩니다. 옵션은 패닉(프로그램 크레시) 혹은 올림(wrap-around)입니다. 기본적으로 디버그 모드(`cargo build`)에서는 패닉이, 릴리즈 모드(`cargo build --release`)에서는 wrap-around가 발생합니다."
 
 #: src/why-rust/runtime.md:17
 msgid ""
@@ -2123,10 +2062,7 @@ msgid ""
 "  not be disabled directly with the `unsafe` keyword. However,\n"
 "  `unsafe` allows you to call functions such as `slice::get_unchecked`\n"
 "  which does not do bounds checking."
-msgstr ""
-"* 컴파일 플래그를 사용하여 경계체크를 무력화 할 수 없습니다. `unsafe`를 사용하더라도 마찬가지입니"
-"다. 하지만 `unsafe`에서 호출 가능한 `slice::get_unchecked`같은 함수는 경계 검사를 수행하지 않습니"
-"다."
+msgstr "* 컴파일 플래그를 사용하여 경계체크를 무력화 할 수 없습니다. `unsafe`를 사용하더라도 마찬가지입니다. 하지만 `unsafe`에서 호출 가능한 `slice::get_unchecked`같은 함수는 경계 검사를 수행하지 않습니다."
 
 #: src/why-rust/modern.md:1
 msgid "# Modern Features"
@@ -2176,19 +2112,15 @@ msgid ""
 "  writing a loop using `for` should result in roughly the same low level\n"
 "  instructions as using the `.iter().fold()` construct."
 msgstr ""
-"* C++ 와 유사하게 제로 코스트 추상화는 CPU나 메모리를 사용하여 상위레벨 프로그래밍 구조를 만드는데 "
-"'비용'을 지불할 필요가 없습니다. \n"
-"예를 들어 `for` 루프와와 `iter().fold()` 구조를 사용하는 것과 거의 동일한 낮은 수준의 명령어가 생성"
-"될 것 입니다."
+"* C++ 와 유사하게 제로 코스트 추상화는 CPU나 메모리를 사용하여 상위레벨 프로그래밍 구조를 만드는데 '비용'을 지불할 필요가 없습니다. \n"
+"예를 들어 `for` 루프와와 `iter().fold()` 구조를 사용하는 것과 거의 동일한 낮은 수준의 명령어가 생성될 것 입니다."
 
 #: src/why-rust/modern.md:28
 msgid ""
 "* It may be worth mentioning that Rust enums are 'Algebraic Data Types', also\n"
 "  known as 'sum types', which allow the type system to express things like\n"
 "  `Option<T>` and `Result<T, E>`."
-msgstr ""
-"* 러스트의 열거형(enum)은 합계 타입(`sum types`)으로 알려진 대수학적 데이터형('Algebraic Data "
-"Types')으로, 타입 시스템이 `Option<T>`와 `Result<T, E>`등을 표현할 수 있게 해줍니다."
+msgstr "* 러스트의 열거형(enum)은 합계 타입(`sum types`)으로 알려진 대수학적 데이터형('Algebraic Data Types')으로, 타입 시스템이 `Option<T>`와 `Result<T, E>`등을 표현할 수 있게 해줍니다."
 
 #: src/why-rust/modern.md:32
 msgid ""
@@ -2197,10 +2129,8 @@ msgid ""
 "  talkative than other compilers. It will often provide you with _actionable_\n"
 "  feedback, ready to copy-paste into your code."
 msgstr ""
-"* 오류를 읽어보시기 바랍니다 --- 오랜기간 많은 개발자들이 컴파일러 출력을 무시하는데 익숙해져 있습"
-"니다.\n"
-"  러스트 컴파일러는 다른 컴파일러보다 더 수다스럽고, 복사-붙여넣기 할 수 있는 정도의 코드 피드백을 "
-"제공하는\n"
+"* 오류를 읽어보시기 바랍니다 --- 오랜기간 많은 개발자들이 컴파일러 출력을 무시하는데 익숙해져 있습니다.\n"
+"  러스트 컴파일러는 다른 컴파일러보다 더 수다스럽고, 복사-붙여넣기 할 수 있는 정도의 코드 피드백을 제공하는\n"
 "  경우가 많습니다. "
 
 #: src/why-rust/modern.md:37
@@ -2208,9 +2138,7 @@ msgid ""
 "* The Rust standard library is small compared to languages like Java, Python,\n"
 "  and Go. Rust does not come with several things you might consider standard and\n"
 "  essential:"
-msgstr ""
-"* 러스트 표준 라이브러리는 Java, Python이나 Go와 같은 언어에 비해서 규모가 작습니다. 당연히 포함되"
-"어야 한다고 생각할 수도 있는 아래와 같은 것들이 러스트의 표준 라이브러리에 없습니다."
+msgstr "* 러스트 표준 라이브러리는 Java, Python이나 Go와 같은 언어에 비해서 규모가 작습니다. 당연히 포함되어야 한다고 생각할 수도 있는 아래와 같은 것들이 러스트의 표준 라이브러리에 없습니다."
 
 #: src/why-rust/modern.md:41
 msgid ""
@@ -2229,10 +2157,8 @@ msgid ""
 "  community is still working on finding the best solution --- and perhaps there\n"
 "  isn't a single \"best solution\" for some of these things."
 msgstr ""
-"  그 이유는 표준 라이브러리에서 한 번 어떤 기능을 제공하면 뺄 수 없으며, 매우 안정적이어야 하기 때"
-"문입니다.\n"
-"  위에 언급한 기능들은 아직 러스트 커뮤니티가 최고의 솔루션을 찾지 못했기 때문에 표준 라이브러리에 "
-"포함되지\n"
+"  그 이유는 표준 라이브러리에서 한 번 어떤 기능을 제공하면 뺄 수 없으며, 매우 안정적이어야 하기 때문입니다.\n"
+"  위에 언급한 기능들은 아직 러스트 커뮤니티가 최고의 솔루션을 찾지 못했기 때문에 표준 라이브러리에 포함되지\n"
 "  않았습니다. 어쩌면 이들 중 몇 개는 '최고의 솔루션'이 아예 존재할 수 없을 지도 모릅니다."
 
 #: src/why-rust/modern.md:50
@@ -2241,8 +2167,7 @@ msgid ""
 "  it trivial to download and compile third-party crates. A consequence of this\n"
 "  is that the standard library can be smaller."
 msgstr ""
-"  러스트는 카고라는 패키지 관리자가 내장되어 있고, 서드파티 크레이트를 다운로드, 컴파일 하기 매우 "
-"쉽습니다.\n"
+"  러스트는 카고라는 패키지 관리자가 내장되어 있고, 서드파티 크레이트를 다운로드, 컴파일 하기 매우 쉽습니다.\n"
 "  이 또한 표준 라이브러리가 작은 이유입니다."
 
 #: src/why-rust/modern.md:54
@@ -2298,23 +2223,15 @@ msgstr "# 스칼라 타입"
 
 #: src/basic-syntax/scalar-types.md:3
 msgid ""
-"|                        | Types                                      | "
-"Literals                      |\n"
+"|                        | Types                                      | Literals                      |\n"
 "|------------------------|--------------------------------------------|-------------------------------|\n"
-"| Signed integers        | `i8`, `i16`, `i32`, `i64`, `i128`, `isize` | `-10`, `0`, `1_000`, "
-"`123i64` |\n"
-"| Unsigned integers      | `u8`, `u16`, `u32`, `u64`, `u128`, `usize` | `0`, `123`, "
-"`10u16`           |\n"
-"| Floating point numbers | `f32`, `f64`                               | `3.14`, `-10.0e20`, "
-"`2f32`    |\n"
-"| Strings                | `&str`                                     | `\"foo\"`, `r#\"\\\\"
-"\"#`            |\n"
-"| Unicode scalar values  | `char`                                     | `'a'`, `'α'`, "
-"`'∞'`           |\n"
-"| Byte strings           | `&[u8]`                                    | `b\"abc\"`, `br#\" \" "
-"\"#`         |\n"
-"| Booleans               | `bool`                                     | `true`, "
-"`false`               |"
+"| Signed integers        | `i8`, `i16`, `i32`, `i64`, `i128`, `isize` | `-10`, `0`, `1_000`, `123i64` |\n"
+"| Unsigned integers      | `u8`, `u16`, `u32`, `u64`, `u128`, `usize` | `0`, `123`, `10u16`           |\n"
+"| Floating point numbers | `f32`, `f64`                               | `3.14`, `-10.0e20`, `2f32`    |\n"
+"| Strings                | `&str`                                     | `\"foo\"`, `r#\"\\\\\"#`            |\n"
+"| Unicode scalar values  | `char`                                     | `'a'`, `'α'`, `'∞'`           |\n"
+"| Byte strings           | `&[u8]`                                    | `b\"abc\"`, `br#\" \" \"#`         |\n"
+"| Booleans               | `bool`                                     | `true`, `false`               |"
 msgstr ""
 "|                 | 타입                                       | 스칼라 리터럴 값              |\n"
 "|-----------------|--------------------------------------------|-------------------------------|\n"
@@ -2362,10 +2279,8 @@ msgstr ""
 #: src/basic-syntax/compound-types.md:8
 msgid "Array assignment and access:"
 msgstr ""
-"* _역주: js기준으로 설명하면 튜플은 ‘순서가 중요해서 사이즈 N으로 고정된  불변(immutable) 배열’ 이"
-"라고 보면 됨._\n"
-" _정확히는 서수(순서가 의미가 있는 내용)의 묶음(모음).  갯수N개에 대해서 N-tuple이라고 부르며 2-"
-"tuple을 흔히 쓰긴 함.(cf. 열거형)_\n"
+"* _역주: js기준으로 설명하면 튜플은 ‘순서가 중요해서 사이즈 N으로 고정된  불변(immutable) 배열’ 이라고 보면 됨._\n"
+" _정확히는 서수(순서가 의미가 있는 내용)의 묶음(모음).  갯수N개에 대해서 N-tuple이라고 부르며 2-tuple을 흔히 쓰긴 함.(cf. 열거형)_\n"
 "\n"
 "배열 선언과 접근:"
 
@@ -2404,9 +2319,7 @@ msgid ""
 "* Arrays have elements of the same type, `T`, and length, `N`, which is a compile-time constant.\n"
 "  Note that the length of the array is *part of its type*, which means that `[u8; 3]` and\n"
 "  `[u8; 4]` are considered two different types."
-msgstr ""
-"* 배열은, 같은 타입 `T`의 값이 `N`개 있는 것입니다. 여기서 `N`은 컴파일 타임에 결정된 값이어야 합니"
-"다. 이 길이도 타입의 일부입니다. 따라서, `[u8; 3]`와 `[u8; 4]`은 서로 다른 타입입니다."
+msgstr "* 배열은, 같은 타입 `T`의 값이 `N`개 있는 것입니다. 여기서 `N`은 컴파일 타임에 결정된 값이어야 합니다. 이 길이도 타입의 일부입니다. 따라서, `[u8; 3]`와 `[u8; 4]`은 서로 다른 타입입니다."
 
 #: src/basic-syntax/compound-types.md:38
 msgid "* We can use literals to assign values to arrays."
@@ -2418,10 +2331,7 @@ msgid ""
 "  parameter: `{}` gives the default output, `{:?}` gives the debug output. We\n"
 "  could also have used `{a}` and `{a:?}` without specifying the value after the\n"
 "  format string."
-msgstr ""
-"* 포매팅 문자열에서 `?`는 디버깅 출력을 의미합니다. `{}`는 기본 출력이며, `{:?}`는 디버깅 출력입니"
-"다. `{a}`와 `{a:?}`와 같이 출력할 변수 이름을 포매팅 문자열에 포함시킬 수도 있으며, 이 경우 인자 "
-"`a`는 별도의 인자로 추가하지 않습니다."
+msgstr "* 포매팅 문자열에서 `?`는 디버깅 출력을 의미합니다. `{}`는 기본 출력이며, `{:?}`는 디버깅 출력입니다. `{a}`와 `{a:?}`와 같이 출력할 변수 이름을 포매팅 문자열에 포함시킬 수도 있으며, 이 경우 인자 `a`는 별도의 인자로 추가하지 않습니다."
 
 #: src/basic-syntax/compound-types.md:45
 msgid "* Adding `#`, eg `{a:#?}`, invokes a \"pretty printing\" format, which can be easier to read."
@@ -2440,8 +2350,7 @@ msgid "* Tuples group together values of different types into a compound type."
 msgstr "* 튜플은 서로 다른 타입의 값들을 하나의 복합 타입으로 묶습니다."
 
 #: src/basic-syntax/compound-types.md:53
-msgid ""
-"* Fields of a tuple can be accessed by the period and the index of the value, e.g. `t.0`, `t.1`."
+msgid "* Fields of a tuple can be accessed by the period and the index of the value, e.g. `t.0`, `t.1`."
 msgstr "* 튜플에 속한 값은 `t.0`, `t.1`과 같이 인덱스로 접근할 수 있습니다."
 
 #: src/basic-syntax/compound-types.md:55
@@ -2452,10 +2361,7 @@ msgid ""
 "  expression has no return value, as we'll see in a future slide. \n"
 "    * You can think of it as `void` that can be familiar to you from other \n"
 "      programming languages."
-msgstr ""
-"* 비어있는 튜플`()`은 단위 타입(unit type)이라고도 합니다. 이는 타입이면서 해당 타입의 유일하며 유"
-"효한 값입니다. 즉 타입과 값이 모두 `()`입니다. 예를 들어 함수나 식에서 반환 값이 없음을 나타낼 때 "
-"사용합니다.  * 다른 언어에서 익숙한 `void` 개념으로 생각할 수 있습니다."
+msgstr "* 비어있는 튜플`()`은 단위 타입(unit type)이라고도 합니다. 이는 타입이면서 해당 타입의 유일하며 유효한 값입니다. 즉 타입과 값이 모두 `()`입니다. 예를 들어 함수나 식에서 반환 값이 없음을 나타낼 때 사용합니다.  * 다른 언어에서 익숙한 `void` 개념으로 생각할 수 있습니다."
 
 #: src/basic-syntax/references.md:1
 msgid "# References"
@@ -2488,10 +2394,8 @@ msgid ""
 "  methods (try `ref_x.count_ones()`).\n"
 "* References that are declared as `mut` can be bound to different values over their lifetime."
 msgstr ""
-"* `ref_x`에 값을 할당할 때, C/C++의 포인터와 유사하게 `*`를 이용해서 참조를 따라가야(역참조) 합니"
-"다.\n"
-"* 러스트는 특정한 경우(메서드 호출)에 자동으로 역참조를 합니다.(`ref_x.count_one()`을 하면 `*ref_x`"
-"가 `count_one`의 인자로 전달됩니다.)\n"
+"* `ref_x`에 값을 할당할 때, C/C++의 포인터와 유사하게 `*`를 이용해서 참조를 따라가야(역참조) 합니다.\n"
+"* 러스트는 특정한 경우(메서드 호출)에 자동으로 역참조를 합니다.(`ref_x.count_one()`을 하면 `*ref_x`가 `count_one`의 인자로 전달됩니다.)\n"
 "* `mut`로 선언된 참조는 그 변수가 살아있는 동안 다른 값을 가질 수 있습니다."
 
 #: src/basic-syntax/references.md:21
@@ -2580,19 +2484,16 @@ msgstr ""
 "* 질문: `a[3]`을 수정하면 무슨 일이 있어날까요?"
 
 #: src/basic-syntax/slices.md:20
-msgid ""
-"* We create a slice by borrowing `a` and specifying the starting and ending indexes in brackets."
+msgid "* We create a slice by borrowing `a` and specifying the starting and ending indexes in brackets."
 msgstr "* 슬라이스는 우선 `a`를 빌린다음, 시작과 끝 인덱스를 브래킷(`[]`)안에 지정해서 만듭니다."
 
 #: src/basic-syntax/slices.md:22
 msgid ""
-"* If the slice starts at index 0, Rust’s range syntax allows us to drop the starting index, "
-"meaning that `&a[0..a.len()]` and `&a[..a.len()]` are identical.\n"
+"* If the slice starts at index 0, Rust’s range syntax allows us to drop the starting index, meaning that `&a[0..a.len()]` and `&a[..a.len()]` are identical.\n"
 "    \n"
 "* The same is true for the last index, so `&a[2..a.len()]` and `&a[2..]` are identical."
 msgstr ""
-"* 슬라이스가 인덱스 0부터 시작한다면 시작 인덱스는 생략 가능합니다. 즉 `&a[0..a.len()]`와 `&a[..a."
-"len()]` 는 동일합니다.\n"
+"* 슬라이스가 인덱스 0부터 시작한다면 시작 인덱스는 생략 가능합니다. 즉 `&a[0..a.len()]`와 `&a[..a.len()]` 는 동일합니다.\n"
 "* 마지막 인덱스도 생략 가능합니다. 그래서 `&a[2..a.len()]` 와 `&a[2..]`는 동일합니다."
 
 #: src/basic-syntax/slices.md:26
@@ -2601,27 +2502,19 @@ msgstr "* 따라서 전체 배열에 대한 슬라이스는 `&a[..]`가 됩니
 
 #: src/basic-syntax/slices.md:28
 msgid ""
-"* `s` is a reference to a slice of `i32`s. Notice that the type of `s` (`&[i32]`) no longer "
-"mentions the array length. This allows us to perform computation on slices of different sizes.\n"
+"* `s` is a reference to a slice of `i32`s. Notice that the type of `s` (`&[i32]`) no longer mentions the array length. This allows us to perform computation on slices of different sizes.\n"
 " \n"
-"* Slices always borrow from another object. In this example, `a` has to remain 'alive' (in scope) "
-"for at least as long as our slice. \n"
+"* Slices always borrow from another object. In this example, `a` has to remain 'alive' (in scope) for at least as long as our slice. \n"
 "    \n"
-"* The question about modifying `a[3]` can spark an interesting discussion, but the answer is that "
-"for memory safety reasons\n"
-"  you cannot do it through `a` after you created a slice, but you can read the data from both `a` "
-"and `s` safely. \n"
+"* The question about modifying `a[3]` can spark an interesting discussion, but the answer is that for memory safety reasons\n"
+"  you cannot do it through `a` after you created a slice, but you can read the data from both `a` and `s` safely. \n"
 "  More details will be explained in the borrow checker section."
 msgstr ""
-"* `s`는 `i32`들로 이루어진 슬라이스에 대한 참조입니다. `s`의 타입(`&[i32]`)에 배열의 크기가 빠져있"
-"음에 주목하시기 바랍니다. 즉, 슬라이스를 이용하면 다양한 길이의 데이터를  다룰 수 있습니다.\n"
+"* `s`는 `i32`들로 이루어진 슬라이스에 대한 참조입니다. `s`의 타입(`&[i32]`)에 배열의 크기가 빠져있음에 주목하시기 바랍니다. 즉, 슬라이스를 이용하면 다양한 길이의 데이터를  다룰 수 있습니다.\n"
 " \n"
-"* 슬라이스는 항상 다른 객체로부터 '빌려' 옵니다. 이 예시에서 객체 `a`는 슬라이스  `s`보다 더 오래 "
-"살아 있어야만 합니다.\n"
+"* 슬라이스는 항상 다른 객체로부터 '빌려' 옵니다. 이 예시에서 객체 `a`는 슬라이스  `s`보다 더 오래 살아 있어야만 합니다.\n"
 "    \n"
-"* `a[3]`의 값을 바꿀 수 있냐는 질문은 좋은 질문입니다. 여기에 대한 답은 `a`와 `s`를 통해 데이터를 "
-"읽을 수는 있지만 수정할 수는 없으며, 이는 메모리 안전을 위해서라는 것입니다. 왜 그런지에 대한 좀더 "
-"구체적인 답은 빌림 검사 부분에서 자세히 설명합니다."
+"* `a[3]`의 값을 바꿀 수 있냐는 질문은 좋은 질문입니다. 여기에 대한 답은 `a`와 `s`를 통해 데이터를 읽을 수는 있지만 수정할 수는 없으며, 이는 메모리 안전을 위해서라는 것입니다. 왜 그런지에 대한 좀더 구체적인 답은 빌림 검사 부분에서 자세히 설명합니다."
 
 #: src/basic-syntax/string-slices.md:1
 msgid "# `String` vs `str`"
@@ -2669,21 +2562,17 @@ msgid ""
 "* `&str` introduces a string slice, which is an immutable reference to UTF-8 encoded string data \n"
 "  stored in a block of memory. String literals (`”Hello”`), are stored in the program’s binary."
 msgstr ""
-"* `&str`은 문자열 슬라이스의 불변 참조입니다. 러스트에서 문자열은 UTF-8로 인코딩된 데이터를 의미합"
-"니다.\n"
+"* `&str`은 문자열 슬라이스의 불변 참조입니다. 러스트에서 문자열은 UTF-8로 인코딩된 데이터를 의미합니다.\n"
 " 문자열 리터럴(`”Hello”`)은 프로그램 바이너리에 저장됩니다. "
 
 #: src/basic-syntax/string-slices.md:30
 msgid ""
 "* Rust’s `String` type is a wrapper around a vector of bytes. As with a `Vec<T>`, it is owned.\n"
 "    \n"
-"* As with many other types `String::from()` creates a string from a string literal; `String::"
-"new()` \n"
-"  creates a new empty string, to which string data can be added using the `push()` and "
-"`push_str()` methods."
+"* As with many other types `String::from()` creates a string from a string literal; `String::new()` \n"
+"  creates a new empty string, to which string data can be added using the `push()` and `push_str()` methods."
 msgstr ""
-"* 러스트의 `String`타입은 실제로는 문자열을 이루는 바이트에 대한 백터(`Vec<u8>`)입니다. `Vec<T>`가 "
-"`T`를 소유하고 있듯이, `String`이 가리키고 있는 문자열은 `String`의 소유입니다.\n"
+"* 러스트의 `String`타입은 실제로는 문자열을 이루는 바이트에 대한 백터(`Vec<u8>`)입니다. `Vec<T>`가 `T`를 소유하고 있듯이, `String`이 가리키고 있는 문자열은 `String`의 소유입니다.\n"
 "* 다른 많은 타입들처럼 `String::from`는 문자열 리터럴로부터 문자열을 생성합니다.\n"
 "  * `String::new()`는 새로운 빈 문자열을 생성합니다. \n"
 "  * `push()`와 `push_str()`메서드를 사용하여 문자열 데이터를 추가 할 수 있습니다."
@@ -2697,18 +2586,15 @@ msgid ""
 "    \n"
 "* For C++ programmers: think of `&str` as `const char*` from C++, but the one that always points \n"
 "  to a valid string in memory. Rust `String` is a rough equivalent of `std::string` from C++ \n"
-"  (main difference: it can only contain UTF-8 encoded bytes and will never use a small-string "
-"optimization).\n"
+"  (main difference: it can only contain UTF-8 encoded bytes and will never use a small-string optimization).\n"
 "    \n"
 "</details>"
 msgstr ""
 "* `format!()` 매크로는 변수의 값을 문자열로 변환하는 편리한 방법입니다.\n"
 "  이 매크로는 `println!()` 매크로와 동일한 포맷팅 형식을 지원합니다.\n"
 "* `&`와 범위 연산자를 이용하여 `String`에서 `&str`슬라이스를 빌려올 수 있습니다.\n"
-"* 당신이 C++ 프로그래머 라면: `&str`는 C++의 `const char*`와 유사하지만 항상 유효한 문자열을 가리킨"
-"다는 점이 다릅니다. 러스트의 `String`은 C++의 `std::string` 과 대략 거의 동일합니다.\n"
-"  (주요 차이점:  러스트의 `String`은 UTF-8 인코딩 바이트만 포함할 수 있으며 작은 문자열 최적화"
-"(small-string optimization)는 사용하지 않습니다.\n"
+"* 당신이 C++ 프로그래머 라면: `&str`는 C++의 `const char*`와 유사하지만 항상 유효한 문자열을 가리킨다는 점이 다릅니다. 러스트의 `String`은 C++의 `std::string` 과 대략 거의 동일합니다.\n"
+"  (주요 차이점:  러스트의 `String`은 UTF-8 인코딩 바이트만 포함할 수 있으며 작은 문자열 최적화(small-string optimization)는 사용하지 않습니다.\n"
 "    \n"
 "</details>"
 
@@ -2717,17 +2603,13 @@ msgid "# Functions"
 msgstr "# 함수"
 
 #: src/basic-syntax/functions.md:3
-msgid ""
-"A Rust version of the famous [FizzBuzz](https://en.wikipedia.org/wiki/Fizz_buzz) interview "
-"question:"
+msgid "A Rust version of the famous [FizzBuzz](https://en.wikipedia.org/wiki/Fizz_buzz) interview question:"
 msgstr ""
 "러스트 버전의 [FizzBuzz](https://en.wikipedia.org/wiki/Fizz_buzz) 함수입니다: \n"
 "* _역주_\n"
-"  * _corner case: 복합 경계 조건. 변수와 환경적인 요소로 인해서 로직에 문제가 있는 경우.(나누기 로"
-"직에서 0으로 나누는 경우.)_\n"
+"  * _corner case: 복합 경계 조건. 변수와 환경적인 요소로 인해서 로직에 문제가 있는 경우.(나누기 로직에서 0으로 나누는 경우.)_\n"
 "    * _edge case: 경계조건. 매개변수 값이 극단적인 최대/최소값  (로직 유효범위 끝) 이상인 경우._\n"
-"  * _fizzbuzz: 숫자를 입력받아서 3으로 나뉘면 fizz, 5으로 나뉘면 buss, 둘다  나뉘면 fizzbuzz, 안나"
-"뉘면 입력값을 출력하는 테스트로 자주 쓰는 문제입니다._"
+"  * _fizzbuzz: 숫자를 입력받아서 3으로 나뉘면 fizz, 5으로 나뉘면 buss, 둘다  나뉘면 fizzbuzz, 안나뉘면 입력값을 출력하는 테스트로 자주 쓰는 문제입니다._"
 
 #: src/basic-syntax/functions.md:5
 msgid ""
@@ -2795,30 +2677,18 @@ msgstr ""
 
 #: src/basic-syntax/functions.md:35
 msgid ""
-"* We refer in `main` to a function written below. Neither forward declarations nor headers are "
-"necessary. \n"
-"* Declaration parameters are followed by a type (the reverse of some programming languages), then "
-"a return type.\n"
-"* The last expression in a function body (or any block) becomes the return value. Simply omit the "
-"`;` at the end of the expression.\n"
-"* Some functions have no return value, and return the 'unit type', `()`. The compiler will infer "
-"this if the `-> ()` return type is omitted.\n"
-"* The range expression in the `for` loop in `fizzbuzz_to()` contains `=n`, which causes it to "
-"include the upper bound.\n"
-"* The `match` expression in `fizzbuzz()` is doing a lot of work. It is expanded below to show what "
-"is happening."
+"* We refer in `main` to a function written below. Neither forward declarations nor headers are necessary. \n"
+"* Declaration parameters are followed by a type (the reverse of some programming languages), then a return type.\n"
+"* The last expression in a function body (or any block) becomes the return value. Simply omit the `;` at the end of the expression.\n"
+"* Some functions have no return value, and return the 'unit type', `()`. The compiler will infer this if the `-> ()` return type is omitted.\n"
+"* The range expression in the `for` loop in `fizzbuzz_to()` contains `=n`, which causes it to include the upper bound.\n"
+"* The `match` expression in `fizzbuzz()` is doing a lot of work. It is expanded below to show what is happening."
 msgstr ""
-"* `main` 함수에서 그 다음에 오는 함수들을 사용할 수 있습니다. 상단에 선언이나 헤더 같은건 필요 없습"
-"니다.\n"
-"* 매개변수를 선언할 때에는 이름을 먼저 쓰고, 타입을 나중에 씁니다. 이름과 타입은 `:` 로 구분합니"
-"다. 이는 일부 언어(예를 들어 C)와 반대임에 유의하시기 바랍니다. 마찬가지로, 리턴 타입도 함수의 시작"
-"이 아닌 가장 뒷부분에 선언합니다.\n"
+"* `main` 함수에서 그 다음에 오는 함수들을 사용할 수 있습니다. 상단에 선언이나 헤더 같은건 필요 없습니다.\n"
+"* 매개변수를 선언할 때에는 이름을 먼저 쓰고, 타입을 나중에 씁니다. 이름과 타입은 `:` 로 구분합니다. 이는 일부 언어(예를 들어 C)와 반대임에 유의하시기 바랍니다. 마찬가지로, 리턴 타입도 함수의 시작이 아닌 가장 뒷부분에 선언합니다.\n"
 "* 함수 본문의 마지막 표현식은 반환 값이 됩니다. 간단히, 식 끝에 있는 `;`를 생략하면 됩니다.\n"
-"* 반환값이 없는 함수의 경우, `유닛 타입 ()`을 반환합니다. `-> ()`가 생략된 경우 컴파일러는 이를 추"
-"론합니다.* `fizzbuzz_to()`함수 내 `for` 반목문의 rage 표현식 중 `=n`은 해당 범위까지 포함한다는 의"
-"미입니다. \n"
-"* `fizzbuzz()`함수의 `match` 표현식은 많은 일을 합니다. 무슨 일이 일어나는지 조금 더 이해하기 쉽도"
-"록 아래 코드를 확인하시기 바랍니다."
+"* 반환값이 없는 함수의 경우, `유닛 타입 ()`을 반환합니다. `-> ()`가 생략된 경우 컴파일러는 이를 추론합니다.* `fizzbuzz_to()`함수 내 `for` 반목문의 rage 표현식 중 `=n`은 해당 범위까지 포함한다는 의미입니다. \n"
+"* `fizzbuzz()`함수의 `match` 표현식은 많은 일을 합니다. 무슨 일이 일어나는지 조금 더 이해하기 쉽도록 아래 코드를 확인하시기 바랍니다."
 
 #: src/basic-syntax/functions.md:42
 msgid "  (Type annotations added for clarity, but they can be elided.)"
@@ -2940,9 +2810,7 @@ msgstr ""
 msgid ""
 "* When using generics, the standard library's `Into<T>` can provide a kind of limited\n"
 "  polymorphism on argument types. We will see more details in a later section."
-msgstr ""
-"* 제너릭을 사용할 때 표준 라이브러리의 `Into<T>`은 타입에 대한 다형성을 제공할 수 있습니다. 나중에 "
-"자세히 설명하겠습니다."
+msgstr "* 제너릭을 사용할 때 표준 라이브러리의 `Into<T>`은 타입에 대한 다형성을 제공할 수 있습니다. 나중에 자세히 설명하겠습니다."
 
 #: src/basic-syntax/functions-interlude.md:30
 msgid "</defails>"
@@ -2973,9 +2841,7 @@ msgid ""
 "* Use a local Rust installation, if possible. This way you can get\n"
 "  auto-completion in your editor. See the page about [Using Cargo] for details\n"
 "  on installing Rust."
-msgstr ""
-"* 가능하다면 러스트가 설치된 로컬 환경에서 진행하세요. 그러는 편이 텍스트 에디터의 자동완성 기능의 "
-"도움을 받을 수 있어서 좋습니다. [카고 사용하기][Using Cargo] 을 참조하시기 바랍니다."
+msgstr "* 가능하다면 러스트가 설치된 로컬 환경에서 진행하세요. 그러는 편이 텍스트 에디터의 자동완성 기능의 도움을 받을 수 있어서 좋습니다. [카고 사용하기][Using Cargo] 을 참조하시기 바랍니다."
 
 #: src/exercises/day-1/morning.md:17
 msgid "* Alternatively, use the Rust Playground."
@@ -2985,9 +2851,7 @@ msgstr "* 혹은 러스트 플레이그라운드를 이용할 수 있습니다.
 msgid ""
 "The code snippets are not editable on purpose: the inline code snippets lose\n"
 "their state if you navigate away from the page."
-msgstr ""
-"페이지 밖으로 이동할 경우 작성한 내용이 소실되기 때문에 제공되는 코드 스니펫은 의도적으로 편집할 "
-"수 없습니다.  "
+msgstr "페이지 밖으로 이동할 경우 작성한 내용이 소실되기 때문에 제공되는 코드 스니펫은 의도적으로 편집할 수 없습니다.  "
 
 #: src/exercises/day-1/morning.md:22 src/exercises/day-1/afternoon.md:11
 #: src/exercises/day-2/morning.md:11 src/exercises/day-2/afternoon.md:7
@@ -3046,10 +2910,8 @@ msgid ""
 "Implementing these traits is how a type expresses that it can be converted into\n"
 "another type."
 msgstr ""
-"러스트의 정수형 타입은 모두 [`From<T>`][1] 와 [`Into<T>`][2] 트레이트를 구현하고 있으며, 이를 통해 "
-"타입 변환이 이루어 집니다.\n"
-"`From<T>` 트레이트는 `from()` 메서드를 가지고 있고, `Into<T>`트레이트는 `into()` 메서드를 가지고 있"
-"습니다.\n"
+"러스트의 정수형 타입은 모두 [`From<T>`][1] 와 [`Into<T>`][2] 트레이트를 구현하고 있으며, 이를 통해 타입 변환이 이루어 집니다.\n"
+"`From<T>` 트레이트는 `from()` 메서드를 가지고 있고, `Into<T>`트레이트는 `into()` 메서드를 가지고 있습니다.\n"
 "러스트에서는 `From`과 `Into` 트레이트를 구현함으로써, 타입 간 변환이 가능하다는 것을 표현합니다."
 
 #: src/exercises/day-1/implicit-conversions.md:25
@@ -3059,18 +2921,14 @@ msgid ""
 "`i16::from(x)`. Or, simpler, with `x.into()`, because `From<i8> for i16`\n"
 "implementation automatically create an implementation of `Into<i16> for i8`."
 msgstr ""
-"표준 라이브러리에는 `From<i8> for i16`가 구현되어 있는데 이것은 `i8` 타입의 변수 `x`를 `i16::"
-"from(x)`를 호출하여 `i16`타입으로 변환할 수 있다는  의미입니다.\n"
-"혹은 더 간단하게 `x.into()`를 사용할 수도 있습니다. 이것이 가능한 이유는 `From<i8> for i16` 구현을 "
-"가지고 있으면 `Into<i16> for i8` 구현이 자동으로 생성되기 때문입니다."
+"표준 라이브러리에는 `From<i8> for i16`가 구현되어 있는데 이것은 `i8` 타입의 변수 `x`를 `i16::from(x)`를 호출하여 `i16`타입으로 변환할 수 있다는  의미입니다.\n"
+"혹은 더 간단하게 `x.into()`를 사용할 수도 있습니다. 이것이 가능한 이유는 `From<i8> for i16` 구현을 가지고 있으면 `Into<i16> for i8` 구현이 자동으로 생성되기 때문입니다."
 
 #: src/exercises/day-1/implicit-conversions.md:30
 msgid ""
 "The same applies for your own `From` implementations for your own types, so it is\n"
 "sufficient to only implement `From` to get a respective `Into` implementation automatically."
-msgstr ""
-"이는 사용자 정의 타입에도 동일하게 적용되는 규칙입니다. 따라서 `From`만을 구현해도 `Into`까지 자동"
-"으로 구현이 됩니다."
+msgstr "이는 사용자 정의 타입에도 동일하게 적용되는 규칙입니다. 따라서 `From`만을 구현해도 `Into`까지 자동으로 구현이 됩니다."
 
 #: src/exercises/day-1/implicit-conversions.md:33
 msgid "1. Execute the above program and look at the compiler error."
@@ -3161,9 +3019,7 @@ msgstr ""
 msgid ""
 "Use the above to write a function `pretty_print` which pretty-print a matrix and\n"
 "a function `transpose` which will transpose a matrix (turn rows into columns):"
-msgstr ""
-"위 코드를 이용해서, 행렬을 예쁘게 출력하는 `pretty_print`함수와, 행렬을 전치(행과  열을 서로 바꾸"
-"는)시키는 `transpose`함수를 작성해 보시기 바랍니다."
+msgstr "위 코드를 이용해서, 행렬을 예쁘게 출력하는 `pretty_print`함수와, 행렬을 전치(행과  열을 서로 바꾸는)시키는 `transpose`함수를 작성해 보시기 바랍니다."
 
 #: src/exercises/day-1/for-loops.md:41
 msgid ""
@@ -3219,7 +3075,8 @@ msgid ""
 "    ];"
 msgstr ""
 
-#: src/exercises/day-1/for-loops.md:71 src/exercises/day-1/solutions-morning.md:70
+#: src/exercises/day-1/for-loops.md:71
+#: src/exercises/day-1/solutions-morning.md:70
 msgid ""
 "    println!(\"matrix:\");\n"
 "    pretty_print(&matrix);"
@@ -3251,16 +3108,13 @@ msgstr ""
 msgid ""
 "See the [`ndarray` crate](https://docs.rs/ndarray/) for a production quality\n"
 "implementation."
-msgstr ""
-"상용 품질의 구현에 대해서는 [`ndarray` 크레이트](https://docs.rs/ndarray/)를 참조하시기 바랍니다."
+msgstr "상용 품질의 구현에 대해서는 [`ndarray` 크레이트](https://docs.rs/ndarray/)를 참조하시기 바랍니다."
 
 #: src/exercises/day-1/for-loops.md:92
 msgid ""
 "The solution and the answer to the bonus section are available in the \n"
 "[Solution](solutions-morning.md#arrays-and-for-loops) section."
-msgstr ""
-"보너스 문제에 대한 답변 역시 [Solution](solutions-morning.md#arrays-and-for-loops)에서 확인할 수 있"
-"습니다."
+msgstr "보너스 문제에 대한 답변 역시 [Solution](solutions-morning.md#arrays-and-for-loops)에서 확인할 수 있습니다."
 
 #: src/basic-syntax/variables.md:1
 msgid "# Variables"
@@ -3296,13 +3150,10 @@ msgstr ""
 
 #: src/basic-syntax/variables.md:17
 msgid ""
-"* Due to type inference the `i32` is optional. We will gradually show the types less and less as "
-"the course progresses.\n"
-"* Note that since `println!` is a macro, `x` is not moved, even using the function like syntax of "
-"`println!(\"x: {}\", x)`"
+"* Due to type inference the `i32` is optional. We will gradually show the types less and less as the course progresses.\n"
+"* Note that since `println!` is a macro, `x` is not moved, even using the function like syntax of `println!(\"x: {}\", x)`"
 msgstr ""
-"* 타입 추론에 덕분에 `i32`는 생략 가능합니다. 강의가 진행될 수록 생략 가능한 부분은 점점 생략할 것"
-"입니다.\n"
+"* 타입 추론에 덕분에 `i32`는 생략 가능합니다. 강의가 진행될 수록 생략 가능한 부분은 점점 생략할 것입니다.\n"
 "* `println!(\"x: {}\", x)`는 함수 호출 처럼 보이지만 실은 매크로 호출이며 `x`는 이동되지 않습니다."
 
 #: src/basic-syntax/type-inference.md:1
@@ -3346,30 +3197,20 @@ msgstr ""
 
 #: src/basic-syntax/type-inference.md:26
 msgid ""
-"This slide demonstrates how the Rust compiler infers types based on constraints given by variable "
-"declarations and usages.\n"
+"This slide demonstrates how the Rust compiler infers types based on constraints given by variable declarations and usages.\n"
 "    \n"
-"It is very important to emphasize that variables declared like this are not of some sort of "
-"dynamic \"any type\" that can\n"
-"hold any data. The machine code generated by such declaration is identical to the explicit "
-"declaration of a type.\n"
-"The compiler does the job for us and helps us to write a more concise code."
+"It is very important to emphasize that variables declared like this are not of some sort of dynamic \"any type\" that can\n"
+"hold any data. The machine code generated by such declaration is identical to the explicit declaration of a type.\n"
+"The compiler does the job for us and helps us write more concise code."
 msgstr ""
-"이 슬라이드는, 러스트 컴파일러가 변수가 어떻게 선언되어 있고, 어떻게 사용되는지를 제약 조건으로 삼"
-"아서 변수의 타입을 추론하는 모습을 보여줍니다.\n"
+"이 슬라이드는, 러스트 컴파일러가 변수가 어떻게 선언되어 있고, 어떻게 사용되는지를 제약 조건으로 삼아서 변수의 타입을 추론하는 모습을 보여줍니다.\n"
 "    \n"
-"여기서 중요한 것은, 이렇게 명시적인 타입을 생략하고 선언되었다고 해서 \"어떤 타입\"이라도 다 담을 "
-"수 있는 타입이 되는 것은 아니라는 점입니다.\n"
-"명시적인 타입 선언이 있던 없던, 컴파일러가 생성한 머신코드는 동일합니다. 컴파일러는 단지 타입 선언"
-"을 생략할 수 있도록 해서 프로그래머가 더 간결한 코드를 쓸 수 있도록 도와줄 뿐입니다."
+"여기서 중요한 것은, 이렇게 명시적인 타입을 생략하고 선언되었다고 해서 \"어떤 타입\"이라도 다 담을 수 있는 타입이 되는 것은 아니라는 점입니다.\n"
+"명시적인 타입 선언이 있던 없던, 컴파일러가 생성한 머신코드는 동일합니다. 컴파일러는 단지 타입 선언을 생략할 수 있도록 해서 프로그래머가 더 간결한 코드를 쓸 수 있도록 도와줄 뿐입니다."
 
 #: src/basic-syntax/type-inference.md:32
-msgid ""
-"The following code tells the compiler to copy into a certain generic container without the code "
-"ever explicitly specifying the contained type, using `_` as a placeholder:"
-msgstr ""
-"아래 코드는, 제너릭 컨테이너를 쓸 때 컨테이터 안에 포함된 데이터의 타입을 명시적으로 쓰지 않고 `_`"
-"로 대체하여도 된다는 것을 보여줍니다."
+msgid "The following code tells the compiler to copy into a certain generic container without the code ever explicitly specifying the contained type, using `_` as a placeholder:"
+msgstr "아래 코드는, 제너릭 컨테이너를 쓸 때 컨테이터 안에 포함된 데이터의 타입을 명시적으로 쓰지 않고 `_`로 대체하여도 된다는 것을 보여줍니다."
 
 #: src/basic-syntax/type-inference.md:34
 msgid ""
@@ -3390,14 +3231,8 @@ msgid ""
 msgstr ""
 
 #: src/basic-syntax/type-inference.md:46
-msgid ""
-"[`collect`](https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.collect) relies "
-"on `FromIterator`, which [`HashSet`](https://doc.rust-lang.org/std/iter/trait.FromIterator.html) "
-"implements."
-msgstr ""
-"[`collect`](https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.collect)는 "
-"[`HashSet`](https://doc.rust-lang.org/std/iter/trait.FromIterator.html)을 구현한 `FromIterator`에 "
-"의존합니다."
+msgid "[`collect`](https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.collect) relies on `FromIterator`, which [`HashSet`](https://doc.rust-lang.org/std/iter/trait.FromIterator.html) implements."
+msgstr "[`collect`](https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html#method.collect)는 [`HashSet`](https://doc.rust-lang.org/std/iter/trait.FromIterator.html)을 구현한 `FromIterator`에 의존합니다."
 
 #: src/basic-syntax/static-and-const.md:1
 msgid "# Static and Constant Variables"
@@ -3469,14 +3304,8 @@ msgid ""
 msgstr ""
 
 #: src/basic-syntax/static-and-const.md:41
-msgid ""
-"As noted in the [Rust RFC Book][1], these are not inlined upon use and have an actual associated "
-"memory location.  This is useful for unsafe and embedded code, and the variable lives through the "
-"entirety of the program execution."
-msgstr ""
-"[Rust RFC Book][1]에서 언급한 바와 같이, 정적 변수는 별도의 메모리 공간을 가지며, 인라인 되지 않습"
-"니다. 정적 변수는 안전하지 않은(unsafe) 러스트와 임베디드 시스템용 코드에서 유용합니다. 이들의 수명"
-"은 프로그램이 수행되는 전체 시간과 동일합니다."
+msgid "As noted in the [Rust RFC Book][1], these are not inlined upon use and have an actual associated memory location.  This is useful for unsafe and embedded code, and the variable lives through the entirety of the program execution."
+msgstr "[Rust RFC Book][1]에서 언급한 바와 같이, 정적 변수는 별도의 메모리 공간을 가지며, 인라인 되지 않습니다. 정적 변수는 안전하지 않은(unsafe) 러스트와 임베디드 시스템용 코드에서 유용합니다. 이들의 수명은 프로그램이 수행되는 전체 시간과 동일합니다."
 
 #: src/basic-syntax/static-and-const.md:44
 msgid "We will look at mutating static data in the [chapter on Unsafe Rust](../unsafe.md)."
@@ -3485,15 +3314,12 @@ msgstr "가변 정적 데이터에 대해서는 안전하지 않은 [러스트 
 #: src/basic-syntax/static-and-const.md:48
 msgid ""
 "* Mention that `const` behaves semantically similar to C++'s `constexpr`.\n"
-"* `static`, on the other hand, is much more similar to a `const` or mutable global variable in C+"
-"+.\n"
-"* It isn't super common that one would need a runtime evaluated constant, but it is helpful and "
-"safer than using a static."
+"* `static`, on the other hand, is much more similar to a `const` or mutable global variable in C++.\n"
+"* It isn't super common that one would need a runtime evaluated constant, but it is helpful and safer than using a static."
 msgstr ""
 "* `const`는 C++의 `constexpr`과 매우 비슷합니다.\n"
 "* 반면에 `static`은 C++의 `const`나 가변 정적 변수와 훨씬 더 유사합니다.\n"
-"* 프로그램 수행시 그 값이 정해지는 상수가 필요한 경우는 드뭅니다. 그러나 그렇다고 해도, 정적 변수"
-"를 사용하는 것 보다는 더 유용하고 안전합니다."
+"* 프로그램 수행시 그 값이 정해지는 상수가 필요한 경우는 드뭅니다. 그러나 그렇다고 해도, 정적 변수를 사용하는 것 보다는 더 유용하고 안전합니다."
 
 #: src/basic-syntax/static-and-const.md:54
 msgid "[1]: https://rust-lang.github.io/rfcs/0246-const-vs-static.html"
@@ -3540,23 +3366,15 @@ msgstr ""
 
 #: src/basic-syntax/scopes-shadowing.md:25
 msgid ""
-"* Definition: Shadowing is different from mutation, because after shadowing both variable's memory "
-"locations exist at the same time. Both are available under the same name, depending where you use "
-"it in the code. \n"
+"* Definition: Shadowing is different from mutation, because after shadowing both variable's memory locations exist at the same time. Both are available under the same name, depending where you use it in the code. \n"
 "* A shadowing variable can have a different type. \n"
 "* Shadowing looks obscure at first, but is convenient for holding on to values after `.unwrap()`.\n"
-"* The following code demonstrates why the compiler can't simply reuse memory locations when "
-"shadowing an immutable variable in a scope, even if the type does not change."
+"* The following code demonstrates why the compiler can't simply reuse memory locations when shadowing an immutable variable in a scope, even if the type does not change."
 msgstr ""
-"* 쉐도잉은 기존 변수에 새로운 값을 할당하는 것이 아닙니다. 쉐도잉을 하면 새로운 변수기 생기며, 이"
-"전 변수와 새 변수는 메모리의 서로 다른 위치에 존재합니다. 그 두 변수는 단지 이름이 같은 뿐이며, 코"
-"드 중 어디에서 그 이름이 사용되었느냐에 따라 어떤 변수를 지칭하는 지가 결정됩니다.\n"
+"* 쉐도잉은 기존 변수에 새로운 값을 할당하는 것이 아닙니다. 쉐도잉을 하면 새로운 변수기 생기며, 이전 변수와 새 변수는 메모리의 서로 다른 위치에 존재합니다. 그 두 변수는 단지 이름이 같은 뿐이며, 코드 중 어디에서 그 이름이 사용되었느냐에 따라 어떤 변수를 지칭하는 지가 결정됩니다.\n"
 "* 쉐도잉 시 타입을 바꿀 수 있습니다.\n"
-"* 처음에 쉐도잉을 보면 코드를 더 모호하게 만든다고 생각할 수 도 있습니다. 그러나 실제로 쉐도잉을 이"
-"용하면, 어떤 변수에서 `.unwrap()` 된 값을 새로운 변수에 담을 경우 새로운 이름을 지을 필요 없이 기"
-"존 이름을 유지할 수 있어서 편리합니다.\n"
-"* 아래 코드는 불변 변수를 쉐도잉할 때 타입이 동일하더라도 새 변수가 원래 변수의 메모리 위치를 재사"
-"용 할 수 없는지 그 이유를 보여줍니다."
+"* 처음에 쉐도잉을 보면 코드를 더 모호하게 만든다고 생각할 수 도 있습니다. 그러나 실제로 쉐도잉을 이용하면, 어떤 변수에서 `.unwrap()` 된 값을 새로운 변수에 담을 경우 새로운 이름을 지을 필요 없이 기존 이름을 유지할 수 있어서 편리합니다.\n"
+"* 아래 코드는 불변 변수를 쉐도잉할 때 타입이 동일하더라도 새 변수가 원래 변수의 메모리 위치를 재사용 할 수 없는지 그 이유를 보여줍니다."
 
 #: src/basic-syntax/scopes-shadowing.md:30
 msgid ""
@@ -3583,10 +3401,8 @@ msgid ""
 "* Full control via manual memory management: C, C++, Pascal, ...\n"
 "* Full safety via automatic memory management at runtime: Java, Python, Go, Haskell, ..."
 msgstr ""
-"* 메모리 관리가 프로그래머의 완전한 통제하에 있지만 수동(_역주_: 그래서 안전하지 않을 수 있는)이 언"
-"어: C, C++, Pascal, ...\n"
-"* 메모리 관리가 런타임에 의해 되므로 안전하지만 자동(_역주_: 그래서 프로그래머가 개입할 여지가 적거"
-"나 없는)인 언어: Java, Python, Go, Haskell, ... "
+"* 메모리 관리가 프로그래머의 완전한 통제하에 있지만 수동(_역주_: 그래서 안전하지 않을 수 있는)이 언어: C, C++, Pascal, ...\n"
+"* 메모리 관리가 런타임에 의해 되므로 안전하지만 자동(_역주_: 그래서 프로그래머가 개입할 여지가 적거나 없는)인 언어: Java, Python, Go, Haskell, ... "
 
 #: src/memory-management.md:8
 msgid "Rust offers a new mix:"
@@ -3622,8 +3438,7 @@ msgstr ""
 "  * 여기 저장되는 값은 컴파일 시 결정되는 고정 크기를 갖습니다. \n"
 "  * 매우 빠름: 메모리 할당/반환이 단지 스택 포인터의 이동만으로 구현됩니다.\n"
 "  * 관리가 쉬움: 함수가 호출되면 할당되고, 리턴하면 반환됩니다.\n"
-"  * 스택에 있는 값들은 매우 높은 메모리 인접성을 가집니다(_역주_: 그래서 캐시를 효과적으로 활용할 "
-"수 있습니다)"
+"  * 스택에 있는 값들은 매우 높은 메모리 인접성을 가집니다(_역주_: 그래서 캐시를 효과적으로 활용할 수 있습니다)"
 
 #: src/memory-management/stack-vs-heap.md:9
 msgid ""
@@ -3645,9 +3460,7 @@ msgstr "# 스택 메모리"
 msgid ""
 "Creating a `String` puts fixed-sized data on the stack and dynamically sized\n"
 "data on the heap:"
-msgstr ""
-"`String` 타입은 고정 크기 데이터(_역주_: 문자열의 길이, 문자열이 저장된 버퍼의 주소 등)는 스택에 저"
-"장하고, 가변 크기 데이터(_역주_: 문자열 버퍼)는 힙에 저장합니다:"
+msgstr "`String` 타입은 고정 크기 데이터(_역주_: 문자열의 길이, 문자열이 저장된 버퍼의 주소 등)는 스택에 저장하고, 가변 크기 데이터(_역주_: 문자열 버퍼)는 힙에 저장합니다:"
 
 #: src/memory-management/stack.md:6
 msgid ""
@@ -3676,28 +3489,18 @@ msgid ""
 msgstr ""
 
 #: src/memory-management/stack.md:28
-msgid ""
-"* Mention that a `String` is backed by a `Vec`, so it has a capacity and length and can grow if "
-"mutable via reallocation on the heap."
-msgstr ""
-"* 문자열(`String`)은 실제로는 `Vec`입니다. 크기(capacity)와 현재 길이(length) 정보를 가지며, 더 큰 "
-"크기가 필요할 경우 힙에서 재 할당을 합니다."
+msgid "* Mention that a `String` is backed by a `Vec`, so it has a capacity and length and can grow if mutable via reallocation on the heap."
+msgstr "* 문자열(`String`)은 실제로는 `Vec`입니다. 크기(capacity)와 현재 길이(length) 정보를 가지며, 더 큰 크기가 필요할 경우 힙에서 재 할당을 합니다."
 
 #: src/memory-management/stack.md:30
-msgid ""
-"* If students ask about it, you can mention that the underlying memory is heap allocated using the "
-"[System Allocator] and custom allocators can be implemented using the [Allocator API]"
+msgid "* If students ask about it, you can mention that the underlying memory is heap allocated using the [System Allocator] and custom allocators can be implemented using the [Allocator API]"
 msgstr ""
 "* 힙은 기본적으로 [System Allocator]를 통해 할당됩니다. 그리고 [Allocator API]를 이용해서\n"
 "  커스텀 메모리 할당자를 만들 수도 있습니다."
 
 #: src/memory-management/stack.md:32
-msgid ""
-"* We can inspect the memory layout with `unsafe` code. However, you should point out that this is "
-"rightfully unsafe!"
-msgstr ""
-"* `unsafe` 코드로 메모리 레이아웃을 살펴볼 수 있습니다. 물론 이 코드가 안전하지 않다는 점을 알려주"
-"세요."
+msgid "* We can inspect the memory layout with `unsafe` code. However, you should point out that this is rightfully unsafe!"
+msgstr "* `unsafe` 코드로 메모리 레이아웃을 살펴볼 수 있습니다. 물론 이 코드가 안전하지 않다는 점을 알려주세요."
 
 #: src/memory-management/stack.md:34
 msgid ""
@@ -3748,8 +3551,7 @@ msgid "You allocate and deallocate heap memory yourself."
 msgstr "사용자가 직접 메모리를 할당, 해제 합니다."
 
 #: src/memory-management/manual.md:5
-msgid ""
-"If not done with care, this can lead to crashes, bugs, security vulnerabilities, and memory leaks."
+msgid "If not done with care, this can lead to crashes, bugs, security vulnerabilities, and memory leaks."
 msgstr "조심하지 않으면, 충돌(crash), 버그, 보안취약성 및 메모리 누출이 발생할 수 있습니다."
 
 #: src/memory-management/manual.md:7
@@ -3787,8 +3589,7 @@ msgstr "# 범위기반 메모리 관리"
 
 #: src/memory-management/scope-based.md:3
 msgid "Constructors and destructors let you hook into the lifetime of an object."
-msgstr ""
-"생성자와 소멸자를 사용하여 객체의 생명주기에 따라 메모리 할당/해제가 일어나도록 할 수 있습니다."
+msgstr "생성자와 소멸자를 사용하여 객체의 생명주기에 따라 메모리 할당/해제가 일어나도록 할 수 있습니다."
 
 #: src/memory-management/scope-based.md:5
 msgid ""
@@ -3798,16 +3599,13 @@ msgid ""
 msgstr ""
 "포인터를 객체로 감싸도록 하면, 그 객체가 소멸될 때 그 포인터가 가리키는 메모리가 \n"
 "해제되도록 할 수 있습니다. 컴파일러는 객체가 소멸될 때 반드시 소멸자가 호출되는 것을 \n"
-"보장합니다. 심지어는 예외(exception)가 발생(_역주_: 함수의 리턴이나 스코프의 종료 뿐만이 아니라) 하"
-"더라도요."
+"보장합니다. 심지어는 예외(exception)가 발생(_역주_: 함수의 리턴이나 스코프의 종료 뿐만이 아니라) 하더라도요."
 
 #: src/memory-management/scope-based.md:9
 msgid ""
 "This is often called _resource acquisition is initialization_ (RAII) and gives\n"
 "you smart pointers."
-msgstr ""
-"이를 종종 RAII (Resource Acquisition Is Initialization)라고 하며, 이런 객체는 일종의 스마트 포인터 "
-"역할을 합니다."
+msgstr "이를 종종 RAII (Resource Acquisition Is Initialization)라고 하며, 이런 객체는 일종의 스마트 포인터 역할을 합니다."
 
 #: src/memory-management/scope-based.md:12
 msgid "## C++ Example"
@@ -3869,9 +3667,7 @@ msgstr "## Jave 예제"
 
 #: src/memory-management/garbage-collection.md:11
 msgid "The `person` object is not deallocated after `sayHello` returns:"
-msgstr ""
-"`person`객체는 `sayHello`함수 반환 후에도 해제되지 않습니다. (_역주_: GC가 나중에 알아서 해제합니"
-"다.)"
+msgstr "`person`객체는 `sayHello`함수 반환 후에도 해제되지 않습니다. (_역주_: GC가 나중에 알아서 해제합니다.)"
 
 #: src/memory-management/garbage-collection.md:13
 msgid ""
@@ -3893,32 +3689,22 @@ msgstr "러스트의 메모리 관리는 지금까지 설명한 방식들을 혼
 #: src/memory-management/rust.md:5
 msgid ""
 "* Safe and correct like Java, but without a garbage collector.\n"
-"* Depending on which abstraction (or combination of abstractions) you choose, can be a single "
-"unique pointer, reference counted, or atomically reference counted.\n"
+"* Depending on which abstraction (or combination of abstractions) you choose, can be a single unique pointer, reference counted, or atomically reference counted.\n"
 "* Scope-based like C++, but the compiler enforces full adherence.\n"
-"* A Rust user can choose the right abstraction for the situation, some even have no cost at "
-"runtime like C."
+"* A Rust user can choose the right abstraction for the situation, some even have no cost at runtime like C."
 msgstr ""
 "* 자바처럼 안전하고 정확합니다. 하지만 GC는 없습니다. \n"
 "* 다양한 추상화를 제공합니다: 단일 포인터, 참조 카운트, 아토믹(atomic) 참조 카운트\n"
 "* C++ 처럼 범위(스코프) 기반입니다. 하지만 컴파일러가 훨씬 더 엄격합니다.\n"
-"* 사용자는 상황에 따라 적합한 추상화를 선택할 수 있습니다. 그 중에는 C 언어 처럼 런타임 오버헤드가 "
-"없는 것도 있습니다."
+"* 사용자는 상황에 따라 적합한 추상화를 선택할 수 있습니다. 그 중에는 C 언어 처럼 런타임 오버헤드가 없는 것도 있습니다."
 
 #: src/memory-management/rust.md:10
 msgid "It achieves this by modeling _ownership_ explicitly."
 msgstr "러스트는 _소유권_을 언어 차원에서 명시적으로 모델링 함으로써 이를 이룹니다."
 
 #: src/memory-management/rust.md:14
-msgid ""
-"* If asked how at this point, you can mention that in Rust this is usually handled by RAII wrapper "
-"types such as [Box], [Vec], [Rc], or [Arc]. These encapsulate ownership and memory allocation via "
-"various means, and prevent the potential errors in C."
-msgstr ""
-"* 이 시점에서 그게 어떻게 가능하냐는 질문이 있으면, 러스트에서 이 작업은 일반적으로 [Box], [Vec], "
-"[Rc] 또는 [Arc]와 같은 RAII 타입에 의해 처리된다고 답변할 수 있습니다. 이들은 다양한 방법을 통해 소"
-"유권과 메모리 할당에 대한 구체적인 내용을을 캡슐화하여, C 언어였다면 발생할 수 있었을 다양한 에러"
-"를 막습니다."
+msgid "* If asked how at this point, you can mention that in Rust this is usually handled by RAII wrapper types such as [Box], [Vec], [Rc], or [Arc]. These encapsulate ownership and memory allocation via various means, and prevent the potential errors in C."
+msgstr "* 이 시점에서 그게 어떻게 가능하냐는 질문이 있으면, 러스트에서 이 작업은 일반적으로 [Box], [Vec], [Rc] 또는 [Arc]와 같은 RAII 타입에 의해 처리된다고 답변할 수 있습니다. 이들은 다양한 방법을 통해 소유권과 메모리 할당에 대한 구체적인 내용을을 캡슐화하여, C 언어였다면 발생할 수 있었을 다양한 에러를 막습니다."
 
 #: src/memory-management/rust.md:16
 msgid "* You may be asked about destructors here, the [Drop] trait is the Rust equivalent."
@@ -3999,8 +3785,7 @@ msgstr ""
 "  * 메모리 누출 문제\n"
 "* JAVA와 같은 자동화 관리: \n"
 "  * GC동작으로 인한 멈춤\n"
-"  * 소멸자 지연 (_역주_: 특정 메모리를 더이상 사용하지 않더라도 곧바로 해제 되지 않고 GC가 동작할 "
-"때 까지 기다려야 한다는 점)\n"
+"  * 소멸자 지연 (_역주_: 특정 메모리를 더이상 사용하지 않더라도 곧바로 해제 되지 않고 GC가 동작할 때 까지 기다려야 한다는 점)\n"
 "* C++ 와 같은 범위 기반 관리: \n"
 "  * 복잡하며, 개발자의 선택사항임\n"
 "  * 사용 후 해제 문제 가능성 있음\n"
@@ -4016,8 +3801,7 @@ msgstr "# 소유권"
 msgid ""
 "All variable bindings have a _scope_ where they are valid and it is an error to\n"
 "use a variable outside its scope:"
-msgstr ""
-"모든 변수 바인딩은 유효한 _범위(스코프)_를 가지며, 범위 밖에서 변수 사용하면 에러가 발생합니다."
+msgstr "모든 변수 바인딩은 유효한 _범위(스코프)_를 가지며, 범위 밖에서 변수 사용하면 에러가 발생합니다."
 
 #: src/ownership.md:6
 msgid ""
@@ -4082,15 +3866,11 @@ msgstr ""
 "* 값(데이터)의 소유권을 갖는 변수는 항상 _단_ 하나 입니다."
 
 #: src/ownership/move-semantics.md:22
-msgid ""
-"* Mention that this is the opposite of the defaults in C++, which copies by value unless you use "
-"`std::move` (and the move constructor is defined!)."
-msgstr ""
-"* 이는 C++과 정반대 임을 설명하세요. C++에서는 복사가 기본이고, `std::move` 를 이용해야만 (그리고 "
-"이동 생성자가 정의되어 있어야만!) 소유권 이전이 됩니다."
+msgid "* Mention that this is the opposite of the defaults in C++, which copies by value unless you use `std::move` (and the move constructor is defined!)."
+msgstr "* 이는 C++과 정반대 임을 설명하세요. C++에서는 복사가 기본이고, `std::move` 를 이용해야만 (그리고 이동 생성자가 정의되어 있어야만!) 소유권 이전이 됩니다."
 
 #: src/ownership/move-semantics.md:24
-msgid "* In Rust, you clones are explicit (by using `clone`)."
+msgid "* In Rust, clones are explicit (by using `clone`)."
 msgstr "* 러스트에서는 복사할때에는 명시적으로 `clone`을 사용합니다."
 
 #: src/ownership/moved-strings-rust.md:1
@@ -4268,23 +4048,17 @@ msgstr ""
 
 #: src/ownership/moves-function-calls.md:20
 msgid ""
-"* With the first call to `say_hello`, `main` gives up ownership of `name`. Afterwards, `name` "
-"cannot be used anymore within `main`.\n"
+"* With the first call to `say_hello`, `main` gives up ownership of `name`. Afterwards, `name` cannot be used anymore within `main`.\n"
 "* The heap memory allocated for `name` will be freed at the end of the `say_hello` function.\n"
-"* `main` can retain ownership if it passes `name` as a reference (`&name`) and if `say_hello` "
-"accepts a reference as a parameter.\n"
+"* `main` can retain ownership if it passes `name` as a reference (`&name`) and if `say_hello` accepts a reference as a parameter.\n"
 "* Alternatively, `main` can pass a clone of `name` in the first call (`name.clone()`).\n"
-"* Rust makes it harder than C++ to inadvertently create copies by making move semantics the "
-"default, and by forcing programmers to make clones explicit."
+"* Rust makes it harder than C++ to inadvertently create copies by making move semantics the default, and by forcing programmers to make clones explicit."
 msgstr ""
-"* `say_hello`함수의 첫번째 호출시 `main`함수는 자신이 가진 `name`에 대한 소유권을 포기하므로, 이후 "
-"`main`함수에서는 `name`을 사용할 수 없습니다. \n"
+"* `say_hello`함수의 첫번째 호출시 `main`함수는 자신이 가진 `name`에 대한 소유권을 포기하므로, 이후 `main`함수에서는 `name`을 사용할 수 없습니다. \n"
 "* `name`에 할당되있는 힙 메모리는 `say_hello`함수의 끝에서 해제됩니다.\n"
-"* `main`함수에서 `name`을 참조로 전달(빌림)하고(`&name`), `say_hello`에서 매개변수를 참조형으로 수"
-"정한다면 `main`함수는 `name`의 소유권을 유지할 수 있습니다. \n"
+"* `main`함수에서 `name`을 참조로 전달(빌림)하고(`&name`), `say_hello`에서 매개변수를 참조형으로 수정한다면 `main`함수는 `name`의 소유권을 유지할 수 있습니다. \n"
 "* 또는 첫번째 호출 시 `main`함수에서 `name`을 복제하여 전달할 수도 있습니다.(`name.clone()`)\n"
-"* 러스트는 이동을 기본으로 하고 복제를 명시적으로 선언하도록 만듬으로, 의도치 않게 복사본을 만드는 "
-"것이 C++에서보다 어렵습니다. \n"
+"* 러스트는 이동을 기본으로 하고 복제를 명시적으로 선언하도록 만듬으로, 의도치 않게 복사본을 만드는 것이 C++에서보다 어렵습니다. \n"
 " "
 
 #: src/ownership/copy-clone.md:1
@@ -4349,16 +4123,12 @@ msgstr "복사(copying)와 복제(cloning)는 같지 않습니다: "
 msgid ""
 "* Copying refers to bitwise copies of memory regions and does not work on arbitrary objects.\n"
 "* Copying does not allow for custom logic (unlike copy constructors in C++).\n"
-"* Cloning is a more general operation and also allows for custom behavior by implementing the "
-"`Clone` trait.\n"
+"* Cloning is a more general operation and also allows for custom behavior by implementing the `Clone` trait.\n"
 "* Copying does not work on types that implement the `Drop` trait."
 msgstr ""
-"* 복사는 메모리의 내용을 그대로 한 벌 더 만드는 것을 의미하며, 아무 객체에서나 다 지원하지는 않습니"
-"다. \n"
-"* 복사는 커스터마이즈 할 수 없습니다. (C++에서 복사 생성자를 통해 복사 동작을 임의로 구현할 수 있"
-"는 것과 비교가 됩니다.)\n"
-"* 복제는 보다 일반적인 작업이며, `Clone`트레이트를 구현하여 복제시 동작을 커스터마이즈 할 수 있습니"
-"다.\n"
+"* 복사는 메모리의 내용을 그대로 한 벌 더 만드는 것을 의미하며, 아무 객체에서나 다 지원하지는 않습니다. \n"
+"* 복사는 커스터마이즈 할 수 없습니다. (C++에서 복사 생성자를 통해 복사 동작을 임의로 구현할 수 있는 것과 비교가 됩니다.)\n"
+"* 복제는 보다 일반적인 작업이며, `Clone`트레이트를 구현하여 복제시 동작을 커스터마이즈 할 수 있습니다.\n"
 "* `Drop` 트레이트를 구현한 타입은 복사되지 않습니다."
 
 #: src/ownership/copy-clone.md:42 src/ownership/lifetimes-function-calls.md:29
@@ -4367,29 +4137,22 @@ msgstr "위의 예시에서 다음을 시도해 보시기 바랍니다:"
 
 #: src/ownership/copy-clone.md:44
 msgid ""
-"* Add a `String` field to `struct Point`. It will not compile because `String` is not a `Copy` "
-"type.\n"
-"* Remove `Copy` from the `derive` attribute. The compiler error is now in the `println!` for  "
-"`p1`.\n"
+"* Add a `String` field to `struct Point`. It will not compile because `String` is not a `Copy` type.\n"
+"* Remove `Copy` from the `derive` attribute. The compiler error is now in the `println!` for  `p1`.\n"
 "* Show that it works if you clone `p1` instead."
 msgstr ""
-"* `Point`구조체에 `String`필드를 추가하세요. 컴파일 되지 않을 것입니다. 왜냐하면 `String`은 `Copy`"
-"트레이트를 구현하고 있지 않기 때문입니다.\n"
-"* `derive` 속성에서 `Copy`를 제거해 보세요. `p1`을 `println!` 할 때 컴파일 에러가 발생할 것입니"
-"다.\n"
+"* `Point`구조체에 `String`필드를 추가하세요. 컴파일 되지 않을 것입니다. 왜냐하면 `String`은 `Copy`트레이트를 구현하고 있지 않기 때문입니다.\n"
+"* `derive` 속성에서 `Copy`를 제거해 보세요. `p1`을 `println!` 할 때 컴파일 에러가 발생할 것입니다.\n"
 "* `p1`을 복제하면 잘 동작함을 확인해 보세요."
 
 #: src/ownership/copy-clone.md:48
 msgid ""
-"If students ask about `derive`, it is sufficient to say that this is a way to generate code in "
-"Rust\n"
-"at compile time. In this case the default implementations of `Copy` and `Clone` traits are "
-"generated.\n"
+"If students ask about `derive`, it is sufficient to say that this is a way to generate code in Rust\n"
+"at compile time. In this case the default implementations of `Copy` and `Clone` traits are generated.\n"
 "    \n"
 "</details>"
 msgstr ""
-"만약 학생들이 `derive`에 대해 묻는다면, 컴파일 시 러스트에서 코드를 생성하는방법이라고 말하는 것으"
-"로 충분합니다.\n"
+"만약 학생들이 `derive`에 대해 묻는다면, 컴파일 시 러스트에서 코드를 생성하는방법이라고 말하는 것으로 충분합니다.\n"
 "위 경우 `Copy`와 `Clone` 트레이트에 대한 기본 구현이 생성됩니다.\n"
 "    \n"
 "</details>"
@@ -4440,15 +4203,10 @@ msgstr ""
 #: src/ownership/borrowing.md:27
 msgid ""
 "Notes on stack returns:\n"
-"* Demonstrate that the return from `add` is cheap because the compiler can eliminate the copy "
-"operation. Change the above code to print stack addresses and run it on the [Playground]. In the "
-"\"DEBUG\" optimization level, the addresses should change, while the stay the same when changing "
-"to the \"RELEASE\" setting:"
+"* Demonstrate that the return from `add` is cheap because the compiler can eliminate the copy operation. Change the above code to print stack addresses and run it on the [Playground]. In the \"DEBUG\" optimization level, the addresses should change, while the stay the same when changing to the \"RELEASE\" setting:"
 msgstr ""
 "스택에 할당된 값을 리턴하는 것에 대한 참고: \n"
-"* `add`에서 값을 반환하는 것은 매우 값이 싸다는 것을 설명하세요. 왜냐하면, 컴파일러가 복사 과정을 "
-"생략할 수 있기 때문입니다. 위 코드를 스택 주소를 출력하도록 수정하고 [Playground]에서 수행해 보세"
-"요. \"디버그\" 최적화 레벨에서는 주소가 바뀌지만, \"릴리즈\" 레벨에서는 바뀌지 않습니다."
+"* `add`에서 값을 반환하는 것은 매우 값이 싸다는 것을 설명하세요. 왜냐하면, 컴파일러가 복사 과정을 생략할 수 있기 때문입니다. 위 코드를 스택 주소를 출력하도록 수정하고 [Playground]에서 수행해 보세요. \"디버그\" 최적화 레벨에서는 주소가 바뀌지만, \"릴리즈\" 레벨에서는 바뀌지 않습니다."
 
 #: src/ownership/borrowing.md:30
 msgid ""
@@ -4477,9 +4235,7 @@ msgid ""
 "  }\n"
 "  ```\n"
 "* The Rust compiler can do return value optimization (RVO).\n"
-"* In C++, copy elision has to be defined in the language specification because constructors can "
-"have side effects. In Rust, this is not an issue at all. If RVO did not happen, Rust will always "
-"performs a simple and efficient `memcpy` copy."
+"* In C++, copy elision has to be defined in the language specification because constructors can have side effects. In Rust, this is not an issue at all. If RVO did not happen, Rust will always performs a simple and efficient `memcpy` copy."
 msgstr ""
 "  fn main() {\n"
 "      let p1 = Point(3, 4);\n"
@@ -4490,9 +4246,7 @@ msgstr ""
 "  }\n"
 "  ```\n"
 "* 러스트 컴파일러는 반환값 최적화(RVO)를 수행할 수 있습니다.\n"
-"* C++에서 copy elision은 생성자의 부수효과 가능성이 있어 언어레벨의 정의가   필요하지만 러스트에서"
-"는 문제가 되지 않습니다. 만약 RVO가 발생하지 않으면 러스트는 항상 간단하고 효율적인 `memcpy`복사를 "
-"수행할 것입니다."
+"* C++에서 copy elision은 생성자의 부수효과 가능성이 있어 언어레벨의 정의가   필요하지만 러스트에서는 문제가 되지 않습니다. 만약 RVO가 발생하지 않으면 러스트는 항상 간단하고 효율적인 `memcpy`복사를 수행할 것입니다."
 
 #: src/ownership/borrowing.md:53
 msgid "[Playground]: https://play.rust-lang.org/"
@@ -4540,24 +4294,12 @@ msgstr ""
 
 #: src/ownership/shared-unique-borrows.md:25
 msgid ""
-"* The above code does not compile because `a` is borrowed as mutable (through `c`) and as "
-"immutable (through `b`) at the same time.\n"
-"* Move the `println!` statement for `b` before the scope that introduces `c` to make the code "
-"compile.\n"
-"* After that change, the compiler realizes that `b` is only ever used before the new mutable "
-"borrow of `a` through `c`. This is a feature of the borrow checker called \"non-lexical "
-"lifetimes\"."
+"* The above code does not compile because `a` is borrowed as mutable (through `c`) and as immutable (through `b`) at the same time.\n"
+"* Move the `println!` statement for `b` before the scope that introduces `c` to make the code compile.\n"
+"* After that change, the compiler realizes that `b` is only ever used before the new mutable borrow of `a` through `c`. This is a feature of the borrow checker called \"non-lexical lifetimes\"."
 msgstr ""
-"* 위 코드 컴파일 되지 않습니다. 왜냐하면 `c`는 `a`를 가변 변수로 빌렸고, 이와 동시에 `b`는 `a`를 불"
-"변 변수로 빌렸기 때문입니다.\n"
-"* `b`에 대한 `println!` 구분을 `c`가 있는 스코프 앞으로 이동하면 컴파일이 됩니다.* 이렇게 바꾸면, "
-"컴파일러는 `c`가 `a`를 가변 변수로 빌리기 전에만 `b`가 사용된다는 것을 확인할 수 있습니다. 빌림 검"
-"사기의 이러한 기능을 \"non-lexical lifetime\" 이라고 합니다. (_역주_: 단순히 스코프만 보면 `b`의 수"
-"명은 `main`함수의 전체라고 생각할 수 있습니다. 때문에 `c`의 블럭 안에서는 `a`에 대한 가변 빌림과 불"
-"변 빌림이 동시에 존재하는 것 처럼 보이며, 이는 위 제약 조건을 위반하는 것으로 생각할 수 있습니다. "
-"그러나 컴파일러는 `b`가 `c`블럭이 시작되기 전에만 사용된다는 점을 적극 활용해서 `b`의 수명을 `c`블"
-"럭의 시작 전 까지로 줄입니다. 그러면 `b`와 `c`의 수명은 겹치지 않고, 따라서 제약 조건을 위반하지 않"
-"습니다.)"
+"* 위 코드 컴파일 되지 않습니다. 왜냐하면 `c`는 `a`를 가변 변수로 빌렸고, 이와 동시에 `b`는 `a`를 불변 변수로 빌렸기 때문입니다.\n"
+"* `b`에 대한 `println!` 구분을 `c`가 있는 스코프 앞으로 이동하면 컴파일이 됩니다.* 이렇게 바꾸면, 컴파일러는 `c`가 `a`를 가변 변수로 빌리기 전에만 `b`가 사용된다는 것을 확인할 수 있습니다. 빌림 검사기의 이러한 기능을 \"non-lexical lifetime\" 이라고 합니다. (_역주_: 단순히 스코프만 보면 `b`의 수명은 `main`함수의 전체라고 생각할 수 있습니다. 때문에 `c`의 블럭 안에서는 `a`에 대한 가변 빌림과 불변 빌림이 동시에 존재하는 것 처럼 보이며, 이는 위 제약 조건을 위반하는 것으로 생각할 수 있습니다. 그러나 컴파일러는 `b`가 `c`블럭이 시작되기 전에만 사용된다는 점을 적극 활용해서 `b`의 수명을 `c`블럭의 시작 전 까지로 줄입니다. 그러면 `b`와 `c`의 수명은 겹치지 않고, 따라서 제약 조건을 위반하지 않습니다.)"
 
 #: src/ownership/lifetimes.md:1
 msgid "# Lifetimes"
@@ -4582,8 +4324,7 @@ msgstr ""
 "* 물론 명시할 수도 있습니다: `&'a Point`, `&'document str`.\n"
 "* `&'a Point` 는 `Point`의 수명이 최소한 `'a`라는 수명보다는 같거나 더 길다는 것을 의미합니다.\n"
 "* 수명은 항상 컴파일러가 자동으로 추론합니다. 직접 수명을 지정할 수는 없습니다.\n"
-"  * 수명 표기(`'`)은 수명 추론시 제약조건이 됩니다. 컴파일러는 이 제약조건을 만족시키는 유요한 수명"
-"을 추론할 수 있는지 검사를 합니다."
+"  * 수명 표기(`'`)은 수명 추론시 제약조건이 됩니다. 컴파일러는 이 제약조건을 만족시키는 유요한 수명을 추론할 수 있는지 검사를 합니다."
 
 #: src/ownership/lifetimes-function-calls.md:1
 msgid "# Lifetimes in Function Calls"
@@ -4626,8 +4367,7 @@ msgstr ""
 
 #: src/ownership/lifetimes-function-calls.md:31
 msgid ""
-"* Move the declaration of `p2` and `p3` into a a new scope (`{ ... }`), resulting in the following "
-"code:\n"
+"* Move the declaration of `p2` and `p3` into a a new scope (`{ ... }`), resulting in the following code:\n"
 "  ```rust,ignore\n"
 "  #[derive(Debug)]\n"
 "  struct Point(i32, i32);"
@@ -4672,25 +4412,19 @@ msgstr ""
 
 #: src/ownership/lifetimes-function-calls.md:52
 msgid ""
-"* Reset the workspace and change the function signature to `fn left_most<'a, 'b>(p1: &'a Point, "
-"p2: &'a Point) -> &'b Point`. This will not compile because the relationship between the lifetimes "
-"`'a` and `'b` is unclear.\n"
+"* Reset the workspace and change the function signature to `fn left_most<'a, 'b>(p1: &'a Point, p2: &'a Point) -> &'b Point`. This will not compile because the relationship between the lifetimes `'a` and `'b` is unclear.\n"
 "* Another way to explain it:\n"
 "  * Two references to two values are borrowed by a function and the function returns\n"
 "    another reference.\n"
 "  * It must have come from one of those two inputs (or from a global variable).\n"
-"  * Which one is it? The compiler needs to to know, so at the call site the returned reference is "
-"not used\n"
+"  * Which one is it? The compiler needs to to know, so at the call site the returned reference is not used\n"
 "    for longer than a variable from where the reference came from."
 msgstr ""
-"* 작업공간을 초기화 한 후 함수 시그니처를 `fn left_most<'a, 'b>(p1: &'a Point, p2: &'a Point) -> "
-"&'b Point`로 변경해 봅니다. 이 경우 `'a`와 `'b`사이의 관계가 불분명하기 때문에 컴파일 되지 않습니"
-"다.\n"
+"* 작업공간을 초기화 한 후 함수 시그니처를 `fn left_most<'a, 'b>(p1: &'a Point, p2: &'a Point) -> &'b Point`로 변경해 봅니다. 이 경우 `'a`와 `'b`사이의 관계가 불분명하기 때문에 컴파일 되지 않습니다.\n"
 "* 이 에러를 설명하는 또 다른 방법은 다음과 같습니다:  \n"
 "  * 이 함수는 두 값을 빌려서, 새로운 참조를 반환합니다.\n"
 "  * 이 반환된 참조는 두 입력 중 하나로 부터 와야 합니다. (아니면 전역 변수로 부터)\n"
-"  * 두 입력 중 어떤 것일까요? 컴파일러는 이를 알아야 합니다. 그래야만 함수 호출부에서 봤을 때, 반환"
-"된 참조의 수명이 원래 값을 수명보다 길지 않음을 확인할 수 있기 때문입니다."
+"  * 두 입력 중 어떤 것일까요? 컴파일러는 이를 알아야 합니다. 그래야만 함수 호출부에서 봤을 때, 반환된 참조의 수명이 원래 값을 수명보다 길지 않음을 확인할 수 있기 때문입니다."
 
 #: src/ownership/lifetimes-data-structures.md:1
 msgid "# Lifetimes in Data Structures"
@@ -4729,29 +4463,21 @@ msgstr ""
 
 #: src/ownership/lifetimes-data-structures.md:25
 msgid ""
-"* In the above example, the annotation on `Highlight` enforces that the data underlying the "
-"contained `&str` lives at least as long as any instance of `Highlight` that uses that data.\n"
-"* If `text` is consumed before the end of the lifetime of `fox` (or `dog`), the borrow checker "
-"throws an error.\n"
-"* Types with borrowed data force users to hold on to the original data. This can be useful for "
-"creating lightweight views, but it generally makes them somewhat harder to use.\n"
+"* In the above example, the annotation on `Highlight` enforces that the data underlying the contained `&str` lives at least as long as any instance of `Highlight` that uses that data.\n"
+"* If `text` is consumed before the end of the lifetime of `fox` (or `dog`), the borrow checker throws an error.\n"
+"* Types with borrowed data force users to hold on to the original data. This can be useful for creating lightweight views, but it generally makes them somewhat harder to use.\n"
 "* When possible, make data structures own their data directly.\n"
-"* Some structs with multiple references inside can have more than one lifetime annotation. This "
-"can be necessary if there is a need to describe lifetime relationships between the references "
-"themselves, in addition to the lifetime of the struct itself. Those are very advanced use cases.\n"
+"* Some structs with multiple references inside can have more than one lifetime annotation. This can be necessary if there is a need to describe lifetime relationships between the references themselves, in addition to the lifetime of the struct itself. Those are very advanced use cases.\n"
 "</details>"
 msgstr ""
-"* 위의 예제에서 `Highlight`의 어노테이션(`<'doc>`)은 적어도 `Highlight` 인스턴스가 살아있는 동안에"
-"는\n"
+"* 위의 예제에서 `Highlight`의 어노테이션(`<'doc>`)은 적어도 `Highlight` 인스턴스가 살아있는 동안에는\n"
 "  그 내부의 `&str`가 가리키는 데이터 역시 살아있어야 한다는 것을 의미합니다.\n"
 "* 만약 `text`가 `fox` (혹은 `dog`)의 수명이 다하기 전에 `erase`함수 호출 등으로 사라지게 된다면\n"
 "  빌림 검사기가 에러를 발생합니다.\n"
-"* 빌린 데이터를 가지고 있는 타입은 사용자로 하여금 원본 데이터를 유지하도록 강제합니다. 이런 타입"
-"은 경량 뷰(lightweight view)를\n"
+"* 빌린 데이터를 가지고 있는 타입은 사용자로 하여금 원본 데이터를 유지하도록 강제합니다. 이런 타입은 경량 뷰(lightweight view)를\n"
 "  만드는데 유용하지만, 이 제약 조건 때문에 이런 타입을 사용하는 것이 쉽지만은 않습니다.\n"
 "* 따라서, 가능하다면, 구조체가 자신의 데이터를 직접 소유하도록 하는 것이 좋습니다.\n"
-"* 한 구조체안에 여러 참조가 있으면서, 이 참조들의 수명이 서로 다르게 지정되는 경우도 있습니다. 이"
-"는 참조와 그 구조체 간의 관계 뿐만이 아니라,\n"
+"* 한 구조체안에 여러 참조가 있으면서, 이 참조들의 수명이 서로 다르게 지정되는 경우도 있습니다. 이는 참조와 그 구조체 간의 관계 뿐만이 아니라,\n"
 "  그 참조들 사이의 수명 관계를 설명해야 할 경우에 필요합니다. 매우 고급 기술입니다.\n"
 "</details>"
 
@@ -4805,9 +4531,7 @@ msgstr ""
 msgid ""
 "Use this to create a library application. Copy the code below to\n"
 "<https://play.rust-lang.org/> and update the types to make it compile:"
-msgstr ""
-"도서관 프로그램을 만들기 위해 아래 코드를 <https://play.rust-lang.org/>에 복사해서 구현하시면 됩니"
-"다."
+msgstr "도서관 프로그램을 만들기 위해 아래 코드를 <https://play.rust-lang.org/>에 복사해서 구현하시면 됩니다."
 
 #: src/exercises/day-1/book-library.md:24
 msgid ""
@@ -4816,7 +4540,8 @@ msgid ""
 "}"
 msgstr ""
 
-#: src/exercises/day-1/book-library.md:28 src/exercises/day-1/solutions-afternoon.md:27
+#: src/exercises/day-1/book-library.md:28
+#: src/exercises/day-1/solutions-afternoon.md:27
 msgid ""
 "struct Book {\n"
 "    title: String,\n"
@@ -4824,7 +4549,8 @@ msgid ""
 "}"
 msgstr ""
 
-#: src/exercises/day-1/book-library.md:33 src/exercises/day-1/solutions-afternoon.md:32
+#: src/exercises/day-1/book-library.md:33
+#: src/exercises/day-1/solutions-afternoon.md:32
 msgid ""
 "impl Book {\n"
 "    // This is a constructor, used below.\n"
@@ -4958,8 +4684,7 @@ msgid ""
 "traits."
 msgstr ""
 "러스트의 소유권 모델은 많은 API에 반영이 되어 있습니다.  \n"
-"예를들어 [`Iterator`](https://doc.rust-lang.org/std/iter/trait.Iterator.html) 와 [`IntoIterator`]"
-"(https://doc.rust-lang.org/std/iter/trait.IntoIterator.html) 같은 트레이트가 있습니다."
+"예를들어 [`Iterator`](https://doc.rust-lang.org/std/iter/trait.Iterator.html) 와 [`IntoIterator`](https://doc.rust-lang.org/std/iter/trait.IntoIterator.html) 같은 트레이트가 있습니다."
 
 #: src/exercises/day-1/iterators-and-ownership.md:8
 msgid "## `Iterator`"
@@ -4969,9 +4694,7 @@ msgstr ""
 msgid ""
 "Traits are like interfaces: they describe behavior (methods) for a type. The\n"
 "`Iterator` trait simply says that you can call `next` until you get `None` back:"
-msgstr ""
-"트레이트는 타입에 대한 행동(메서드)를 설명한다는 점에서 인터페이스와 유사합니다. `Iterator`는 단순"
-"히 `None`이 나올때까지 `next`를 호출하는 것이 가능하다는 것을 나타내는 트레이트입니다."
+msgstr "트레이트는 타입에 대한 행동(메서드)를 설명한다는 점에서 인터페이스와 유사합니다. `Iterator`는 단순히 `None`이 나올때까지 `next`를 호출하는 것이 가능하다는 것을 나타내는 트레이트입니다."
 
 #: src/exercises/day-1/iterators-and-ownership.md:13
 msgid ""
@@ -5038,9 +4761,7 @@ msgstr ""
 msgid ""
 "The `Iterator` trait tells you how to _iterate_ once you have created an\n"
 "iterator. The related trait `IntoIterator` tells you how to create the iterator:"
-msgstr ""
-"`Iterator` 트레이트는 생성된 반복자를 _사용_하는 방법을 알려줍니다. 반면 `IntoIterator` 트레이트는 "
-"반복자를 생성하는 방법을 알려줍니다:"
+msgstr "`Iterator` 트레이트는 생성된 반복자를 _사용_하는 방법을 알려줍니다. 반면 `IntoIterator` 트레이트는 반복자를 생성하는 방법을 알려줍니다:"
 
 #: src/exercises/day-1/iterators-and-ownership.md:53
 msgid ""
@@ -5075,9 +4796,7 @@ msgstr ""
 msgid ""
 "Note that `IntoIter` and `Item` are linked: the iterator must have the same\n"
 "`Item` type, which means that it returns `Option<Item>`"
-msgstr ""
-"`IntoIter`에서 `Item`가 연결되어 있음을 주목하세요. `IntoIter` 반복자는 `Item` 타입의 데이터를 가리"
-"켜야 합니다. 즉, 반복자는 `Option<Item>`을 리턴합니다."
+msgstr "`IntoIter`에서 `Item`가 연결되어 있음을 주목하세요. `IntoIter` 반복자는 `Item` 타입의 데이터를 가리켜야 합니다. 즉, 반복자는 `Option<Item>`을 리턴합니다."
 
 #: src/exercises/day-1/iterators-and-ownership.md:71
 msgid "Like before, what  is the type returned by the iterator?"
@@ -5102,8 +4821,7 @@ msgid ""
 "iterator:"
 msgstr ""
 "자, 이제 우리는 `Iterator`와 `IntoIterator`를 알았으므로 `for` 루프를 만들 수 있습니다. \n"
-"`for` 루프는 `into_iter()`를 호출하여 반복자를 만든 다음 그 반복자를 이용하여 요소들을 반복해서 접"
-"근합니다:"
+"`for` 루프는 `into_iter()`를 호출하여 반복자를 만든 다음 그 반복자를 이용하여 요소들을 반복해서 접근합니다:"
 
 #: src/exercises/day-1/iterators-and-ownership.md:89
 msgid ""
@@ -5136,18 +4854,14 @@ msgstr "매 루프에서 `word`의 타입은 무엇입니까? "
 msgid ""
 "Experiment with the code above and then consult the documentation for [`impl\n"
 "IntoIterator for\n"
-"&Vec<T>`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-for-"
-"%26%27a%20Vec%3CT%2C%20A%3E)\n"
+"&Vec<T>`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-for-%26%27a%20Vec%3CT%2C%20A%3E)\n"
 "and [`impl IntoIterator for\n"
-"Vec<T>`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-for-"
-"Vec%3CT%2C%20A%3E)\n"
+"Vec<T>`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-for-Vec%3CT%2C%20A%3E)\n"
 "to check your answers."
 msgstr ""
 "위 코드에서 실험 해 본 후 다음 문서를 참조해서 답변을 확인하시기 바랍니다.\n"
-"* [`impl IntoIterator for &Vec<T>`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-"
-"IntoIterator-for-%26%27a%20Vec%3CT%2C%20A%3E)\n"
-"* [`impl IntoIterator for Vec<T>`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-"
-"IntoIterator-for-Vec%3CT%2C%20A%3E)"
+"* [`impl IntoIterator for &Vec<T>`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-for-%26%27a%20Vec%3CT%2C%20A%3E)\n"
+"* [`impl IntoIterator for Vec<T>`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-for-Vec%3CT%2C%20A%3E)"
 
 #: src/welcome-day-2.md:1
 msgid "# Welcome to Day 2"
@@ -5234,22 +4948,18 @@ msgid ""
 "  * Unlike in C++, there is no inheritance between structs.\n"
 "* Methods are defined in an `impl` block, which we will see in following slides.\n"
 "* This may be a good time to let people know there are different types of structs. \n"
-"  * Zero-sized structs `e.g., struct Foo;` might be used when implementing a trait on some type "
-"but don’t have any data that you want to store in the value itself. \n"
+"  * Zero-sized structs `e.g., struct Foo;` might be used when implementing a trait on some type but don’t have any data that you want to store in the value itself. \n"
 "  * The next slide will introduce Tuple structs, used when the field names are not important.\n"
-"* The syntax `..peter` allows us to copy the majority of the fields from the old struct without "
-"having to explicitly type it all out. It must always be the last element."
+"* The syntax `..peter` allows us to copy the majority of the fields from the old struct without having to explicitly type it all out. It must always be the last element."
 msgstr ""
 "* 구조체는 C/C++ 와 유사합니다.\n"
 "  * C++ 와 같지만 C와는 달리 타입을 정의하기 위해 'typedef'가 필요하지 않습니다.\n"
 "  * C++ 와 달리 구조체 간 상속은 없습니다.\n"
 "* 메서드는 `impl`블록에 정의 합니다. 다음 슬라이드에서 확인 할 수 있습니다.\n"
 "* 사람들에게 다른 종류의 구조체가 있음을 알게 하기에 좋은 시간일 것입니다.\n"
-"  * 0 크기 구조체(예: `struct Foo;`)는 데이터를 가지고 있지 않지만 특정 타입의 트레이트를 구현할 "
-"때 유용합니다.\n"
+"  * 0 크기 구조체(예: `struct Foo;`)는 데이터를 가지고 있지 않지만 특정 타입의 트레이트를 구현할 때 유용합니다.\n"
 "  * 다음 슬라이드에서는 필드 이름이 덜 중요할 때 사용할 수 있는 튜플 구조체를 소개합니다.\n"
-"* `..peter` 문법은 한 구조체에서 다른 구조체로 대부분의 값을 복사하려고 하는 경우에 하나하나 타이핑"
-"하는\n"
+"* `..peter` 문법은 한 구조체에서 다른 구조체로 대부분의 값을 복사하려고 하는 경우에 하나하나 타이핑하는\n"
 "  수고를 덜어줍니다. 반드시 맨 마지막에 와야 합니다."
 
 #: src/structs/tuple-structs.md:1
@@ -5277,8 +4987,7 @@ msgstr ""
 
 #: src/structs/tuple-structs.md:14
 msgid "This is often used for single-field wrappers (called newtypes):"
-msgstr ""
-"튜플 구조체는 종종 단일 필드의 래퍼(wrapper, 러스트에서 뉴타입(newtype)이라고 부름)로 사용됩니다."
+msgstr "튜플 구조체는 종종 단일 필드의 래퍼(wrapper, 러스트에서 뉴타입(newtype)이라고 부름)로 사용됩니다."
 
 #: src/structs/tuple-structs.md:16
 msgid ""
@@ -5309,21 +5018,18 @@ msgid ""
 "}"
 msgstr ""
 
-#: src/structs/tuple-structs.md:33 src/traits/default.md:36 src/generics/trait-objects.md:86
+#: src/structs/tuple-structs.md:33 src/traits/default.md:36
+#: src/generics/trait-objects.md:86
 msgid "```"
 msgstr ""
 
 #: src/structs/tuple-structs.md:37
 msgid ""
-"* Newtypes are a great way to encode additional information about the value in a primitive type, "
-"for example:\n"
+"* Newtypes are a great way to encode additional information about the value in a primitive type, for example:\n"
 "  * The number is measured in some units: `Newtons` in the example above.\n"
-"  * The value passed some validation when it was created, so you no longer have to validate it "
-"again at every use: 'PhoneNumber(String)` or `OddNumber(u32)`.\n"
-"* Demonstrate how to add a `f64` value to a `Newtons` type by accessing the single field in the "
-"newtype.\n"
-"  *  Rust generally doesn’t like inexplicit things, like automatic unwrapping or for instance "
-"using booleans as integers.\n"
+"  * The value passed some validation when it was created, so you no longer have to validate it again at every use: 'PhoneNumber(String)` or `OddNumber(u32)`.\n"
+"* Demonstrate how to add a `f64` value to a `Newtons` type by accessing the single field in the newtype.\n"
+"  *  Rust generally doesn’t like inexplicit things, like automatic unwrapping or for instance using booleans as integers.\n"
 "  *  Operator overloading is discussed on Day 3 (generics). \n"
 "</details>"
 msgstr ""
@@ -5332,8 +5038,7 @@ msgstr ""
 "  * 값이 생성될 때 이미 유효성 검사를 통과 했으므로 추가적인 검사가 필요없는 경우:\n"
 "    `PhoneNumber(String)`또는 `OddNumber(u32)`\n"
 "* `Newtons` 타입의 값에 `f64` 값을 더하는 방법을 보여주세요.\n"
-"  * 러스트는 대체로 분명하지 않은 것을 싫어합니다. 예를 들면 자동으로 unwrap하거나 불리언 값을 정"
-"수 값으로\n"
+"  * 러스트는 대체로 분명하지 않은 것을 싫어합니다. 예를 들면 자동으로 unwrap하거나 불리언 값을 정수 값으로\n"
 "    사용하는 것들이 그렇습니다.\n"
 "  * 연산자 재정의는 3일차 제너릭 부분에서 다룹니다.\n"
 "</details>"
@@ -5346,8 +5051,7 @@ msgstr "# 필드 할당 단축 문법(Field Shorthand Syntax)"
 msgid ""
 "If you already have variables with the right names, then you can create the\n"
 "struct using a shorthand:"
-msgstr ""
-"구조체 필드와 동일한 이름의 변수가 있다면 아래와 같이 _짧은 문법_ 으로 구조체를 생성할 수 있습니다:"
+msgstr "구조체 필드와 동일한 이름의 변수가 있다면 아래와 같이 _짧은 문법_ 으로 구조체를 생성할 수 있습니다:"
 
 #: src/structs/field-shorthand.md:6 src/methods.md:6
 msgid ""
@@ -5378,9 +5082,7 @@ msgid ""
 msgstr ""
 
 #: src/structs/field-shorthand.md:27
-msgid ""
-"The `new` function could be written using `Self` as a type, as it is interchangeable with the "
-"struct type name"
+msgid "The `new` function could be written using `Self` as a type, as it is interchangeable with the struct type name"
 msgstr "`new`함수를 다음처럼 구조체 이름 대신 `Self`를 사용하여 작성해도 됩니다."
 
 #: src/structs/field-shorthand.md:29
@@ -5456,25 +5158,19 @@ msgstr ""
 #: src/enums.md:35
 msgid ""
 "* Enumerations allow you to collect a set of values under one type\n"
-"* This page offers an enum type `CoinFlip` with two variants `Heads` and `Tail`. You might note "
-"the namespace when using variants.\n"
+"* This page offers an enum type `CoinFlip` with two variants `Heads` and `Tail`. You might note the namespace when using variants.\n"
 "* This might be a good time to compare Structs and Enums:\n"
-"  * In both, you can have a simple version without fields (unit struct) or one with different "
-"types of fields (variant payloads). \n"
+"  * In both, you can have a simple version without fields (unit struct) or one with different types of fields (variant payloads). \n"
 "  * In both, associated functions are defined within an `impl` block.\n"
-"  * You could even implement the different variants of an enum with separate structs but then they "
-"wouldn’t be the same type as they would if they were all defined in an enum. \n"
+"  * You could even implement the different variants of an enum with separate structs but then they wouldn’t be the same type as they would if they were all defined in an enum. \n"
 "</details>"
 msgstr ""
 "* 열거형은 값들의 집합을 하나의 타입으로 표현할 수 있게 합니다.\n"
-"* 위의 `CoinFlip` 열거형 타입은 `Heads`와 `Tail` 두가지 variant를 가집니다.  열거형 타입의 variant"
-"는 네임스페이스를 붙여서 사용합니다.\n"
+"* 위의 `CoinFlip` 열거형 타입은 `Heads`와 `Tail` 두가지 variant를 가집니다.  열거형 타입의 variant는 네임스페이스를 붙여서 사용합니다.\n"
 "* 구조체와 열거형을 비교해 볼까요?\n"
-"  * 구조체나 열거형 모두, 필드가 하나도 없는 단순한 형태도 가능 하고, 여러 타입의 필드를 가질 수도 "
-"있습니다.\n"
+"  * 구조체나 열거형 모두, 필드가 하나도 없는 단순한 형태도 가능 하고, 여러 타입의 필드를 가질 수도 있습니다.\n"
 "  * 둘 다 연관함수를 `impl`블록으로 정의 할 수 있습니다.\n"
-"  * 열거형 타입의 각 variant를 별도의 구조체로 정의할 수도 있지만, 그러면 열거형을 사용했을 때처럼 "
-"하나의 타입으로 취급할 수 없습니다.\n"
+"  * 열거형 타입의 각 variant를 별도의 구조체로 정의할 수도 있지만, 그러면 열거형을 사용했을 때처럼 하나의 타입으로 취급할 수 없습니다.\n"
 "</details>"
 
 #: src/enums/variant-payloads.md:1
@@ -5485,9 +5181,7 @@ msgstr "# 데이터를 포함하는 열거형(Variant Payloads)"
 msgid ""
 "You can define richer enums where the variants carry data. You can then use the\n"
 "`match` statement to extract the data from each variant:"
-msgstr ""
-"좀더 복잡한 열거형의 경우 variant에 데이터(payload)를 포함시키도 합니다.각 variant에 담긴 데이터는 "
-"`match`문을 이용해 추출합니다."
+msgstr "좀더 복잡한 열거형의 경우 variant에 데이터(payload)를 포함시키도 합니다.각 variant에 담긴 데이터는 `match`문을 이용해 추출합니다."
 
 #: src/enums/variant-payloads.md:6
 msgid ""
@@ -5530,24 +5224,17 @@ msgstr ""
 
 #: src/enums/variant-payloads.md:35
 msgid ""
-"* In the above example, accessing the `char` in `KeyPress`, or `x` and `y` in `Click` only works "
-"within a `match` or an `if let` statement.\n"
+"* In the above example, accessing the `char` in `KeyPress`, or `x` and `y` in `Click` only works within a `match` or an `if let` statement.\n"
 "* `match` and `if let` inspect a hidden discriminant field in the `enum`.\n"
 "* It is possible to retrieve the discriminant by calling `std::mem::discriminant()`\n"
-"  * This is useful, for example, if implementing `PartialEq` for structs where comparing field "
-"values doesn't affect equality.\n"
-"* `WebEvent::Click { ... }` is not exactly the same as `WebEvent::Click(Click)` with a top level "
-"`struct Click { ... }`. The inlined version cannot implement traits, for example."
+"  * This is useful, for example, if implementing `PartialEq` for structs where comparing field values doesn't affect equality.\n"
+"* `WebEvent::Click { ... }` is not exactly the same as `WebEvent::Click(Click)` with a top level `struct Click { ... }`. The inlined version cannot implement traits, for example."
 msgstr ""
-"* 위의 예제에서 `KeyPress`의 `char`, `Cilck`의 `x`와 `y`의 접근은 `match`나 `if let` 안에서만 동작 "
-"합니다.\n"
-"* `match`는 주어진 열거형 값이 실제로 어떤 variant인지 판단하기 위해, 그 variant의 종류가 기록된, "
-"숨겨진 필드(식별자)의 값을 검사합니다.\n"
+"* 위의 예제에서 `KeyPress`의 `char`, `Cilck`의 `x`와 `y`의 접근은 `match`나 `if let` 안에서만 동작 합니다.\n"
+"* `match`는 주어진 열거형 값이 실제로 어떤 variant인지 판단하기 위해, 그 variant의 종류가 기록된, 숨겨진 필드(식별자)의 값을 검사합니다.\n"
 "* `std::mem::discriminant()`를 이용하여 식별자를 얻을 수도 있습니다.\n"
 "  * 이는 각 필드 값을 굳이 비교할 필요 없는 구조체에 대해 `PartialEq` 트레이트를 구현할 때 유용합니다.\n"
-"* `WebEvent::Click { ... }`은 최상위 레벨 구조체 `struct Click {...}`를 따로 정의하고 `WebEvent::"
-"Click(Click)`처럼 튜플 형태로 정의한 것과 정확히 같진 않습니다. 예를 들어 `WebEvent::Click { ... }"
-"` 로 정의한 경우, 구조체 형태와 유사하지만 트레이트를 구현 할 수 없습니다."
+"* `WebEvent::Click { ... }`은 최상위 레벨 구조체 `struct Click {...}`를 따로 정의하고 `WebEvent::Click(Click)`처럼 튜플 형태로 정의한 것과 정확히 같진 않습니다. 예를 들어 `WebEvent::Click { ... }` 로 정의한 경우, 구조체 형태와 유사하지만 트레이트를 구현 할 수 없습니다."
 
 #: src/enums/sizes.md:1
 msgid "# Enum Sizes"
@@ -5606,8 +5293,7 @@ msgstr ""
 
 #: src/enums/sizes.md:37
 msgid "* See the [Rust Reference](https://doc.rust-lang.org/reference/type-layout.html)."
-msgstr ""
-"* 자세한 사항은 [공식문서](https://doc.rust-lang.org/reference/type-layout.html)를 확인하세요."
+msgstr "* 자세한 사항은 [공식문서](https://doc.rust-lang.org/reference/type-layout.html)를 확인하세요."
 
 #: src/enums/sizes.md:39
 msgid ""
@@ -5615,39 +5301,29 @@ msgid ""
 "    \n"
 "Key Points: \n"
 " * Internally Rust is using a field (discriminant) to keep track of the enum variant.\n"
-" * `Bar` enum demonstrates that there is a way to control the discriminant value and type. If "
-"`repr` is removed, the discriminant type takes 2 bytes, becuase 10001 fits 2 bytes.\n"
-" * As a niche optimization an enum discriminant is merged with the pointer so that `Option<&Foo>` "
-"is the same size as `&Foo`.\n"
+" * `Bar` enum demonstrates that there is a way to control the discriminant value and type. If `repr` is removed, the discriminant type takes 2 bytes, becuase 10001 fits 2 bytes.\n"
+" * As a niche optimization an enum discriminant is merged with the pointer so that `Option<&Foo>` is the same size as `&Foo`.\n"
 " * `Option<bool>` is another example of tight packing.\n"
-" * For [some types](https://doc.rust-lang.org/std/option/#representation), Rust guarantees that "
-"`size_of::<T>()` equals `size_of::<Option<T>>()`.\n"
-" * Zero-sized types allow for efficient implementation of `HashSet` using `HashMap` with `()` as "
-"the value."
+" * For [some types](https://doc.rust-lang.org/std/option/#representation), Rust guarantees that `size_of::<T>()` equals `size_of::<Option<T>>()`.\n"
+" * Zero-sized types allow for efficient implementation of `HashSet` using `HashMap` with `()` as the value."
 msgstr ""
 "<details>\n"
 "    \n"
 "키 포인트: \n"
 "* 러스트는 내부적으로 열거형의 각 variant를 구분하기 위해 별도의 필드(식별자)를 사용합니다.\n"
-"* `Bar` 타입을 보면 식별자의 값을 직접 지정하거나 그 타입을 변경할 수 있음을 알 수 있습니다.`repr`"
-"을 제거하면 10001을 나타내는데 2바이트가 필요하기 때문에 식별자 타입이 2바이트를 차지합니다.\n"
-"* 니치 최적화(niche optimization)로서 열거형(enum)의 식별자는 포인터에 결합됩니다.그래서 "
-"`Option<&Foo>` 타입은 `&Foo`와 같은 사이즈가 됩니다.\n"
+"* `Bar` 타입을 보면 식별자의 값을 직접 지정하거나 그 타입을 변경할 수 있음을 알 수 있습니다.`repr`을 제거하면 10001을 나타내는데 2바이트가 필요하기 때문에 식별자 타입이 2바이트를 차지합니다.\n"
+"* 니치 최적화(niche optimization)로서 열거형(enum)의 식별자는 포인터에 결합됩니다.그래서 `Option<&Foo>` 타입은 `&Foo`와 같은 사이즈가 됩니다.\n"
 "* `Option<bool>역시 이에 대한 또 다른 예입니다.\n"
-"* [일부 타입](https://doc.rust-lang.org/std/option/#representation)의 경우 러스트는 `size_of::"
-"<T>()`와 `size_of::<Option<T>>()`가 동일함을 보장합니다. \n"
-"* 0크기 타입 덕분에 `HashMap`의 값을 `()`로 지정하는 식으로 `HashSet`을 효율적으로 구현할 수 있습니"
-"다."
+"* [일부 타입](https://doc.rust-lang.org/std/option/#representation)의 경우 러스트는 `size_of::<T>()`와 `size_of::<Option<T>>()`가 동일함을 보장합니다. \n"
+"* 0크기 타입 덕분에 `HashMap`의 값을 `()`로 지정하는 식으로 `HashSet`을 효율적으로 구현할 수 있습니다."
 
 #: src/enums/sizes.md:49
 msgid ""
 "Example code if you want to show how the bitwise representation *may* look like in practice.\n"
-"It's important to note that the compiler provides no guarantees regarding this representation, "
-"therefore this is totally unsafe."
+"It's important to note that the compiler provides no guarantees regarding this representation, therefore this is totally unsafe."
 msgstr ""
 "비트 수준에서 어떤식으로 표현되는지 보여주고 싶다면 다음 예제 코드를 사용해보세요.\n"
-"컴파일러가 비트 표현까지 보장하지 않기 때문에 여기에 의존하는 것은 안전하지 않다는 점을 꼭 알려주세"
-"요."
+"컴파일러가 비트 표현까지 보장하지 않기 때문에 여기에 의존하는 것은 안전하지 않다는 점을 꼭 알려주세요."
 
 #: src/enums/sizes.md:52
 msgid ""
@@ -5703,11 +5379,8 @@ msgid ""
 msgstr ""
 
 #: src/enums/sizes.md:87
-msgid ""
-"More complex example if you want to discuss what happens when we chain more than 256 `Option`s "
-"together."
-msgstr ""
-"좀더 복잡한 예제입니다. `Option`을 256개 이상으로 중첩한 경우에 어떻게 되는지 볼 수 있습니다."
+msgid "More complex example if you want to discuss what happens when we chain more than 256 `Option`s together."
+msgstr "좀더 복잡한 예제입니다. `Option`을 256개 이상으로 중첩한 경우에 어떻게 되는지 볼 수 있습니다."
 
 #: src/enums/sizes.md:89
 msgid ""
@@ -5801,38 +5474,26 @@ msgstr ""
 msgid ""
 "Key Points:\n"
 "* It can be helpful to introduce methods by comparing them to functions.\n"
-"  * Methods are called on an instance of a type (such as a struct or enum), the first parameter "
-"represents the instance as `self`.\n"
-"  * Developers may choose to use methods to take advantage of method receiver syntax and to help "
-"keep them more organized. By using methods we can keep all the implementation code in one "
-"predictable place.\n"
+"  * Methods are called on an instance of a type (such as a struct or enum), the first parameter represents the instance as `self`.\n"
+"  * Developers may choose to use methods to take advantage of method receiver syntax and to help keep them more organized. By using methods we can keep all the implementation code in one predictable place.\n"
 "* Point out the use of the keyword `self`, a method receiver. \n"
-"  * Show that it is an abbreviated term for `self:&Self` and perhaps show how the struct name "
-"could also be used. \n"
-"  * Explain that `Self` is a type alias for the type the `impl` block is in and can be used "
-"elsewhere in the block.\n"
-"  * Note how `self` is used like other structs and dot notation can be used to refer to individual "
-"fields.\n"
-"  * This might be a good time to demonstrate how the `&self` differs from `self` by modifying the "
-"code and trying to run say_hello twice.  \n"
+"  * Show that it is an abbreviated term for `self:&Self` and perhaps show how the struct name could also be used. \n"
+"  * Explain that `Self` is a type alias for the type the `impl` block is in and can be used elsewhere in the block.\n"
+"  * Note how `self` is used like other structs and dot notation can be used to refer to individual fields.\n"
+"  * This might be a good time to demonstrate how the `&self` differs from `self` by modifying the code and trying to run say_hello twice.  \n"
 "* We describe the distinction between method receivers next.\n"
 "   \n"
 "</details>"
 msgstr ""
 "키 포인트: \n"
 "* 메서드를 함수와 비교하여 소개하는 것도 도움이 될 수 있습니다.\n"
-"  * 메서드는 구조체나 열거형과 같은 타입의 인스턴스에서 호출 되며, 첫번째 매개변수(파라메터)는 인스"
-"턴스를 `self`로 표기합니다.\n"
-"  * 메서드를 이용하면 receiver 문법을 사용할 수 있고 코드를 좀더 체계적으로 정리할 수 있습니다. 메"
-"서드들이 예측 가능한 위치에 모여 있으니 찾기 쉽습니다.\n"
+"  * 메서드는 구조체나 열거형과 같은 타입의 인스턴스에서 호출 되며, 첫번째 매개변수(파라메터)는 인스턴스를 `self`로 표기합니다.\n"
+"  * 메서드를 이용하면 receiver 문법을 사용할 수 있고 코드를 좀더 체계적으로 정리할 수 있습니다. 메서드들이 예측 가능한 위치에 모여 있으니 찾기 쉽습니다.\n"
 "* 메서드 receiver인 `self` 키워드 사용을 언급해 주시기 바랍니다.\n"
-"  * 예제의 경우 `self: &Self`의 줄인 버전임을 알려주고, 구조체의 이름을 직접 사용하면 어떻게 되는"
-"지 보여주는 것도 좋습니다.\n"
+"  * 예제의 경우 `self: &Self`의 줄인 버전임을 알려주고, 구조체의 이름을 직접 사용하면 어떻게 되는지 보여주는 것도 좋습니다.\n"
 "  * `impl` 블록 내부에서는 `Self`가 해당 타입의 이름 대용으로 사용될 수 있음을 알려주세요.\n"
-"  * 구조체의 필드를 접근할 때 점 표기를 사용하듯이 `self`에 점 표기를 사용하여 개별 필드들을 접근"
-"할 수 있습니다.\n"
-"  * `say_hello` 함수가 두 번 호출되도록 코드를 수정하여 `&self`와 `self`가 어떻게 다른지 보여주는 "
-"것도 좋습니다.\n"
+"  * 구조체의 필드를 접근할 때 점 표기를 사용하듯이 `self`에 점 표기를 사용하여 개별 필드들을 접근할 수 있습니다.\n"
+"  * `say_hello` 함수가 두 번 호출되도록 코드를 수정하여 `&self`와 `self`가 어떻게 다른지 보여주는 것도 좋습니다.\n"
 "* 다음 슬라이드에서 receiver의 구분을 설명합니다.\n"
 "</details>"
 
@@ -5844,9 +5505,7 @@ msgstr "# 메서드 리시버(Receiver)"
 msgid ""
 "The `&self` above indicates that the method borrows the object immutably. There\n"
 "are other possible receivers for a method:"
-msgstr ""
-"`&self`는 메서드가 객체를 불변하게 빌려옴을 나타냅니다. 메서드의 리시버는 다음의 형태들이 가능합니"
-"다."
+msgstr "`&self`는 메서드가 객체를 불변하게 빌려옴을 나타냅니다. 메서드의 리시버는 다음의 형태들이 가능합니다."
 
 #: src/methods/receiver.md:6
 msgid ""
@@ -5863,33 +5522,24 @@ msgid ""
 "* No receiver: this becomes a static method on the struct. Typically used to\n"
 "  create constructors which are called `new` by convention."
 msgstr ""
-"* `&self`: 호출자로부터 공유가능한 불변 참조 방식으로 객체를 빌려옴을 나타냅니다. 객체는 메소드 호"
-"출 뒤에도 사용될 수 있습니다.\n"
-"* `&mut self`: 호출자로부터 유일한 가변 참조 방식으로 객체를 빌려옴을 나타냅니다. 객체는 메소드 호"
-"출 뒤에도 사용될 수 있습니다.\n"
-"* `self`: 호출자로부터 객체의 소유권을 가져오고 객체는 호출자로부터 메소드로 이동됩니다. 메소드가 "
-"객체를 소유하게 되며 따라서 명시적으로 소유권을 다른 곳으로 전달하지 않는다면 메서드 종료와 함께 객"
-"체는 drop(해제)됩니다.\n"
-"* `mut self`: 위와 동일하지만 메서드가 객체의 소유권을 가지면서 동시에 객체를 수정할 수도 있습니"
-"다. 소유권을 가지는 것이 수정할 수 있음을 의미하는 것은 아닙니다.\n"
-"* 리시버 없음: 구조체의 정적 메서드가 됩니다. 주로 생성자를 만들때 사용하게 되며, 생성자는 흔히 "
-"`new`라고 이름붙입니다."
+"* `&self`: 호출자로부터 공유가능한 불변 참조 방식으로 객체를 빌려옴을 나타냅니다. 객체는 메소드 호출 뒤에도 사용될 수 있습니다.\n"
+"* `&mut self`: 호출자로부터 유일한 가변 참조 방식으로 객체를 빌려옴을 나타냅니다. 객체는 메소드 호출 뒤에도 사용될 수 있습니다.\n"
+"* `self`: 호출자로부터 객체의 소유권을 가져오고 객체는 호출자로부터 메소드로 이동됩니다. 메소드가 객체를 소유하게 되며 따라서 명시적으로 소유권을 다른 곳으로 전달하지 않는다면 메서드 종료와 함께 객체는 drop(해제)됩니다.\n"
+"* `mut self`: 위와 동일하지만 메서드가 객체의 소유권을 가지면서 동시에 객체를 수정할 수도 있습니다. 소유권을 가지는 것이 수정할 수 있음을 의미하는 것은 아닙니다.\n"
+"* 리시버 없음: 구조체의 정적 메서드가 됩니다. 주로 생성자를 만들때 사용하게 되며, 생성자는 흔히 `new`라고 이름붙입니다."
 
 #: src/methods/receiver.md:19
 msgid ""
 "Beyond variants on `self`, there are also\n"
 "[special wrapper types](https://doc.rust-lang.org/reference/special-types-and-traits.html)\n"
 "allowed to be receiver types, such as `Box<Self>`."
-msgstr ""
-"`self`를 사용하는 이같은 변형들 외에도 `Box<Self>`와 같이 리시버 타입으로 허용되는 [특별한 래퍼 타"
-"입](https://doc.rust-lang.org/reference/special-types-and-traits.html)이 있습니다."
+msgstr "`self`를 사용하는 이같은 변형들 외에도 `Box<Self>`와 같이 리시버 타입으로 허용되는 [특별한 래퍼 타입](https://doc.rust-lang.org/reference/special-types-and-traits.html)이 있습니다."
 
 #: src/methods/receiver.md:23
 msgid ""
 "<details>\n"
 "  \n"
-"Consider emphasizing \"shared and immutable\" and \"unique and mutable\". These constraints always "
-"come\n"
+"Consider emphasizing \"shared and immutable\" and \"unique and mutable\". These constraints always come\n"
 "together in Rust due to borrow checker rules, and `self` is no exception. It isn't possible to\n"
 "reference a struct from multiple locations and call a mutating (`&mut self`) method on it.\n"
 "  \n"
@@ -5897,9 +5547,7 @@ msgid ""
 msgstr ""
 "<details>\n"
 "  \n"
-" \"공유가능한 불변\"과 \"유일한 가변\" 부분은 강조할 만합니다. 이러한 제약은 러스트의 빌림 검사기"
-"(borrow checker) 규칙으로 늘 붙어다닙니다. `self`도 예외는 아닙니다. 여러 위치에서 구조체를 참조하"
-"면서 객체를 수정하는(`&mut self`를 리시버로 하는) 메서드를 호출하는 것은 불가능합니다.\n"
+" \"공유가능한 불변\"과 \"유일한 가변\" 부분은 강조할 만합니다. 이러한 제약은 러스트의 빌림 검사기(borrow checker) 규칙으로 늘 붙어다닙니다. `self`도 예외는 아닙니다. 여러 위치에서 구조체를 참조하면서 객체를 수정하는(`&mut self`를 리시버로 하는) 메서드를 호출하는 것은 불가능합니다.\n"
 "</details>"
 
 #: src/methods/example.md:1 src/concurrency/shared_state/example.md:1
@@ -5989,28 +5637,19 @@ msgid ""
 "    \n"
 "Key Points:\n"
 "* All four methods here use a different method receiver.\n"
-"  * You can point out how that changes what the function can do with the variable values and if/"
-"how it can be used again in `main`.\n"
+"  * You can point out how that changes what the function can do with the variable values and if/how it can be used again in `main`.\n"
 "  * You can showcase the error that appears when trying to call `finish` twice.\n"
-"* Note that although the method receivers are different, the non-static functions are called the "
-"same way in the main body. Rust enables automatic referencing and dereferencing when calling "
-"methods. Rust automatically adds in the `&`, `*`, `muts` so that that object matches the method "
-"signature.\n"
-"* You might point out that `print_laps` is using a vector that is iterated over. We describe "
-"vectors in more detail in the afternoon. "
+"* Note that although the method receivers are different, the non-static functions are called the same way in the main body. Rust enables automatic referencing and dereferencing when calling methods. Rust automatically adds in the `&`, `*`, `muts` so that that object matches the method signature.\n"
+"* You might point out that `print_laps` is using a vector that is iterated over. We describe vectors in more detail in the afternoon. "
 msgstr ""
 "<details>\n"
 "    \n"
 "키 포인트:\n"
 "* 4가지 유형의 메서드 receiver에 대해 설명합니다.\n"
-"  * receiver 유형에 따라 함수가 할 수 있는 일이 달라지고, 또 메소드를 호출한 뒤 `main`에서 해당 객"
-"체를 사용할 수 있는지 여부도 달라진다는 점을 강조하세요.\n"
+"  * receiver 유형에 따라 함수가 할 수 있는 일이 달라지고, 또 메소드를 호출한 뒤 `main`에서 해당 객체를 사용할 수 있는지 여부도 달라진다는 점을 강조하세요.\n"
 "  * `finish`를 두번 호출하여 오류가 발생하는 것을 보일 수 있습니다.\n"
-"* 비록 메서드 receiver는 다르지만 main 함수에서 비 정적 함수를 부르는 방법은 같습니다.  러스트는 메"
-"서드를 호출할 때 자동으로 참조/역참조(따라가기)를 수행합니다.  러스트는 객체와 매서드 시그니처가 서"
-"로 매치되도록 객체에 `&`, `*`, `muts`를 자동으로 붙여줍니다.\n"
-"* `print_laps`함수에서 벡터를 어떤 식으로 사용하고 있는지 언급하는 것도 좋습니다. 벡터는 오후 강의"
-"에서 더 자세히 설명할 것입니다."
+"* 비록 메서드 receiver는 다르지만 main 함수에서 비 정적 함수를 부르는 방법은 같습니다.  러스트는 메서드를 호출할 때 자동으로 참조/역참조(따라가기)를 수행합니다.  러스트는 객체와 매서드 시그니처가 서로 매치되도록 객체에 `&`, `*`, `muts`를 자동으로 붙여줍니다.\n"
+"* `print_laps`함수에서 벡터를 어떤 식으로 사용하고 있는지 언급하는 것도 좋습니다. 벡터는 오후 강의에서 더 자세히 설명할 것입니다."
 
 #: src/pattern-matching.md:1
 msgid "# Pattern Matching"
@@ -6020,9 +5659,7 @@ msgstr "# 패턴 매칭"
 msgid ""
 "The `match` keyword let you match a value against one or more _patterns_. The\n"
 "comparisons are done from top to bottom and the first match wins."
-msgstr ""
-"`match`키워드는 값을 여러 형태의 _패턴_과 매치시킬 수 있습니다. 맨 위 패턴부터 하나씩 매치되는지 검"
-"사하며, 처음으로 매치되는 패턴이 선택됩니다."
+msgstr "`match`키워드는 값을 여러 형태의 _패턴_과 매치시킬 수 있습니다. 맨 위 패턴부터 하나씩 매치되는지 검사하며, 처음으로 매치되는 패턴이 선택됩니다."
 
 #: src/pattern-matching.md:6
 msgid "The patterns can be simple values, similarly to `switch` in C and C++:"
@@ -6061,11 +5698,9 @@ msgid ""
 "  * `..` can expand as much as it needs to be\n"
 "  * `1..=5` represents an inclusive range\n"
 "  * `_` is a wild card\n"
-"* It can be useful to show how binding works, by for instance replacing a wildcard character with "
-"a variable, or removing the quotes around `q`.\n"
+"* It can be useful to show how binding works, by for instance replacing a wildcard character with a variable, or removing the quotes around `q`.\n"
 "* You can demonstrate matching on a reference.\n"
-"* This might be a good time to bring up the concept of irrefutable patterns, as the term can show "
-"up in error messages.\n"
+"* This might be a good time to bring up the concept of irrefutable patterns, as the term can show up in error messages.\n"
 "   \n"
 "</details>"
 msgstr ""
@@ -6077,11 +5712,9 @@ msgstr ""
 "  * `..`: 필요한 만큼 확장합니다.\n"
 "  * `1..=5`: 끝 값(여기서는 5)을 포함하는 범위를 나타냅니다.\n"
 "  * `_`: 와일드카드입니다.\n"
-"* 와일드카드 문자를 변수로 바꾸거나 `q`의 따옴표를 제거하는 식으로 수정하면서 바인딩이 어떻게 작동"
-"하는지 보여주는 것도 유용할 수 있습니다.\n"
+"* 와일드카드 문자를 변수로 바꾸거나 `q`의 따옴표를 제거하는 식으로 수정하면서 바인딩이 어떻게 작동하는지 보여주는 것도 유용할 수 있습니다.\n"
 "* 참조를 매칭하는 것도 시연할 수 있습니다.\n"
-"* 에러 메시지에 \"반박 불가능 패턴(irrefutable pattern)\"이란 용어가 등장하기도 합니다. 지금 그 의"
-"미를 소개하는 것도 좋을 것 같습니다.\n"
+"* 에러 메시지에 \"반박 불가능 패턴(irrefutable pattern)\"이란 용어가 등장하기도 합니다. 지금 그 의미를 소개하는 것도 좋을 것 같습니다.\n"
 "\n"
 "</details>"
 
@@ -6093,9 +5726,7 @@ msgstr "# 열거형 분해(역구조화)"
 msgid ""
 "Patterns can also be used to bind variables to parts of your values. This is how\n"
 "you inspect the structure of your types. Let us start with a simple `enum` type:"
-msgstr ""
-"구조체나 열거형 값의 일부를 패턴 매치를 통해 변수에 바인딩할 수 있습니다. 간단한 `enum` 타입을 먼"
-"저 살펴보겠습니다."
+msgstr "구조체나 열거형 값의 일부를 패턴 매치를 통해 변수에 바인딩할 수 있습니다. 간단한 `enum` 타입을 먼저 살펴보겠습니다."
 
 #: src/pattern-matching/destructuring-enums.md:6
 msgid ""
@@ -6155,8 +5786,7 @@ msgid ""
 "arm, `half` is bound to the value inside the `Ok` variant. In the second arm,\n"
 "`msg` is bound to the error message."
 msgstr ""
-"`match`구문에서 `divide_in_two`함수에서 반환되는 `Result` 값을 두 개의 팔(혹은 가지)로 _분해"
-"(destructure)_ 하였습니다.\n"
+"`match`구문에서 `divide_in_two`함수에서 반환되는 `Result` 값을 두 개의 팔(혹은 가지)로 _분해(destructure)_ 하였습니다.\n"
 "첫번째 팔에서 `half`는 `Ok` variant에 담긴 값으로 바인딩됩니다.\n"
 "두번째 팔에서 `msg`는 오류 메시지 문자열에 바인딩됩니다."
 
@@ -6164,14 +5794,11 @@ msgstr ""
 msgid ""
 "Key points:\n"
 "* The `if`/`else` expression is returning an enum that is later unpacked with a `match`.\n"
-"* You can try adding a third variant to the enum definition and displaying the errors when running "
-"the code. Point out the places where your code is now inexhaustive and how the compiler tries to "
-"give you hints."
+"* You can try adding a third variant to the enum definition and displaying the 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 ""
 "키 포인트:\n"
 "* `if`/`else` 표현식은 열거형을 반환하고, 이 값은 나중에 `match`로 분해됩니다.\n"
-"* 열거형에 세번째 variant를 추가하고 코드를 실행하여 오류를 표시해보세요. 코드 어느 부분에 누락이 "
-"있는지, 그리고 컴파일러가 어떤 식으로 힌트를 주는지 같이 살펴보세요."
+"* 열거형에 세번째 variant를 추가하고 코드를 실행하여 오류를 표시해보세요. 코드 어느 부분에 누락이 있는지, 그리고 컴파일러가 어떤 식으로 힌트를 주는지 같이 살펴보세요."
 
 #: src/pattern-matching/destructuring-structs.md:1
 msgid "# Destructuring Structs"
@@ -6321,9 +5948,7 @@ msgstr "# 매치 가드"
 msgid ""
 "When matching, you can add a _guard_ to a pattern. This is an arbitrary Boolean\n"
 "expression which will be executed if the pattern matches:"
-msgstr ""
-"패턴 뒤에 가드(guard, 조건식)를 덧붙일 수 있습니다. 가드는 패턴이 매치되면 추가로 따져보는 불리언 "
-"표현식입니다."
+msgstr "패턴 뒤에 가드(guard, 조건식)를 덧붙일 수 있습니다. 가드는 패턴이 매치되면 추가로 따져보는 불리언 표현식입니다."
 
 #: src/pattern-matching/match-guards.md:6
 msgid ""
@@ -6358,23 +5983,17 @@ msgstr ""
 #: src/pattern-matching/match-guards.md:22
 msgid ""
 "Key Points:\n"
-"* Match guards as a separate syntax feature are important and necessary when we wish to concisely "
-"express more complex ideas than patterns alone would allow.\n"
-"* They are not the same as separate `if` expression inside of the match arm. An `if` expression "
-"inside of the branch block (after `=>`) happens after the match arm is selected. Failing the `if` "
-"condition inside of that block won't result in other arms\n"
+"* Match guards as a separate syntax feature are important and necessary when we wish to concisely express more complex ideas than patterns alone would allow.\n"
+"* They are not the same as separate `if` expression inside of the match arm. An `if` expression inside of the branch block (after `=>`) happens after the match arm is selected. Failing the `if` condition inside of that block won't result in other arms\n"
 "of the original `match` expression being considered.  \n"
 "* You can use the variables defined in the pattern in your if expression.\n"
 "* The condition defined in the guard applies to every expression in a pattern with an `|`.\n"
 "</details>"
 msgstr ""
 "키 포인트:\n"
-"* 매치 가드는 별도의 문법 요소로서 패턴 자체만으로 표현하기 어려운 복잡한 경우를 간결하게 표현하고"
-"자 할 때 유용합니다.\n"
-"* 매치의 각 팔(혹은 가지) 안에 따로 `if`를 사용한 것과 다릅니다. 매치 가지의 `=>` 뒤에 사용된 `if` "
-"표현식은 해당\n"
-"  가지가 선택된 다음에 실행됩니다. 따라서 여기서 `if` 조건이 실패하더라도 원래 `match`의 다른 가지"
-"는 고려되지 않습니다.\n"
+"* 매치 가드는 별도의 문법 요소로서 패턴 자체만으로 표현하기 어려운 복잡한 경우를 간결하게 표현하고자 할 때 유용합니다.\n"
+"* 매치의 각 팔(혹은 가지) 안에 따로 `if`를 사용한 것과 다릅니다. 매치 가지의 `=>` 뒤에 사용된 `if` 표현식은 해당\n"
+"  가지가 선택된 다음에 실행됩니다. 따라서 여기서 `if` 조건이 실패하더라도 원래 `match`의 다른 가지는 고려되지 않습니다.\n"
 "* 패턴에 정의된 변수를 가드의 표현식에서 사용할 수 있습니다.\n"
 "* 가드에 정의된 조건은 `|` 를 포함하는 패턴의 모든 표현식에 적용됩니다.\n"
 "</details>"
@@ -6513,8 +6132,7 @@ msgid ""
 "tests pass:"
 msgstr ""
 "우리는 몇개의 꼭지점을 가진 다각형을 표현하는 `Polygon` 구조체를 만들 것입니다.  \n"
-"아래 코드를 <https://play.rust-lang.org/>에 복사해서 테스트가 통과하도록 빠진 메서드를 구현하시면 "
-"됩니다: "
+"아래 코드를 <https://play.rust-lang.org/>에 복사해서 테스트가 통과하도록 빠진 메서드를 구현하시면 됩니다: "
 
 #: src/exercises/day-2/points-polygons.md:7 src/exercises/day-2/luhn.md:23
 #: src/exercises/day-2/strings-iterators.md:12
@@ -6581,14 +6199,16 @@ msgid ""
 "    use super::*;"
 msgstr ""
 
-#: src/exercises/day-2/points-polygons.md:44 src/exercises/day-2/solutions-morning.md:165
+#: src/exercises/day-2/points-polygons.md:44
+#: src/exercises/day-2/solutions-morning.md:165
 msgid ""
 "    fn round_two_digits(x: f64) -> f64 {\n"
 "        (x * 100.0).round() / 100.0\n"
 "    }"
 msgstr ""
 
-#: src/exercises/day-2/points-polygons.md:48 src/exercises/day-2/solutions-morning.md:169
+#: src/exercises/day-2/points-polygons.md:48
+#: src/exercises/day-2/solutions-morning.md:169
 msgid ""
 "    #[test]\n"
 "    fn test_point_magnitude() {\n"
@@ -6597,7 +6217,8 @@ msgid ""
 "    }"
 msgstr ""
 
-#: src/exercises/day-2/points-polygons.md:54 src/exercises/day-2/solutions-morning.md:175
+#: src/exercises/day-2/points-polygons.md:54
+#: src/exercises/day-2/solutions-morning.md:175
 msgid ""
 "    #[test]\n"
 "    fn test_point_dist() {\n"
@@ -6607,7 +6228,8 @@ msgid ""
 "    }"
 msgstr ""
 
-#: src/exercises/day-2/points-polygons.md:61 src/exercises/day-2/solutions-morning.md:182
+#: src/exercises/day-2/points-polygons.md:61
+#: src/exercises/day-2/solutions-morning.md:182
 msgid ""
 "    #[test]\n"
 "    fn test_point_add() {\n"
@@ -6617,7 +6239,8 @@ msgid ""
 "    }"
 msgstr ""
 
-#: src/exercises/day-2/points-polygons.md:68 src/exercises/day-2/solutions-morning.md:189
+#: src/exercises/day-2/points-polygons.md:68
+#: src/exercises/day-2/solutions-morning.md:189
 msgid ""
 "    #[test]\n"
 "    fn test_polygon_left_most_point() {\n"
@@ -6625,7 +6248,8 @@ msgid ""
 "        let p2 = Point::new(16, 16);"
 msgstr ""
 
-#: src/exercises/day-2/points-polygons.md:73 src/exercises/day-2/solutions-morning.md:194
+#: src/exercises/day-2/points-polygons.md:73
+#: src/exercises/day-2/solutions-morning.md:194
 msgid ""
 "        let mut poly = Polygon::new();\n"
 "        poly.add_point(p1);\n"
@@ -6634,7 +6258,8 @@ msgid ""
 "    }"
 msgstr ""
 
-#: src/exercises/day-2/points-polygons.md:79 src/exercises/day-2/solutions-morning.md:200
+#: src/exercises/day-2/points-polygons.md:79
+#: src/exercises/day-2/solutions-morning.md:200
 msgid ""
 "    #[test]\n"
 "    fn test_polygon_iter() {\n"
@@ -6642,14 +6267,16 @@ msgid ""
 "        let p2 = Point::new(16, 16);"
 msgstr ""
 
-#: src/exercises/day-2/points-polygons.md:84 src/exercises/day-2/solutions-morning.md:205
+#: src/exercises/day-2/points-polygons.md:84
+#: src/exercises/day-2/solutions-morning.md:205
 msgid ""
 "        let mut poly = Polygon::new();\n"
 "        poly.add_point(p1);\n"
 "        poly.add_point(p2);"
 msgstr ""
 
-#: src/exercises/day-2/points-polygons.md:88 src/exercises/day-2/solutions-morning.md:209
+#: src/exercises/day-2/points-polygons.md:88
+#: src/exercises/day-2/solutions-morning.md:209
 msgid ""
 "        let points = poly.iter().cloned().collect::<Vec<_>>();\n"
 "        assert_eq!(points, vec![Point::new(12, 13), Point::new(16, 16)]);\n"
@@ -6689,24 +6316,20 @@ msgstr ""
 msgid ""
 "Since the method signatures are missing from the problem statements, the key part\n"
 "of the exercise is to specify those correctly. You don't have to modify the tests."
-msgstr ""
-"누락된 메서드 시그니처를 올바르게 정의하는 것이 문제의 핵심 부분입니다. 테스트는 수정하면 안됩니다."
+msgstr "누락된 메서드 시그니처를 올바르게 정의하는 것이 문제의 핵심 부분입니다. 테스트는 수정하면 안됩니다."
 
 #: src/exercises/day-2/points-polygons.md:120
 msgid ""
 "Other interesting parts of the exercise:\n"
 "    \n"
-"* Derive a `Copy` trait for some structs, as in tests the methods sometimes don't borrow their "
-"arguments.\n"
-"* Discover that `Add` trait must be implemented for two objects to be addable via \"+\". Note that "
-"we do not discuss generics until Day 3."
+"* Derive a `Copy` trait for some structs, as in tests the methods sometimes don't borrow their arguments.\n"
+"* Discover that `Add` trait must be implemented for two objects to be addable via \"+\". Note that we do not discuss generics until Day 3."
 msgstr ""
 "연습문제의 다른 흥미로운 부분:\n"
 "    \n"
 "* 테스트 코드를 보면 어떤 메서드들은 인자를 borrow하는 대신 `Copy` 트레이트를 사용하기도 합니다.\n"
 "  구조체가 `Copy` 트레이트를 상속(derive)하도록 하면 됩니다.\n"
-"* \"+\"를 사용하여 두 객체를 서로 더하려면 `Add` 트레이트를 구현해야 합니다. 이는 3일차에 다룰 내용"
-"입니다."
+"* \"+\"를 사용하여 두 객체를 서로 더하려면 `Add` 트레이트를 구현해야 합니다. 이는 3일차에 다룰 내용입니다."
 
 #: src/control-flow.md:1
 msgid "# Control Flow"
@@ -6718,9 +6341,7 @@ msgid ""
 "evaluate one of two blocks, but the blocks can have a value which then becomes\n"
 "the value of the `if` expression. Other control flow expressions work similarly\n"
 "in Rust."
-msgstr ""
-"앞에서 살펴본 바와 같이 러스트에서 `if`는 표현식입니다. 조건에 따라 두 블록 중 하나를 평가하며, 그 "
-"결과값이 `if` 표현식의 값이 됩니다. 다른 흐름제어 표현식도 유사하게 작동합니다. "
+msgstr "앞에서 살펴본 바와 같이 러스트에서 `if`는 표현식입니다. 조건에 따라 두 블록 중 하나를 평가하며, 그 결과값이 `if` 표현식의 값이 됩니다. 다른 흐름제어 표현식도 유사하게 작동합니다. "
 
 #: src/control-flow/blocks.md:1
 msgid "# Blocks"
@@ -6784,8 +6405,7 @@ msgstr "위의 `main` 함수는 마지막 표현식이 `;`로 끝나기 때문
 msgid ""
 "Key Points:\n"
 "* The point of this slide is to show that blocks have a type and value in Rust. \n"
-"* You can show how the value of the block changes by changing the last line in the block. For "
-"instance, adding/removing a semicolon or using a `return`.\n"
+"* You can show how the value of the block changes by changing the last line in the block. For instance, adding/removing a semicolon or using a `return`.\n"
 "   \n"
 "</details>"
 msgstr ""
@@ -6839,13 +6459,11 @@ msgstr ""
 
 #: src/control-flow/if-expressions.md:31
 msgid ""
-"Because `if` is an expression and must have a particular type, both of its branch blocks must have "
-"the same type. Consider showing what happens if you add `;` after `x / 2` in the second example.\n"
+"Because `if` is an expression and must have a particular type, both of its branch blocks must have the same type. Consider showing what happens if you add `;` after `x / 2` in the second example.\n"
 "    \n"
 "</details>"
 msgstr ""
-"`if`는 표현식이고 타입을 가져야 하므로 분기 블록은 모두 같은 타입을 가져야 합니다. 두번째 예시의 "
-"`x / 2` 뒤에 `;`를 추가하여 어떻게 되는지 확인해 보시기 바랍니다.    \n"
+"`if`는 표현식이고 타입을 가져야 하므로 분기 블록은 모두 같은 타입을 가져야 합니다. 두번째 예시의 `x / 2` 뒤에 `;`를 추가하여 어떻게 되는지 확인해 보시기 바랍니다.    \n"
 "</details>"
 
 #: src/control-flow/if-let-expressions.md:1
@@ -6870,7 +6488,8 @@ msgid ""
 "```"
 msgstr ""
 
-#: src/control-flow/if-let-expressions.md:16 src/control-flow/while-let-expressions.md:21
+#: src/control-flow/if-let-expressions.md:16
+#: src/control-flow/while-let-expressions.md:21
 #: src/control-flow/match-expressions.md:22
 msgid ""
 "See [pattern matching](../pattern-matching.md) for more details on patterns in\n"
@@ -6879,17 +6498,13 @@ msgstr "패턴에 관한 설명은 [패턴 매칭](../pattern-matching.md)을 
 
 #: src/control-flow/if-let-expressions.md:21
 msgid ""
-"* `if let` can be more concise than `match`, e.g., when only one case is interesting. In contrast, "
-"`match` requires all branches to be covered.\n"
-"    * For the similar use case consider demonstrating a newly stabilized [`let else`](https://"
-"github.com/rust-lang/rust/pull/93628) feature.\n"
+"* `if let` can be more concise than `match`, e.g., when only one case is interesting. In contrast, `match` requires all branches to be covered.\n"
+"    * For the similar use case consider demonstrating a newly stabilized [`let else`](https://github.com/rust-lang/rust/pull/93628) feature.\n"
 "* A common usage is handling `Some` values when working with `Option`.\n"
 "* Unlike `match`, `if let` does not support guard clauses for pattern matching."
 msgstr ""
-"* `if let`은 `match`보다 더 간결할 수 있습니다. 예를 들어 특정한 경우만 고려하고 싶더라도 `match`"
-"는 모든 분기를 포함해야 합니다.\n"
-"  * 비슷한 사용례로 새롭게 \"stable\" 릴리즈 된 [`let else`](https://github.com/rust-lang/rust/"
-"pull/93628) 기능을 시연하는 것도 고려해 보시기 바랍니다.\n"
+"* `if let`은 `match`보다 더 간결할 수 있습니다. 예를 들어 특정한 경우만 고려하고 싶더라도 `match`는 모든 분기를 포함해야 합니다.\n"
+"  * 비슷한 사용례로 새롭게 \"stable\" 릴리즈 된 [`let else`](https://github.com/rust-lang/rust/pull/93628) 기능을 시연하는 것도 고려해 보시기 바랍니다.\n"
 "* 일반적으로 `Option`으로 작업할 때 `Some` 값을 처리하는 식으로 사용됩니다.\n"
 "* `match`와 다르게 `if let` 패턴 매칭에서는 가드를 지원하지 않습니다."
 
@@ -6952,15 +6567,12 @@ msgid ""
 "return `None`. The `while let` lets us keep iterating through all items."
 msgstr ""
 "`v.into_iter()`가 반환한 반복자는 `next()`가 호출될 때마다 `Option<i32>`를 반환합니다.\n"
-"반복자가 완료될 때까지는 `Some(x)`를 반환하고 마지막엔 `None`을 반환합니다. `while let`을 통해 반복"
-"자의 모든 아이템을 확인할 수 있습니다."
+"반복자가 완료될 때까지는 `Some(x)`를 반환하고 마지막엔 `None`을 반환합니다. `while let`을 통해 반복자의 모든 아이템을 확인할 수 있습니다."
 
 #: src/control-flow/while-let-expressions.md:27
 msgid ""
 "* Point out that the `while let` loop will keep going as long as the value matches the pattern.\n"
-"* 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 `iter.next()`. The `while let` provides syntactic sugar for the "
-"above scenario.\n"
+"* 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 `iter.next()`. The `while let` provides syntactic sugar for the above scenario.\n"
 "    \n"
 "</details>"
 msgstr ""
@@ -6973,9 +6585,7 @@ msgstr "# `for` 표현식"
 msgid ""
 "The `for` expression is closely related to the `while let` expression. It will\n"
 "automatically call `into_iter()` on the expression and then iterate over it:"
-msgstr ""
-"`for`표현식은 `while let` 표현식과 매우 유사합니다. `for`표현식은 자동으로 `into_iter()`를 호출한 "
-"다음 이를 반복합니다."
+msgstr "`for`표현식은 `while let` 표현식과 매우 유사합니다. `for`표현식은 자동으로 `into_iter()`를 호출한 다음 이를 반복합니다."
 
 #: src/control-flow/for-expressions.md:6
 msgid ""
@@ -7008,16 +6618,14 @@ msgid ""
 "* Index iteration is not a special syntax in Rust for just that case.\n"
 "* `(0..10)` is a range that implements an `Iterator` trait. \n"
 "* `step_by` is a method that returns another `Iterator` that skips every other element. \n"
-"* Modify the elements in the vector and explain the compiler errors. Change vector `v` to be "
-"mutable and the for loop to `for x in v.iter_mut()`."
+"* Modify the elements in the vector and explain the compiler errors. Change vector `v` to be mutable and the for loop to `for x in v.iter_mut()`."
 msgstr ""
 "<details>\n"
 "    \n"
 "* 러스트는 인덱스 반복을 위해 별도의 문법을 사용하지 않습니다. \n"
 "* `(0..10)`은 `Iterator` 트레이트를 구현하는 범위(range) 값입니다. \n"
 "* `step_by`는 반복자의 요소들을 건너뛰는 또다른 `Iterator`를 반환하는 메서드입니다.\n"
-"* 벡터 요소들을 수정하려고 하면 나오는 컴파일러 에러를 같이 살펴보세요. `v` 벡터를 가변 변수로 변경"
-"하고 루프는 `for x in v.iter_mut()`로 수정하세요."
+"* 벡터 요소들을 수정하려고 하면 나오는 컴파일러 에러를 같이 살펴보세요. `v` 벡터를 가변 변수로 변경하고 루프는 `for x in v.iter_mut()`로 수정하세요."
 
 #: src/control-flow/loop-expressions.md:1
 msgid "# `loop` expressions"
@@ -7027,9 +6635,7 @@ msgstr "# `loop` 표현식"
 msgid ""
 "Finally, there is a `loop` keyword which creates an endless loop. Here you must\n"
 "either `break` or `return` to stop the loop:"
-msgstr ""
-"마지막으로 `loop`키워드는 무한 루프를 생성합니다. 따라서 반드시 `break` 또는 `return`을 사용해서 루"
-"프를 정지해야 합니다."
+msgstr "마지막으로 `loop`키워드는 무한 루프를 생성합니다. 따라서 반드시 `break` 또는 `return`을 사용해서 루프를 정지해야 합니다."
 
 #: src/control-flow/loop-expressions.md:6
 msgid ""
@@ -7066,9 +6672,7 @@ msgstr "# `match` 표현식"
 msgid ""
 "The `match` keyword is used to match a value against one or more patterns. In\n"
 "that sense, it works like a series of `if let` expressions:"
-msgstr ""
-"`match`키워드는 어떤 값을 하나 이상의 패턴에 대해 매치하는데 사용합니다. 그런 면에서 `if let` 표현"
-"식을 여러개 이어 놓은 것과 같습니다."
+msgstr "`match`키워드는 어떤 값을 하나 이상의 패턴에 대해 매치하는데 사용합니다. 그런 면에서 `if let` 표현식을 여러개 이어 놓은 것과 같습니다."
 
 #: src/control-flow/match-expressions.md:6
 msgid ""
@@ -7090,18 +6694,14 @@ msgstr ""
 msgid ""
 "Like `if let`, each match arm must have the same type. The type is the last\n"
 "expression of the block, if any. In the example above, the type is `()`."
-msgstr ""
-"`if let`과 마찬가지로 매치의 모든 팔(arm)은 같은 타입이어야 합니다. 팔이 블록이라면 블록의 마지막 "
-"표현식이 그 타입이 됩니다. 위의 예제에서 매치 표현식의 타입은 `()`입니다."
+msgstr "`if let`과 마찬가지로 매치의 모든 팔(arm)은 같은 타입이어야 합니다. 팔이 블록이라면 블록의 마지막 표현식이 그 타입이 됩니다. 위의 예제에서 매치 표현식의 타입은 `()`입니다."
 
 #: src/control-flow/match-expressions.md:27
 msgid ""
 "* Save the match expression to a variable and print it out.\n"
 "* Remove `.as_deref()` and explain the error.\n"
-"    * `std::env::args().next()` returns an `Option<String>`, but we cannot match against "
-"`String`.\n"
-"    * `as_deref()` transforms an `Option<T>` to `Option<&T::Target>`. In our case, this turns "
-"`Option<String>` into `Option<&str>`.\n"
+"    * `std::env::args().next()` returns an `Option<String>`, but we cannot match against `String`.\n"
+"    * `as_deref()` transforms an `Option<T>` to `Option<&T::Target>`. In our case, this turns `Option<String>` into `Option<&str>`.\n"
 "    * We can now use pattern matching to match against the `&str` inside `Option`.\n"
 "</details>"
 msgstr ""
@@ -7115,9 +6715,7 @@ msgid ""
 "If you want to exit a loop early, use `break`, if you want to immediately start\n"
 "the next iteration use `continue`. Both `continue` and `break` can optionally\n"
 "take a label argument which is used to break out of nested loops:"
-msgstr ""
-"루프를 빠져나가려면 `break`를, 다음 반복으로 넘어가기 위해서는 `continue`를 사용합니다. 중첩 루프에"
-"서는 레이블과 함께 사용할 수 있습니다."
+msgstr "루프를 빠져나가려면 `break`를, 다음 반복으로 넘어가기 위해서는 `continue`를 사용합니다. 중첩 루프에서는 레이블과 함께 사용할 수 있습니다."
 
 #: src/control-flow/break-continue.md:7
 msgid ""
@@ -7153,10 +6751,7 @@ msgid ""
 "Rust comes with a standard library which helps establish a set of common types\n"
 "used by Rust library and programs. This way, two libraries can work together\n"
 "smoothly because they both use the same `String` type."
-msgstr ""
-"러스트에서 제공하는 표준 라이브러리는 러스트로 라이브러리나 프로그램을 작성할 때 공통적으로 사용할 "
-"수 있는 여러 타입들을 포함하고 있습니다. 이를 통해 서로 다른 두 라이브러리라 하더라도 함께 사용하는"
-"데 큰 어려움이 없게 됩니다. 예를 들면 두 라이브러리 모두 같은 `String` 타입을 사용하기 때문입니다."
+msgstr "러스트에서 제공하는 표준 라이브러리는 러스트로 라이브러리나 프로그램을 작성할 때 공통적으로 사용할 수 있는 여러 타입들을 포함하고 있습니다. 이를 통해 서로 다른 두 라이브러리라 하더라도 함께 사용하는데 큰 어려움이 없게 됩니다. 예를 들면 두 라이브러리 모두 같은 `String` 타입을 사용하기 때문입니다."
 
 #: src/std.md:7
 msgid "The common vocabulary types include:"
@@ -7166,14 +6761,11 @@ msgstr "일반적인 타입은 아래와 같습니다:"
 msgid ""
 "* [`Option` and `Result`](std/option-result.md) types: used for optional values\n"
 "  and [error handling](error-handling.md)."
-msgstr ""
-"* [`Option`과 `Result`](std/option-result.md) : 어떤 값이 있거나 없거나 하는 경우, 그리고 [오류 처"
-"리](error-handling.md)에 사용합니다."
+msgstr "* [`Option`과 `Result`](std/option-result.md) : 어떤 값이 있거나 없거나 하는 경우, 그리고 [오류 처리](error-handling.md)에 사용합니다."
 
 #: src/std.md:12
 msgid "* [`String`](std/string.md): the default string type used for owned data."
-msgstr ""
-"* [`String`](std/string.md): 기본적인 문자열 타입으로, 문자열 데이터를 소유하는 경우에 사용합니다."
+msgstr "* [`String`](std/string.md): 기본적인 문자열 타입으로, 문자열 데이터를 소유하는 경우에 사용합니다."
 
 #: src/std.md:14
 msgid "* [`Vec`](std/vec.md): a standard extensible vector."
@@ -7206,8 +6798,7 @@ msgstr ""
 "<details>\n"
 "  \n"
 "  * 사실, 러스트의 표준 라이브러리는 `core`, `alloc`, `std`와 같이 계층(layer)으로 나눠집니다. \n"
-"  * `core`는 `libc`나 할당자(allocator), 심지어 OS에도 의존하지 않는 가장  기본적인 함수와 타입을 "
-"포함합니다.\n"
+"  * `core`는 `libc`나 할당자(allocator), 심지어 OS에도 의존하지 않는 가장  기본적인 함수와 타입을 포함합니다.\n"
 "  * `alloc`은 `Vec`, `Box`, `Arc`와 같이 전역 힙 할당이 필요한 타입을 포함합니다.\n"
 "  * 임베디드 러스트 응용프로그램은 주로 `core`만 사용하거나 가끔 `alloc`을 함께 사용합니다."
 
@@ -7371,13 +6962,10 @@ msgstr ""
 
 #: src/std/vec.md:37
 msgid ""
-"* `Vec` is a type of collection, along with `String` and `HashMap`. The data it contains is "
-"stored\n"
-"  on the heap. This means the amount of data doesn't need to be  known at compile time. It can "
-"grow\n"
+"* `Vec` is a type of collection, along with `String` and `HashMap`. The data it contains is stored\n"
+"  on the heap. This means the amount of data doesn't need to be  known at compile time. It can grow\n"
 "  or shrink at runtime.\n"
-"* Notice how `Vec<T>` is a generic type too, but you don't have to specify `T` explicitly. As "
-"always\n"
+"* Notice how `Vec<T>` is a generic type too, but you don't have to specify `T` explicitly. As always\n"
 "  with Rust type inference, the `T` was established during the first `push` call.\n"
 "* `vec![...]` is a canonical macro to use instead of `Vec::new()` and it supports adding initial\n"
 "  elements to the vector.\n"
@@ -7447,9 +7035,7 @@ msgstr ""
 #: src/std/hashmap.md:38
 msgid ""
 "* `HashMap` is not defined in the prelude and needs to be brought into scope.\n"
-"* Try the following lines of code. The first line will see if a book is in the hashmap and if not "
-"return an alternative value. The second line will insert the alternative value in the hashmap if "
-"the book is not found."
+"* Try the following lines of code. The first line will see if a book is in the hashmap and if not return an alternative value. The second line will insert the alternative value in the hashmap if the book is not found."
 msgstr ""
 
 #: src/std/hashmap.md:41
@@ -7463,8 +7049,7 @@ msgid ""
 "      .or_insert(374);\n"
 "  ```\n"
 "* Unlike `vec!`, there is unfortunately no standard `hashmap!` macro.\n"
-"  * Although, since Rust 1.56, HashMap implements [`From<[(K, V); N]>`][1], which allows us to "
-"easily initialize a hash map from a literal array:"
+"  * Although, since Rust 1.56, HashMap implements [`From<[(K, V); N]>`][1], which allows us to easily initialize a hash map from a literal array:"
 msgstr ""
 
 #: src/std/hashmap.md:52
@@ -7480,17 +7065,13 @@ msgstr ""
 #: src/std/hashmap.md:59
 msgid ""
 " * Alternatively HashMap can be built from any `Iterator` which yields key-value tuples.\n"
-"* We are showing `HashMap<String, i32>`, and avoid using `&str` as key to make examples easier. "
-"Using references in collections can, of course, be done,\n"
+"* We are showing `HashMap<String, i32>`, and avoid using `&str` as key to make examples easier. Using references in collections can, of course, be done,\n"
 "  but it can lead into complications with the borrow checker.\n"
-"  * Try removing `to_string()` from the example above and see if it still compiles. Where do you "
-"think we might run into issues?"
+"  * Try removing `to_string()` from the example above and see if it still compiles. Where do you think we might run into issues?"
 msgstr ""
 
 #: src/std/hashmap.md:64
-msgid ""
-"[1]: https://doc.rust-lang.org/std/collections/hash_map/struct.HashMap.html#impl-"
-"From%3C%5B(K%2C%20V)%3B%20N%5D%3E-for-HashMap%3CK%2C%20V%2C%20RandomState%3E"
+msgid "[1]: https://doc.rust-lang.org/std/collections/hash_map/struct.HashMap.html#impl-From%3C%5B(K%2C%20V)%3B%20N%5D%3E-for-HashMap%3CK%2C%20V%2C%20RandomState%3E"
 msgstr ""
 
 #: src/std/box.md:1
@@ -7544,13 +7125,10 @@ msgstr ""
 #: src/std/box.md:34
 msgid ""
 "* `Box` is like `std::unique_ptr` in C++. \n"
-"* In the above example, you can even leave out the `*` in the `println!` statement thanks to "
-"`Deref`. \n"
+"* In the above example, you can even leave out the `*` in the `println!` statement thanks to `Deref`. \n"
 "* A `Box` can be useful when you:\n"
-"   * have a type whose size that can't be known at compile time, but the Rust compiler wants to "
-"know an exact size.\n"
-"   * want to transfer ownership of a large amount of data. To avoid copying large amounts of data "
-"on the stack, instead store the data on the heap in a `Box` so only the pointer is moved.\n"
+"   * have a type whose size that can't be known at compile time, but the Rust compiler wants to know an exact size.\n"
+"   * want to transfer ownership of a large amount of data. To avoid copying large amounts of data on the stack, instead store the data on the heap in a `Box` so only the pointer is moved.\n"
 "</details>"
 msgstr ""
 
@@ -7601,30 +7179,21 @@ msgstr ""
 msgid ""
 "* If the `Box` was not used here and we attempted to embed a `List` directly into the `List`,\n"
 "the compiler would not compute a fixed size of the struct in memory, it would look infinite."
-msgstr ""
-"* 만일 `Box`를 사용하지 않고 `List`에 직접 `List`를 포함하려고 시도한다면, 컴파일러는 구조체의 고"
-"정 크기를 계산할 수 없습니다. 컴파일러가 보기에 무한대의 크기로 보일 것입니다."
+msgstr "* 만일 `Box`를 사용하지 않고 `List`에 직접 `List`를 포함하려고 시도한다면, 컴파일러는 구조체의 고정 크기를 계산할 수 없습니다. 컴파일러가 보기에 무한대의 크기로 보일 것입니다."
 
 #: src/std/box-recursive.md:36
 msgid ""
-"* `Box` solves this problem as it has the same size as a regular pointer and just points at the "
-"next\n"
+"* `Box` solves this problem as it has the same size as a regular pointer and just points at the next\n"
 "element of the `List` in the heap."
-msgstr ""
-"* `Box`는 일반 포인터와 크기가 같기 때문에 크기를 계산하는 데 문제가 없습니다. 다만 힙에 위치한 "
-"`List`의 다음 요소를 가리킬 뿐입니다."
+msgstr "* `Box`는 일반 포인터와 크기가 같기 때문에 크기를 계산하는 데 문제가 없습니다. 다만 힙에 위치한 `List`의 다음 요소를 가리킬 뿐입니다."
 
 #: src/std/box-recursive.md:39
 msgid ""
-"* Remove the `Box` in the List definition and show the compiler error. \"Recursive with "
-"indirection\" is a hint you might want to use a Box or reference of some kind, instead of storing "
-"a value directly.   \n"
+"* Remove the `Box` in the List definition and show the compiler error. \"Recursive with indirection\" is a hint you might want to use a Box or reference of some kind, instead of storing a value directly.   \n"
 "    \n"
 "</details>"
 msgstr ""
-"* `List` 정의에서 `Box`를 제거하면 어떤 컴파일러 에러가 나오는지 같이 살펴보세요. “Recursive with "
-"indirection”라는 메시지를 보면, 값을 직접 저장하는 대신 `Box`나 비슷한 다른 종류의 참조 타입이 필요"
-"하다는 힌트를 얻을 수 있습니다.\n"
+"* `List` 정의에서 `Box`를 제거하면 어떤 컴파일러 에러가 나오는지 같이 살펴보세요. “Recursive with indirection”라는 메시지를 보면, 값을 직접 저장하는 대신 `Box`나 비슷한 다른 종류의 참조 타입이 필요하다는 힌트를 얻을 수 있습니다.\n"
 "    \n"
 "</details>"
 
@@ -7636,9 +7205,7 @@ msgstr "# 틈새 최적화(Niche Optimization)"
 msgid ""
 "A `Box` cannot be empty, so the pointer is always valid and non-`null`. This\n"
 "allows the compiler to optimize the memory layout:"
-msgstr ""
-"`Box`는 비어있을 수 없습니다. 따라서 포인터는 항상 유효하며 `null`이 아닙니다. 이는 컴파일러가 메모"
-"리 레이아웃을 최적화 할 수 있게 해줍니다."
+msgstr "`Box`는 비어있을 수 없습니다. 따라서 포인터는 항상 유효하며 `null`이 아닙니다. 이는 컴파일러가 메모리 레이아웃을 최적화 할 수 있게 해줍니다."
 
 #: src/std/box-niche.md:19
 msgid ""
@@ -7691,8 +7258,7 @@ msgid ""
 msgstr ""
 "* `Rc`내부의 데이터를 변경해야 하는 경우, 데이터를 [`Cell` 또는 `RefCell`][2]로 래핑해야합니다.\n"
 "* 멀티스레드인 경우 [`Arc`][3]를 참조하시기 바랍니다.\n"
-"* drop 가능한 순환 구조를 만들기 위해 공유 포인터를 [`Weak`][4] 포인터로 **다운그레이드**할 수도 있"
-"습니다."
+"* drop 가능한 순환 구조를 만들기 위해 공유 포인터를 [`Weak`][4] 포인터로 **다운그레이드**할 수도 있습니다."
 
 #: src/std/rc.md:24
 msgid ""
@@ -7710,18 +7276,15 @@ msgstr ""
 msgid ""
 "* Like C++'s `std::shared_ptr`.\n"
 "* `clone` is cheap: creates a pointer to the same allocation and increases the reference count.\n"
-"* `make_mut` actually clones the inner value if necessary (\"clone-on-write\") and returns a "
-"mutable reference.\n"
+"* `make_mut` actually clones the inner value if necessary (\"clone-on-write\") and returns a mutable reference.\n"
 "* You can `downgrade()` a `Rc` into a *weakly reference-counted* object to\n"
 "  create cycles that will be dropped properly (likely in combination with\n"
 "  `RefCell`)."
 msgstr ""
 "* C++의 `std::shared_ptr`와 유사합니다.\n"
 "* `clone`은 저렴합니다. 동일한 할당에 대한 포인터를 생성하고 참조 카운트를 늘림니다.\n"
-"* `make_mut`는 실제로 필요한 경우에 내부 값을 복제하고( (\"clone-on-write\") ) 가변 참조를 반환합니"
-"다.\n"
-"* `Rc`는 `downgrade()`로 다운그레이드하여 **weak 참조 카운트**로 변경할 수 있습니다. 그러면 순환구"
-"조라 하더라도 drop이 가능합니다. (아마도 `RefCell` 을 함께 사용해야 할 것입니다.)"
+"* `make_mut`는 실제로 필요한 경우에 내부 값을 복제하고( (\"clone-on-write\") ) 가변 참조를 반환합니다.\n"
+"* `Rc`는 `downgrade()`로 다운그레이드하여 **weak 참조 카운트**로 변경할 수 있습니다. 그러면 순환구조라 하더라도 drop이 가능합니다. (아마도 `RefCell` 을 함께 사용해야 할 것입니다.)"
 
 #: src/std/rc.md:38
 msgid ""
@@ -7808,10 +7371,8 @@ msgstr ""
 
 #: src/modules.md:28
 msgid ""
-"* Packages provide functionality and include a `Cargo.toml` file that describes how to build a "
-"bundle of 1+ crates.\n"
-"* Crates are a tree of modules, where a binary crate creates an executable and a library crate "
-"compiles to a library.\n"
+"* Packages provide functionality and include a `Cargo.toml` file that describes how to build a bundle of 1+ crates.\n"
+"* Crates are a tree of modules, where a binary crate creates an executable and a library crate compiles to a library.\n"
 "* Modules define organization, scope, and are the focus of this section."
 msgstr ""
 
@@ -7881,14 +7442,12 @@ msgid "* Use the `pub` keyword to make modules public."
 msgstr ""
 
 #: src/modules/visibility.md:41
-msgid ""
-"Additionally, there are advanced `pub(...)` specifiers to restrict the scope of public visibility."
+msgid "Additionally, there are advanced `pub(...)` specifiers to restrict the scope of public visibility."
 msgstr ""
 
 #: src/modules/visibility.md:43
 msgid ""
-"* See the [Rust Reference](https://doc.rust-lang.org/reference/visibility-and-privacy.html#pubin-"
-"path-pubcrate-pubsuper-and-pubself)).\n"
+"* See the [Rust Reference](https://doc.rust-lang.org/reference/visibility-and-privacy.html#pubin-path-pubcrate-pubsuper-and-pubself)).\n"
 "* Configuring `pub(crate)` visibility is a common pattern.\n"
 "* Less commonly, you can give visibility to a specific path.\n"
 "* In any case, visibility must be granted to an ancestor module (and all of its descendants)."
@@ -7969,8 +7528,7 @@ msgstr ""
 
 #: src/modules/filesystem.md:26
 msgid ""
-"* The change from `module/mod.rs` to `module.rs` doesn't preclude the use of submodules in Rust "
-"2018.\n"
+"* The change from `module/mod.rs` to `module.rs` doesn't preclude the use of submodules in Rust 2018.\n"
 "  (It was mandatory in Rust 2015.)"
 msgstr ""
 
@@ -8033,10 +7591,8 @@ msgid ""
 "validate credit card numbers. The algorithm takes a string as input and does the\n"
 "following to validate the credit card number:"
 msgstr ""
-"[룬(Luhn) 알고리즘](https://ko.wikipedia.org/wiki/%EB%A3%AC_%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98)"
-"은 신용카드 번호 검증에 사용되는 알고리즘 입니다. \n"
-"이 알고리즘은 신용카드 번호를 `문자열`로 입력받고, 아래의 순서에 따라 신용카드 번호의 유효성을 확인"
-"합니다:"
+"[룬(Luhn) 알고리즘](https://ko.wikipedia.org/wiki/%EB%A3%AC_%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98)은 신용카드 번호 검증에 사용되는 알고리즘 입니다. \n"
+"이 알고리즘은 신용카드 번호를 `문자열`로 입력받고, 아래의 순서에 따라 신용카드 번호의 유효성을 확인합니다:"
 
 #: src/exercises/day-2/luhn.md:7
 msgid "* Ignore all spaces. Reject number with less than two digits."
@@ -8046,17 +7602,13 @@ msgstr "* 모든 공백을 무시합니다. 2자리 미만 숫자는 무시합
 msgid ""
 "* Moving from right to left, double every second digit: for the number `1234`,\n"
 "  we double `3` and `1`."
-msgstr ""
-"* 오른쪽에서 왼쪽으로 이동하며 2번째 자리마다 숫자를 2배 증가시킵니다. 예를 들어 `1234`에서 3과 1"
-"을 두배로 만듭니다.(2464)"
+msgstr "* 오른쪽에서 왼쪽으로 이동하며 2번째 자리마다 숫자를 2배 증가시킵니다. 예를 들어 `1234`에서 3과 1을 두배로 만듭니다.(2464)"
 
 #: src/exercises/day-2/luhn.md:12
 msgid ""
 "* After doubling a digit, sum the digits. So doubling `7` becomes `14` which\n"
 "  becomes `5`."
-msgstr ""
-"* 두배로 만든 숫자가 2자리라면 각 자리 숫자를 더합니다. 예를 들어, `7`은 두배로 만들면 `14`이므로 "
-"`5`가 됩니다."
+msgstr "* 두배로 만든 숫자가 2자리라면 각 자리 숫자를 더합니다. 예를 들어, `7`은 두배로 만들면 `14`이므로 `5`가 됩니다."
 
 #: src/exercises/day-2/luhn.md:15
 msgid "* Sum all the undoubled and doubled digits."
@@ -8146,16 +7698,13 @@ msgid ""
 "matches a full segment. See the unit tests below."
 msgstr ""
 "이번 훈련은 웹 서버의 라우팅 컴포넌트를 구현합니다. \n"
-"서버는 _요청 경로(request path)_ 를 처리할 수 있는 여러 개의 _경로 접두사(path prefix)_ 로 구성됩니"
-"다. 경로 접두사는 와일드카드문자를 포함할 수 있습니다.  아래 단위 테스트 코드를 참조하세요."
+"서버는 _요청 경로(request path)_ 를 처리할 수 있는 여러 개의 _경로 접두사(path prefix)_ 로 구성됩니다. 경로 접두사는 와일드카드문자를 포함할 수 있습니다.  아래 단위 테스트 코드를 참조하세요."
 
 #: src/exercises/day-2/strings-iterators.md:8
 msgid ""
 "Copy the following code to <https://play.rust-lang.org/> and make the tests\n"
 "pass. Try avoiding allocating a `Vec` for your intermediate results:"
-msgstr ""
-"아래 코드를 <https://play.rust-lang.org/>에 복사하고 테스트를 통과해 보시기 바랍니다. 중간 결과값"
-"을 `Vec`에 할당하지 않도록 주의 하시기 바랍니다."
+msgstr "아래 코드를 <https://play.rust-lang.org/>에 복사하고 테스트를 통과해 보시기 바랍니다. 중간 결과값을 `Vec`에 할당하지 않도록 주의 하시기 바랍니다."
 
 #: src/exercises/day-2/strings-iterators.md:16
 msgid ""
@@ -8173,7 +7722,8 @@ msgid ""
 "    assert!(prefix_matches(\"/v1/publishers\", \"/v1/publishers/abc/books\"));"
 msgstr ""
 
-#: src/exercises/day-2/strings-iterators.md:26 src/exercises/day-2/solutions-afternoon.md:146
+#: src/exercises/day-2/strings-iterators.md:26
+#: src/exercises/day-2/solutions-afternoon.md:146
 msgid ""
 "    assert!(!prefix_matches(\"/v1/publishers\", \"/v1\"));\n"
 "    assert!(!prefix_matches(\"/v1/publishers\", \"/v1/publishersBooks\"));\n"
@@ -8181,7 +7731,8 @@ msgid ""
 "}"
 msgstr ""
 
-#: src/exercises/day-2/strings-iterators.md:31 src/exercises/day-2/solutions-afternoon.md:151
+#: src/exercises/day-2/strings-iterators.md:31
+#: src/exercises/day-2/solutions-afternoon.md:151
 msgid ""
 "#[test]\n"
 "fn test_matches_with_wildcard() {\n"
@@ -8305,22 +7856,13 @@ msgstr ""
 
 #: src/traits.md:41
 msgid ""
-"* Traits may specify pre-implemented (default) methods and methods that users are required to "
-"implement themselves. Methods with default implementations can rely on required methods.\n"
-"* Types that implement a given trait may be of different sizes. This makes it impossible to have "
-"things like `Vec<Greet>` in the example above.\n"
-"* `dyn Greet` is a way to tell the compiler about a dynamically sized type that implements "
-"`Greet`.\n"
-"* In the example, `pets` holds Fat Pointers to objects that implement `Greet`. The Fat Pointer "
-"consists of two components, a pointer to the actual object and a pointer to the virtual method "
-"table for the `Greet` implementation of that particular object."
+"* Traits may specify pre-implemented (default) methods and methods that users are required to implement themselves. Methods with default implementations can rely on required methods.\n"
+"* Types that implement a given trait may be of different sizes. This makes it impossible to have things like `Vec<Greet>` in the example above.\n"
+"* `dyn Greet` is a way to tell the compiler about a dynamically sized type that implements `Greet`.\n"
+"* In the example, `pets` holds Fat Pointers to objects that implement `Greet`. The Fat Pointer consists of two components, a pointer to the actual object and a pointer to the virtual method table for the `Greet` implementation of that particular object."
 msgstr ""
-"* 트레이트는 사용자가 직접 구현해야 하는 메서드와 사전 구현된(디폴트) 메서드를 지정할 수 있습니다. "
-"기본 구현된 메서드는 (다른)필수 메서드를 의존할 수 있습니다.\n"
-"* 여러 타입이 같은 트레이트를 구현하더라도 그 크기는 서로 다를 수 있습니다. 그래서 `Vec<Greeet>`같"
-"은 것은 불가능합니다. 왜냐하면 `Greet`트레이트를 구현하는 타입들 중 어떤 크기의 타입이 실제로 사용"
-"될 지, 컴파일 시에 알 방법이 없는 반면, `Vec<>`는 타입의 크기를 컴파일 시에 알고자 하기 때문입니"
-"다.\n"
+"* 트레이트는 사용자가 직접 구현해야 하는 메서드와 사전 구현된(디폴트) 메서드를 지정할 수 있습니다. 기본 구현된 메서드는 (다른)필수 메서드를 의존할 수 있습니다.\n"
+"* 여러 타입이 같은 트레이트를 구현하더라도 그 크기는 서로 다를 수 있습니다. 그래서 `Vec<Greeet>`같은 것은 불가능합니다. 왜냐하면 `Greet`트레이트를 구현하는 타입들 중 어떤 크기의 타입이 실제로 사용될 지, 컴파일 시에 알 방법이 없는 반면, `Vec<>`는 타입의 크기를 컴파일 시에 알고자 하기 때문입니다.\n"
 "* `dyn Greet`는 `Greet`을 구현하는, 가변 크기의 타입을 의미합니다."
 
 #: src/traits.md:46
@@ -8347,9 +7889,7 @@ msgstr "# 트레이트 상속하기(Deriving Traits)"
 
 #: src/traits/deriving-traits.md:3
 msgid "You can let the compiler derive a number of traits:"
-msgstr ""
-"컴파일러가 여러가지 트레이트를 상속(derive)하도록 할 수 있습니다. 이 경우 컴파일러가 트레이트를 자"
-"동으로 구현합니다."
+msgstr "컴파일러가 여러가지 트레이트를 상속(derive)하도록 할 수 있습니다. 이 경우 컴파일러가 트레이트를 자동으로 구현합니다."
 
 #: src/traits/deriving-traits.md:5
 msgid ""
@@ -8503,23 +8043,18 @@ msgstr ""
 
 #: src/traits/iterator.md:32
 msgid ""
-"* `IntoIterator` is the trait that makes for loops work. It is implemented by collection types "
-"such as\n"
+"* `IntoIterator` is the trait that makes for loops work. It is implemented by collection types such as\n"
 "  `Vec<T>` and references to them such as `&Vec<T>` and `&[T]`. Ranges also implement it.\n"
 "* The `Iterator` trait implements many common functional programming operations over collections \n"
-"  (e.g. `map`, `filter`, `reduce`, etc). This is the trait where you can find all the "
-"documentation\n"
-"  about them. In Rust these functions should produce the code as efficient as equivalent "
-"imperative\n"
+"  (e.g. `map`, `filter`, `reduce`, etc). This is the trait where you can find all the documentation\n"
+"  about them. In Rust these functions should produce the code as efficient as equivalent imperative\n"
 "  implementations.\n"
 "    \n"
 "</details>"
 msgstr ""
 "* `IntoIterator`는 루프가 작동하도록 만드는 트레이트입니다.\n"
-"  `Vec<T>`와 같은 컬렉션 타입과 그에 대한 참조 타입(`&Vec<T>`, `&[T]`)들 모두 이 트레이트를 구현합"
-"니다. Range 역시 이를 구현합니다.\n"
-"* `Iterator` 트레이트는 컬렉션에 대해 다양한 함수형 프로그래밍 연산 (`map`, `filter`, `reduce` 등)"
-"을 구현합니다. \n"
+"  `Vec<T>`와 같은 컬렉션 타입과 그에 대한 참조 타입(`&Vec<T>`, `&[T]`)들 모두 이 트레이트를 구현합니다. Range 역시 이를 구현합니다.\n"
+"* `Iterator` 트레이트는 컬렉션에 대해 다양한 함수형 프로그래밍 연산 (`map`, `filter`, `reduce` 등)을 구현합니다. \n"
 "이 연산들에 대한 자세한 설명은 `Iterator` 트레이트의 API 레퍼런스에서 찾을 수 있습니다.\n"
 "러스트에서 이러한 함수형 연산들은 절차형으로 구현된 코드와 동일한 성능을 보여줍니다.\n"
 "    \n"
@@ -8535,9 +8070,7 @@ msgstr "# FromIterator"
 
 #: src/traits/from-iterator.md:3
 msgid "[`FromIterator`][1] lets you build a collection from an [`Iterator`][2]."
-msgstr ""
-"어떤 컬렉션이 `[FromIterator`][1]를 구현하고 있다면 [`Iterator`][2]로부터 그 컬렉션을 만들 수 있습"
-"니다."
+msgstr "어떤 컬렉션이 `[FromIterator`][1]를 구현하고 있다면 [`Iterator`][2]로부터 그 컬렉션을 만들 수 있습니다."
 
 #: src/traits/from-iterator.md:5
 msgid ""
@@ -8572,8 +8105,7 @@ msgstr ""
 msgid ""
 "There are also implementations which let you do cool things like convert an\n"
 "`Iterator<Item = Result<V, E>>` into a `Result<Vec<V>, E>`."
-msgstr ""
-"이는 또한 `Iterator<Item = Result<V, E>>`을 `Result<Vec<V>, E>`로 변경하는 멋진 작업도 구현합니다."
+msgstr "이는 또한 `Iterator<Item = Result<V, E>>`을 `Result<Vec<V>, E>`로 변경하는 멋진 작업도 구현합니다."
 
 #: src/traits/from-iterator.md:28
 msgid ""
@@ -8625,10 +8157,8 @@ msgstr ""
 msgid ""
 "<details>\n"
 "  \n"
-"* That's why it is common to only implement `From`, as your type will get `Into` implementation "
-"too.\n"
-"* When declaring a function argument input type like \"anything that can be converted into a "
-"`String`\", the rule is opposite, you should use `Into`.\n"
+"* That's why it is common to only implement `From`, as your type will get `Into` implementation too.\n"
+"* When declaring a function argument input type like \"anything that can be converted into a `String`\", the rule is opposite, you should use `Into`.\n"
 "  Your function will accept types that implement `From` and those that _only_ implement `Into`.\n"
 "    \n"
 "</details>"
@@ -8636,9 +8166,7 @@ msgstr ""
 "<details>\n"
 "  \n"
 "* 그렇기 때문에 사용자 정의 타입의 경우에도 `From` 만 구현하는 것이 일반적입니다.\n"
-"* \"`String`으로 변환할 수 있는 모든 것\"과 같은 함수의 인수 타입을 선언할 때에는 `Into`를 사용해"
-"야 함을 조심하세요. 그래야만, 함수는 `From`을 구현한 타입과 `Into` _만_ 구현한 타입 모두를 인자로 "
-"받을 수 있습니다.\n"
+"* \"`String`으로 변환할 수 있는 모든 것\"과 같은 함수의 인수 타입을 선언할 때에는 `Into`를 사용해야 함을 조심하세요. 그래야만, 함수는 `From`을 구현한 타입과 `Into` _만_ 구현한 타입 모두를 인자로 받을 수 있습니다.\n"
 "    \n"
 "</details>"
 
@@ -8784,12 +8312,9 @@ msgid ""
 "        trait."
 msgstr ""
 "* `&Point`가 `Add`를 구현하도록 할 수도 있습니다. 이게 어떤 경우에 유용할까요?\n"
-"  * 답: `Add:add`는 `self`를 소모합니다. 만약 타입 `T`가 `Copy`트레이트를 구현하고 있지 않다면 `&T`"
-"에 대해서도 연산자 오버로딩을 고려해야 합니다. 이렇게 하면 호출부에서 불필요한 복사를 피할 수 있습"
-"니다.\n"
+"  * 답: `Add:add`는 `self`를 소모합니다. 만약 타입 `T`가 `Copy`트레이트를 구현하고 있지 않다면 `&T`에 대해서도 연산자 오버로딩을 고려해야 합니다. 이렇게 하면 호출부에서 불필요한 복사를 피할 수 있습니다.\n"
 "* 왜 `Output`이 연관된 타입인가요? 타입 파라메터로 만들 수 있을까요?\n"
-"  * 답: 타입 파라메터를 호출하는 쪽에서 결정합니다. 반면 연관된 타입(`Output`같은) 은 트레이트를 구"
-"현하는 쪽에서 제어 가능합니다."
+"  * 답: 타입 파라메터를 호출하는 쪽에서 결정합니다. 반면 연관된 타입(`Output`같은) 은 트레이트를 구현하는 쪽에서 제어 가능합니다."
 
 #: src/traits/operators.md:40
 msgid "[1]: https://doc.rust-lang.org/std/ops/index.html"
@@ -8801,8 +8326,7 @@ msgstr "# `Drop` 트레이트"
 
 #: src/traits/drop.md:3
 msgid "Values which implement [`Drop`][1] can specify code to run when they go out of scope:"
-msgstr ""
-"[`Drop`][1]트레이트를 구현하면, 그 값이 스코프 밖으로 나갈 때 실행될 코드를 작성할 수 있습니다:"
+msgstr "[`Drop`][1]트레이트를 구현하면, 그 값이 스코프 밖으로 나갈 때 실행될 코드를 작성할 수 있습니다:"
 
 #: src/traits/drop.md:5
 msgid ""
@@ -8849,8 +8373,7 @@ msgid ""
 "* Try replacing `drop(a)` with `a.drop()`."
 msgstr ""
 "* `Drop::drop`은 왜 `self`를 인자로 받지 않습니까?\n"
-"  * 짧은 대답: 만약 그렇게 된다면 `std::mem::drop`이 블록의 끝에서 호출되고, 다시 `Drop::drop`을 호"
-"출하게되 스택 오버플로가 발생합니다.\n"
+"  * 짧은 대답: 만약 그렇게 된다면 `std::mem::drop`이 블록의 끝에서 호출되고, 다시 `Drop::drop`을 호출하게되 스택 오버플로가 발생합니다.\n"
 "* `drop(a)`를 `a.drop()`로 변경해 보시기 바랍니다."
 
 #: src/traits/drop.md:44
@@ -8942,24 +8465,18 @@ msgstr ""
 #: src/traits/default.md:40
 msgid ""
 "  * It can be implemented directly or it can be derived via `#[derive(Default)]`.\n"
-"  * Derived implementation will produce an instance where all fields are set to their default "
-"values.\n"
+"  * Derived implementation will produce an instance where all fields are set to their default values.\n"
 "    * This means all types in the struct must implement `Default` too.\n"
 "  * Standard Rust types often implement `Default` with reasonable values (e.g. `0`, `\"\"`, etc).\n"
 "  * The partial struct copy works nicely with default.\n"
-"  * Rust standard library is aware that types can implement `Default` and provides convenience "
-"methods that use it."
+"  * Rust standard library is aware that types can implement `Default` and provides convenience methods that use it."
 msgstr ""
-"  * 트레이트를 직접 구현하거나 `#[derive(Default)]`를 붙여서 컴파일러에게 구현을 맡길 수 있습니"
-"다.\n"
-"  * 컴파일러가 제공하는 자동 구현의 경우 모든 필드에 대해 기본 값을 설정한 새 인스턴스를 반환합니"
-"다.\n"
+"  * 트레이트를 직접 구현하거나 `#[derive(Default)]`를 붙여서 컴파일러에게 구현을 맡길 수 있습니다.\n"
+"  * 컴파일러가 제공하는 자동 구현의 경우 모든 필드에 대해 기본 값을 설정한 새 인스턴스를 반환합니다.\n"
 "    * 구조체의 각 필드 타입들이 모두 `Default`를 구현해야 함을 의미합니다.\n"
-"  * 러스트 표준 타입들은 대부분 `Default`를 구현하고 있으며, 기본 값은 `0`이나 `\"\"`처럼 예상 가능"
-"한 값들입니다.\n"
+"  * 러스트 표준 타입들은 대부분 `Default`를 구현하고 있으며, 기본 값은 `0`이나 `\"\"`처럼 예상 가능한 값들입니다.\n"
 "  * 구조체 부분 복사를 할때 `default`를 편리하게 사용할 수 있습니다.\n"
-"  * Rust standard library is aware that types can implement `Default` and provides convenience "
-"methods that use it."
+"  * Rust standard library is aware that types can implement `Default` and provides convenience methods that use it."
 
 #: src/traits/default.md:49
 msgid "[1]: https://doc.rust-lang.org/std/default/trait.Default.html"
@@ -8973,9 +8490,7 @@ msgstr "# 제너릭"
 msgid ""
 "Rust support generics, which lets you abstract an algorithm (such as sorting)\n"
 "over the types used in the algorithm."
-msgstr ""
-"러스트는 제너릭을 지원합니다. 이를 이용하면 알고리즘(정렬과 같은)을 추상화 하여 특정 타입에 의존하"
-"지 않도록 할 수 있습니다."
+msgstr "러스트는 제너릭을 지원합니다. 이를 이용하면 알고리즘(정렬과 같은)을 추상화 하여 특정 타입에 의존하지 않도록 할 수 있습니다."
 
 #: src/generics/data-types.md:1
 msgid "# Generic Data Types"
@@ -9046,19 +8561,16 @@ msgstr ""
 #: src/generics/methods.md:25
 msgid ""
 "* *Q:* Why `T` is specified twice in `impl<T> Point<T> {}`? Isn't that redundant?\n"
-"    * This is because it is a generic implementation section for generic type. They are "
-"independently generic.\n"
+"    * This is because it is a generic implementation section for generic type. They are independently generic.\n"
 "    * It means these methods are defined for any `T`.\n"
 "    * It is possible to write `impl Point<u32> { .. }`. \n"
-"      * `Point` is still generic and you can use `Point<f64>`, but methods in this block will only "
-"be available for `Point<u32>`."
+"      * `Point` is still generic and you can use `Point<f64>`, but methods in this block will only be available for `Point<u32>`."
 msgstr ""
 "* *질문:* `impl<T> Point<T> {}`에서 `T`가 왜 두 번 사용됩니까?\n"
 "  * 제너릭 타입에 대한 제너릭 구현 이기 때문입니다. 이 두 제너릭은 서로 독립적입니다.\n"
 "  * 이는 임의의 모든 `T`에 대해서 이 메소드들이 정의된다는 것을 의미합니다.\n"
 "  * `impl Point<u32> { .. }`와 같이 작성하는 것도 가능합니다.\n"
-"    * `Point`는 여전히 제너릭이며 `Point<f64>`를 사용할 수도 있지만 이 블록의 메서드는 `Point<u32>`"
-"만 쓸 수 있습니다."
+"    * `Point`는 여전히 제너릭이며 `Point<f64>`를 사용할 수도 있지만 이 블록의 메서드는 `Point<u32>`만 쓸 수 있습니다."
 
 #: src/generics/trait-bounds.md:1
 msgid "# Trait Bounds"
@@ -9068,9 +8580,7 @@ msgstr "# 제너릭 타입 제한(트레이트 경계, Trait Bounds)"
 msgid ""
 "When working with generics, you often want to require the types to implement\n"
 "some trait, so that you can call this trait's methods."
-msgstr ""
-"제너릭을 이용하다 보면 타입이 어떤 트레이트를 구현하고 있어야 하는 경우가 있습니다. 그래야 그 트레"
-"이트의 메서드를 호출할 수 있기 때문입니다."
+msgstr "제너릭을 이용하다 보면 타입이 어떤 트레이트를 구현하고 있어야 하는 경우가 있습니다. 그래야 그 트레이트의 메서드를 호출할 수 있기 때문입니다."
 
 #: src/generics/trait-bounds.md:6
 msgid "You can do this with `T: Trait` or `impl Trait`:"
@@ -9143,8 +8653,7 @@ msgstr ""
 msgid ""
 "* It declutters the function signature if you have many parameters.\n"
 "* It has additional features making it more powerful.\n"
-"    * If someone asks, the extra feature is that the type on the left of \":\" can be arbitrary, "
-"like `Option<T>`.\n"
+"    * If someone asks, the extra feature is that the type on the left of \":\" can be arbitrary, like `Option<T>`.\n"
 "    \n"
 "</details>"
 msgstr ""
@@ -9164,7 +8673,8 @@ msgid ""
 "arguments and return values:"
 msgstr "트레이트 바운드와 유사하게 `impl Trait` 문법은 함수의 인자와 반환값에도 적용 가능합니다:"
 
-#: src/generics/impl-trait.md:6 src/generics/trait-objects.md:5 src/generics/trait-objects.md:28
+#: src/generics/impl-trait.md:6 src/generics/trait-objects.md:5
+#: src/generics/trait-objects.md:28
 msgid ""
 "```rust,editable\n"
 "use std::fmt::Display;"
@@ -9201,36 +8711,25 @@ msgstr "`impl Trait`는 어디에 사용되었느냐에 따라 의미가 조금
 #: src/generics/impl-trait.md:26
 msgid ""
 "* For a parameter, `impl Trait` is like an anonymous generic parameter with a trait bound.\n"
-"* For a return type, it means that the return type is some concrete type that implements the "
-"trait,\n"
-"  without naming the type. This can be useful when you don't want to expose the concrete type in "
-"a\n"
+"* For a return type, it means that the return type is some concrete type that implements the trait,\n"
+"  without naming the type. This can be useful when you don't want to expose the concrete type in a\n"
 "  public API."
 msgstr ""
-"* 함수 인자의 타입으로 사용되었을 경우에는 `impl Trait`는 트레이트 경계가 있는 익명의 제너릭 타입"
-"을 의미합니다.\n"
-"* 리턴 타입으로 사용되었을 경우에는, 그 트레이트를 구현하는 구체적인 타입인데, 타입 이름을 프로그래"
-"머가 짓지 않았다는 것을 의미합니다. 이는 그 구체적인 타입 이름을 API로 공개하고 싶지 않은 경우에 유"
-"용합니다."
+"* 함수 인자의 타입으로 사용되었을 경우에는 `impl Trait`는 트레이트 경계가 있는 익명의 제너릭 타입을 의미합니다.\n"
+"* 리턴 타입으로 사용되었을 경우에는, 그 트레이트를 구현하는 구체적인 타입인데, 타입 이름을 프로그래머가 짓지 않았다는 것을 의미합니다. 이는 그 구체적인 타입 이름을 API로 공개하고 싶지 않은 경우에 유용합니다."
 
 #: src/generics/impl-trait.md:31
 msgid ""
 "This example is great, because it uses `impl Display` twice. It helps to explain that\n"
 "nothing here enforces that it is _the same_ `impl Display` type. If we used a single \n"
-"`T: Display`, it would enforce the constraint that input `T` and return `T` type are the same "
-"type.\n"
+"`T: Display`, it would enforce the constraint that input `T` and return `T` type are the same type.\n"
 "It would not work for this particular function, as the type we expect as input is likely not\n"
 "what `format!` returns. If we wanted to do the same via `: Display` syntax, we'd need two\n"
 "independent generic parameters.\n"
 "    \n"
 "</details>"
 msgstr ""
-"이 예시는 `impl Display`가 두번 사용 되었다는 점에서 훌륭합니다. 여기서 중요한 것은 이 두 `impl "
-"Display`가 실제로 같은 타입일 필요가 없다는 것입니다. 만약 `T: Display`로 트레이트 경계를 정하고 입"
-"력 파라메터와 리턴 값의 타입을 모두 `T`로 했다면, 이는 입력과 리턴값이 같은 타입임을 강제합니다. 이"
-"렇게 했다면 위의 예제는 동작하지 않았을 것입니다. 왜냐하면, 입력 값의 타입이 `format!`이 리턴하는 "
-"타입과 같지 않을 가능성이 높기 때문입니다. 만약 `: Display` 문법을 사용하고 싶다면 독립적인 제너릭 "
-"매개변수가 두 개가 필요합니다.\n"
+"이 예시는 `impl Display`가 두번 사용 되었다는 점에서 훌륭합니다. 여기서 중요한 것은 이 두 `impl Display`가 실제로 같은 타입일 필요가 없다는 것입니다. 만약 `T: Display`로 트레이트 경계를 정하고 입력 파라메터와 리턴 값의 타입을 모두 `T`로 했다면, 이는 입력과 리턴값이 같은 타입임을 강제합니다. 이렇게 했다면 위의 예제는 동작하지 않았을 것입니다. 왜냐하면, 입력 값의 타입이 `format!`이 리턴하는 타입과 같지 않을 가능성이 높기 때문입니다. 만약 `: Display` 문법을 사용하고 싶다면 독립적인 제너릭 매개변수가 두 개가 필요합니다.\n"
 "    \n"
 "</details>"
 
@@ -9244,10 +8743,7 @@ msgid ""
 "implement special [`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html),\n"
 "[`FnMut`](https://doc.rust-lang.org/std/ops/trait.FnMut.html), and\n"
 "[`FnOnce`](https://doc.rust-lang.org/std/ops/trait.FnOnce.html) traits:"
-msgstr ""
-"클로저 혹은 람다표현식은 익명타입입니다. 이들은 [`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn."
-"html),[`FnMut`](https://doc.rust-lang.org/std/ops/trait.FnMut.html), [`FnOnce`](https://doc.rust-"
-"lang.org/std/ops/trait.FnOnce.html) 라는 특별한 트레이트를 구현합니다."
+msgstr "클로저 혹은 람다표현식은 익명타입입니다. 이들은 [`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html),[`FnMut`](https://doc.rust-lang.org/std/ops/trait.FnMut.html), [`FnOnce`](https://doc.rust-lang.org/std/ops/trait.FnOnce.html) 라는 특별한 트레이트를 구현합니다."
 
 #: src/generics/closures.md:8
 msgid ""
@@ -9278,30 +8774,21 @@ msgid "If you have an `FnOnce`, you may only call it once. It might consume capt
 msgstr "`FnOnce`는 한번만 호출되며 캡처된 값을 소모합니다."
 
 #: src/generics/closures.md:27
-msgid ""
-"An `FnMut` might mutate captured values, so you can call it multiple times but not concurrently."
-msgstr ""
-"`FnMut`는 캡처된 값을 변경할 수 있으므로 여러번 호출은 가능하지만 동시에 호출 할 수는 없습니다."
+msgid "An `FnMut` might mutate captured values, so you can call it multiple times but not concurrently."
+msgstr "`FnMut`는 캡처된 값을 변경할 수 있으므로 여러번 호출은 가능하지만 동시에 호출 할 수는 없습니다."
 
 #: src/generics/closures.md:29
 msgid ""
-"An `Fn` neither consumes nor mutates captured values, or perhaps captures nothing at all, so it "
-"can\n"
+"An `Fn` neither consumes nor mutates captured values, or perhaps captures nothing at all, so it can\n"
 "be called multiple times concurrently."
-msgstr ""
-"`Fn`은 캡처된 값을 소모도 변경도 하지 않고, 혹은 어떤 것도 캡쳐하지 않았을 수도 있기 때문에 동시에 "
-"여러번 호출할 수 있습니다."
+msgstr "`Fn`은 캡처된 값을 소모도 변경도 하지 않고, 혹은 어떤 것도 캡쳐하지 않았을 수도 있기 때문에 동시에 여러번 호출할 수 있습니다."
 
 #: src/generics/closures.md:32
 msgid ""
 "`FnMut` is a subtype of `FnOnce`. `Fn` is a subtype of `FnMut` and `FnOnce`. I.e. you can use an\n"
-"`FnMut` wherever an `FnOnce` is called for, and you can use an `Fn` wherever an `FnMut` or "
-"`FnOnce`\n"
+"`FnMut` wherever an `FnOnce` is called for, and you can use an `Fn` wherever an `FnMut` or `FnOnce`\n"
 "is called for."
-msgstr ""
-"`FnMut` 는 `FnOnce`의 하위타입입니다. `Fn`은 `FnMut`과 `FnOnce`의 하위 타입입니다. 즉, `FnMut`는 "
-"`FnOnce`가 호출되는 곳이면 어디서나 사용 할 수 있고 `Fn`은 `FnMut`와 `FnOnce`가 호출되는 곳이면 어"
-"디든 사용할 수 있습니다."
+msgstr "`FnMut` 는 `FnOnce`의 하위타입입니다. `Fn`은 `FnMut`과 `FnOnce`의 하위 타입입니다. 즉, `FnMut`는 `FnOnce`가 호출되는 곳이면 어디서나 사용 할 수 있고 `Fn`은 `FnMut`와 `FnOnce`가 호출되는 곳이면 어디든 사용할 수 있습니다."
 
 #: src/generics/closures.md:36
 msgid "`move` closures only implement `FnOnce`."
@@ -9359,9 +8846,7 @@ msgstr ""
 msgid ""
 "This is a zero-cost abstraction: you get exactly the same result as if you had\n"
 "hand-coded the data structures without the abstraction."
-msgstr ""
-"이것이 바로 비용이 들지 않는 (zero-cost) 추상화 입니다: 러스트의 제너릭은 추상화를 거치지 않고 직"
-"접 구체적인 타입을 써서 코딩한 것과 정확히 동일한 결과를 보여줍니다."
+msgstr "이것이 바로 비용이 들지 않는 (zero-cost) 추상화 입니다: 러스트의 제너릭은 추상화를 거치지 않고 직접 구체적인 타입을 써서 코딩한 것과 정확히 동일한 결과를 보여줍니다."
 
 #: src/generics/trait-objects.md:1
 msgid "# Trait Objects"
@@ -9389,9 +8874,7 @@ msgstr ""
 
 #: src/generics/trait-objects.md:18
 msgid "However, how can we store a collection of mixed types which implement `Display`?"
-msgstr ""
-"그런데, 아래와 같이 `Display`를 구현하는 서로 다른 타입들의 콜렉션을 저장하고 싶다면 어떻게 해야 할"
-"까요?"
+msgstr "그런데, 아래와 같이 `Display`를 구현하는 서로 다른 타입들의 콜렉션을 저장하고 싶다면 어떻게 해야 할까요?"
 
 #: src/generics/trait-objects.md:20
 msgid ""
@@ -9456,9 +8939,7 @@ msgstr ""
 msgid ""
 "Similarly, you need a trait object if you want to return different types\n"
 "implementing a trait:"
-msgstr ""
-"마찬가지로, 같은 트레이트를 구현하는 서로 다른 타입의 값을 리턴할 때에도 트레이트 객체가 필요합니"
-"다:"
+msgstr "마찬가지로, 같은 트레이트를 구현하는 서로 다른 타입의 값을 리턴할 때에도 트레이트 객체가 필요합니다:"
 
 #: src/generics/trait-objects.md:72
 msgid ""
@@ -9486,8 +8967,7 @@ msgstr "# 3일차 오전 연습문제"
 
 #: src/exercises/day-3/morning.md:3
 msgid "We will design a classical GUI library traits and trait objects."
-msgstr ""
-"이번 연습문제에서는 트레이트와 트레이트 객체를 통해 고전적인 GUI 라이브러리를 설계할 것입니다."
+msgstr "이번 연습문제에서는 트레이트와 트레이트 객체를 통해 고전적인 GUI 라이브러리를 설계할 것입니다."
 
 #: src/exercises/day-3/simple-gui.md:1
 msgid "# A Simple GUI Library"
@@ -9497,9 +8977,7 @@ msgstr "# 간단한 GUI 라이브러리"
 msgid ""
 "Let us design a classical GUI library using our new knowledge of traits and\n"
 "trait objects."
-msgstr ""
-"이번 연습문제에서는 트레이트와 트레이트 객체에 대해 배운것을 활용하여 고전적인 GUI 라이브러리를 설"
-"계할 것입니다."
+msgstr "이번 연습문제에서는 트레이트와 트레이트 객체에 대해 배운것을 활용하여 고전적인 GUI 라이브러리를 설계할 것입니다."
 
 #: src/exercises/day-3/simple-gui.md:6
 msgid "We will have a number of widgets in our library:"
@@ -9524,11 +9002,10 @@ msgstr "위젯들은 모두 `Widget` 트레이트를 구현합니다. 아래 코
 msgid ""
 "Copy the code below to <https://play.rust-lang.org/>, fill in the missing\n"
 "`draw_into` methods so that you implement the `Widget` trait:"
-msgstr ""
-"아래 코드를 <https://play.rust-lang.org/>에 복사하고 누락된 `draw_into`메서드를 채워 넣어 `Widget` "
-"트레이트를 완성해봅시다:"
+msgstr "아래 코드를 <https://play.rust-lang.org/>에 복사하고 누락된 `draw_into`메서드를 채워 넣어 `Widget` 트레이트를 완성해봅시다:"
 
-#: src/exercises/day-3/simple-gui.md:18 src/exercises/day-3/safe-ffi-wrapper.md:25
+#: src/exercises/day-3/simple-gui.md:18
+#: src/exercises/day-3/safe-ffi-wrapper.md:25
 msgid ""
 "```rust,should_panic\n"
 "// TODO: remove this when you're done with your implementation.\n"
@@ -9542,13 +9019,15 @@ msgid ""
 "    fn width(&self) -> usize;"
 msgstr ""
 
-#: src/exercises/day-3/simple-gui.md:26 src/exercises/day-3/solutions-morning.md:27
+#: src/exercises/day-3/simple-gui.md:26
+#: src/exercises/day-3/solutions-morning.md:27
 msgid ""
 "    /// Draw the widget into a buffer.\n"
 "    fn draw_into(&self, buffer: &mut dyn std::fmt::Write);"
 msgstr ""
 
-#: src/exercises/day-3/simple-gui.md:29 src/exercises/day-3/solutions-morning.md:30
+#: src/exercises/day-3/simple-gui.md:29
+#: src/exercises/day-3/solutions-morning.md:30
 msgid ""
 "    /// Draw the widget on standard output.\n"
 "    fn draw(&self) {\n"
@@ -9559,14 +9038,16 @@ msgid ""
 "}"
 msgstr ""
 
-#: src/exercises/day-3/simple-gui.md:37 src/exercises/day-3/solutions-morning.md:38
+#: src/exercises/day-3/simple-gui.md:37
+#: src/exercises/day-3/solutions-morning.md:38
 msgid ""
 "pub struct Label {\n"
 "    label: String,\n"
 "}"
 msgstr ""
 
-#: src/exercises/day-3/simple-gui.md:41 src/exercises/day-3/solutions-morning.md:42
+#: src/exercises/day-3/simple-gui.md:41
+#: src/exercises/day-3/solutions-morning.md:42
 msgid ""
 "impl Label {\n"
 "    fn new(label: &str) -> Label {\n"
@@ -9577,7 +9058,8 @@ msgid ""
 "}"
 msgstr ""
 
-#: src/exercises/day-3/simple-gui.md:49 src/exercises/day-3/solutions-morning.md:50
+#: src/exercises/day-3/simple-gui.md:49
+#: src/exercises/day-3/solutions-morning.md:50
 msgid ""
 "pub struct Button {\n"
 "    label: Label,\n"
@@ -9585,7 +9067,8 @@ msgid ""
 "}"
 msgstr ""
 
-#: src/exercises/day-3/simple-gui.md:54 src/exercises/day-3/solutions-morning.md:55
+#: src/exercises/day-3/simple-gui.md:54
+#: src/exercises/day-3/solutions-morning.md:55
 msgid ""
 "impl Button {\n"
 "    fn new(label: &str, callback: Box<dyn FnMut()>) -> Button {\n"
@@ -9597,7 +9080,8 @@ msgid ""
 "}"
 msgstr ""
 
-#: src/exercises/day-3/simple-gui.md:63 src/exercises/day-3/solutions-morning.md:64
+#: src/exercises/day-3/simple-gui.md:63
+#: src/exercises/day-3/solutions-morning.md:64
 msgid ""
 "pub struct Window {\n"
 "    title: String,\n"
@@ -9605,7 +9089,8 @@ msgid ""
 "}"
 msgstr ""
 
-#: src/exercises/day-3/simple-gui.md:68 src/exercises/day-3/solutions-morning.md:69
+#: src/exercises/day-3/simple-gui.md:68
+#: src/exercises/day-3/solutions-morning.md:69
 msgid ""
 "impl Window {\n"
 "    fn new(title: &str) -> Window {\n"
@@ -9616,7 +9101,8 @@ msgid ""
 "    }"
 msgstr ""
 
-#: src/exercises/day-3/simple-gui.md:76 src/exercises/day-3/solutions-morning.md:77
+#: src/exercises/day-3/simple-gui.md:76
+#: src/exercises/day-3/solutions-morning.md:77
 msgid ""
 "    fn add_widget(&mut self, widget: Box<dyn Widget>) {\n"
 "        self.widgets.push(widget);\n"
@@ -9700,8 +9186,7 @@ msgid ""
 "formatting operators. In particular, notice how you can pad with different\n"
 "characters (here a `'/'`) and how you can control alignment:"
 msgstr ""
-"텍스트를 줄맞춤 해서 그리려면 [fill/alignment](https://doc.rust-lang.org/std/fmt/index."
-"html#fillalignment)를 참조하시기 바랍니다. \n"
+"텍스트를 줄맞춤 해서 그리려면 [fill/alignment](https://doc.rust-lang.org/std/fmt/index.html#fillalignment)를 참조하시기 바랍니다. \n"
 "특수 문자(여기서는 '/')로 패딩을 주는 방법과 정렬을 제어하는 방법을 확인하시기 바랍니다."
 
 #: src/exercises/day-3/simple-gui.md:140
@@ -9776,8 +9261,7 @@ msgid ""
 msgstr ""
 "* 패닉은 복구할 수 없고 예상치 못한 오류입니다.\n"
 "  * 패닉은 프로그램에 버그가 있다는 것을 나타냅니다.\n"
-"* 충돌(크래시)를 허용하지 않아야 하는 경우, 패닉을 유발하지 않는 API(`Vec::get`등)를 사용하면 됩니"
-"다."
+"* 충돌(크래시)를 허용하지 않아야 하는 경우, 패닉을 유발하지 않는 API(`Vec::get`등)를 사용하면 됩니다."
 
 #: src/error-handling/panic-unwind.md:1
 msgid "# Catching the Stack Unwinding"
@@ -9785,8 +9269,7 @@ msgstr "# 스택 되감기"
 
 #: src/error-handling/panic-unwind.md:3
 msgid "By default, a panic will cause the stack to unwind. The unwinding can be caught:"
-msgstr ""
-"기본적으로, 패닉이 발생하면 스택 되감기를 합니다. 스택 되감기는 다음과 같이 캐치가 가능합니다:"
+msgstr "기본적으로, 패닉이 발생하면 스택 되감기를 합니다. 스택 되감기는 다음과 같이 캐치가 가능합니다:"
 
 #: src/error-handling/panic-unwind.md:5
 msgid ""
@@ -9828,9 +9311,7 @@ msgstr "# `Result`를 이용한 구조화된 오류처리"
 msgid ""
 "We have already seen the `Result` enum. This is used pervasively when errors are\n"
 "expected as part of normal operation:"
-msgstr ""
-"여러분은 이미 `Result` 열거형을 몇 번 봤습니다. 이 타입은 프로그램의 정상적인 수행 중에 발생할 수 "
-"있는 오류값들을 나타내기 위해 사용됩니다:"
+msgstr "여러분은 이미 `Result` 열거형을 몇 번 봤습니다. 이 타입은 프로그램의 정상적인 수행 중에 발생할 수 있는 오류값들을 나타내기 위해 사용됩니다:"
 
 #: src/error-handling/result.md:6
 msgid ""
@@ -9860,22 +9341,15 @@ msgstr ""
 #: src/error-handling/result.md:27
 msgid ""
 "  * As with `Option`, the successful value sits inside of `Result`, forcing the developer to\n"
-"    explicitly extract it. This encourages error checking. In the case where an error should never "
-"happen,\n"
+"    explicitly extract it. This encourages error checking. In the case where an error should never happen,\n"
 "    `unwrap()` or `expect()` can be called, and this is a signal of the developer intent too.  \n"
-"  * `Result` documentation is a recommended read. Not during the course, but it is worth "
-"mentioning. \n"
-"    It contains a lot of convenience methods and functions that help functional-style "
-"programming. \n"
+"  * `Result` documentation is a recommended read. Not during the course, but it is worth mentioning. \n"
+"    It contains a lot of convenience methods and functions that help functional-style programming. \n"
 "    \n"
 "</details>"
 msgstr ""
-"  * `Option`와 마찬가지로, 성공한 경우의 값은 `Result` 내부에 있습니다. 그래서, 개발자는 명시적으"
-"로 이를 추출하여야 합니다. 이렇게 함으로써 값을 읽기 전에 오류 발생 여부를 반드시 체크하도록 유도하"
-"고 있습니다. 만일 오류가 절대 발생하지 않는 경우라면 `unwrap()`이나 `expect()`를 사용할 수 있으며, "
-"이는 개발자의 의도(_역주_: 오류가 발생할 수 없음)을 명시적으로 나타내는 방법이기도 합니다.\n"
-"  * 수업중엔 아니지만 `Result`의 API 레퍼런스를 읽는 것을 권장합니다. 함수형 프로그래밍 스타일에 도"
-"움이 되는 편리한 메서드와 함수를 많이 배울 수 있습니다.\n"
+"  * `Option`와 마찬가지로, 성공한 경우의 값은 `Result` 내부에 있습니다. 그래서, 개발자는 명시적으로 이를 추출하여야 합니다. 이렇게 함으로써 값을 읽기 전에 오류 발생 여부를 반드시 체크하도록 유도하고 있습니다. 만일 오류가 절대 발생하지 않는 경우라면 `unwrap()`이나 `expect()`를 사용할 수 있으며, 이는 개발자의 의도(_역주_: 오류가 발생할 수 없음)을 명시적으로 나타내는 방법이기도 합니다.\n"
+"  * 수업중엔 아니지만 `Result`의 API 레퍼런스를 읽는 것을 권장합니다. 함수형 프로그래밍 스타일에 도움이 되는 편리한 메서드와 함수를 많이 배울 수 있습니다.\n"
 "    \n"
 "</details>"
 
@@ -9958,11 +9432,11 @@ msgid ""
 "```"
 msgstr ""
 
-#: src/error-handling/try-operator.md:52 src/error-handling/converting-error-types-example.md:52
+#: src/error-handling/try-operator.md:52
+#: src/error-handling/converting-error-types-example.md:52
 msgid ""
 "* The `username` variable can be either `Ok(string)` or `Err(error)`.\n"
-"* Use the `fs::write` call to test out the different scenarios: no file, empty file, file with "
-"username."
+"* Use the `fs::write` call to test out the different scenarios: no file, empty file, file with username."
 msgstr ""
 "* `username` 변수는 `Ok(string)`이거나 `Err(error)`일 수 있습니다.\n"
 "* `fs::write` 메서드를 사용하여 파일이 없거나, 비었거나, 중복되는 경우 등을 테스트해 봅니다."
@@ -10070,17 +9544,11 @@ msgstr ""
 
 #: src/error-handling/converting-error-types-example.md:55
 msgid ""
-"It is good practice for all error types to implement `std::error::Error`, which requires `Debug` "
-"and\n"
-"`Display`. It's generally helpful for them to implement `Clone` and `Eq` too where possible, to "
-"make\n"
+"It is good practice for all error types to implement `std::error::Error`, which requires `Debug` and\n"
+"`Display`. It's generally helpful for them to implement `Clone` and `Eq` too where possible, to make\n"
 "life easier for tests and consumers of your library. In this case we can't easily do so, because\n"
 "`io::Error` doesn't implement them."
-msgstr ""
-"에러 타입이 `std::error::Error`를 구현하도록 하는 것은 좋은 습관입니다. 그러면 `Debug`와 `Display` "
-"트레이트 또한 구현을 해야 합니다. 가능하다면 `Clone`과 `Eq` 트레이트도 구현하도록 하세요. 여러분의 "
-"라이브러리가 테스트 하기 쉬워지고, 사용하기 좋아질 겁니다. 다만, 이 예제에서는 그렇게 하기 힘듭니"
-"다. 왜냐하면 `io::Error`는 이 트레이트들을 구현하고 있지 않기 때문입니다."
+msgstr "에러 타입이 `std::error::Error`를 구현하도록 하는 것은 좋은 습관입니다. 그러면 `Debug`와 `Display` 트레이트 또한 구현을 해야 합니다. 가능하다면 `Clone`과 `Eq` 트레이트도 구현하도록 하세요. 여러분의 라이브러리가 테스트 하기 쉬워지고, 사용하기 좋아질 겁니다. 다만, 이 예제에서는 그렇게 하기 힘듭니다. 왜냐하면 `io::Error`는 이 트레이트들을 구현하고 있지 않기 때문입니다."
 
 #: src/error-handling/deriving-error-enums.md:1
 msgid "# Deriving Error Enums"
@@ -10090,9 +9558,7 @@ msgstr "# 또다른 오류 열거형"
 msgid ""
 "The [thiserror](https://docs.rs/thiserror/) crate is a popular way to create an\n"
 "error enum like we did on the previous page:"
-msgstr ""
-"[thiserror](https://docs.rs/thiserror/)는, 이전 페이지에서 보았던 것과 같은 에러 열거형을 쉽게 만"
-"들 수 있게 해 주는 유명한 크레이트 입니다."
+msgstr "[thiserror](https://docs.rs/thiserror/)는, 이전 페이지에서 보았던 것과 같은 에러 열거형을 쉽게 만들 수 있게 해 주는 유명한 크레이트 입니다."
 
 #: src/error-handling/deriving-error-enums.md:6
 msgid ""
@@ -10125,7 +9591,8 @@ msgid ""
 "}"
 msgstr ""
 
-#: src/error-handling/deriving-error-enums.md:28 src/error-handling/dynamic-errors.md:25
+#: src/error-handling/deriving-error-enums.md:28
+#: src/error-handling/dynamic-errors.md:25
 msgid ""
 "fn main() {\n"
 "    //fs::write(\"config.dat\", \"\").unwrap();\n"
@@ -10140,19 +9607,13 @@ msgstr ""
 #: src/error-handling/deriving-error-enums.md:39
 msgid ""
 "`thiserror`'s derive macro automatically implements `std::error::Error`, and optionally `Display`\n"
-"(if the `#[error(...)]` attributes are provided) and `From` (if the `#[from]` attribute is "
-"added).\n"
+"(if the `#[error(...)]` attributes are provided) and `From` (if the `#[from]` attribute is added).\n"
 "It also works for structs."
-msgstr ""
-"`thiserror`의 derive 매크로를 이용하면 `std::error::Error`과 `Display`(만약 `#[error(...)]` 어트리"
-"뷰트를 추가했을 경우), `From`(만약 `#[from]` 어트리뷰트를 추가했을 경우) 트레이트들이 자동으로 구현"
-"이 됩니다. 구조체에 대해서도 사용 가능합니다."
+msgstr "`thiserror`의 derive 매크로를 이용하면 `std::error::Error`과 `Display`(만약 `#[error(...)]` 어트리뷰트를 추가했을 경우), `From`(만약 `#[from]` 어트리뷰트를 추가했을 경우) 트레이트들이 자동으로 구현이 됩니다. 구조체에 대해서도 사용 가능합니다."
 
 #: src/error-handling/deriving-error-enums.md:43
 msgid "It doesn't affect your public API, which makes it good for libraries."
-msgstr ""
-"이 매크로를 사용해도 밖으로 노출되는 API가 변경되지는 않습니다. 라이브러리를 만들 경우에는 이게 중"
-"요하죠."
+msgstr "이 매크로를 사용해도 밖으로 노출되는 API가 변경되지는 않습니다. 라이브러리를 만들 경우에는 이게 중요하죠."
 
 #: src/error-handling/dynamic-errors.md:1
 msgid "# Dynamic Error Types"
@@ -10162,9 +9623,7 @@ msgstr "# 동적인 에러 타입"
 msgid ""
 "Sometimes we want to allow any type of error to be returned without writing our own enum covering\n"
 "all the different possibilities. `std::error::Error` makes this easy."
-msgstr ""
-"때때로 우리는, 발생 가능한 모든 에러를 일일히 열거하지 않고, 어떤 종류의 에러라도 상관없이 리턴하"
-"고 싶을 때가 있습니다. `std::error::Error`를 이용하면 쉽습니다."
+msgstr "때때로 우리는, 발생 가능한 모든 에러를 일일히 열거하지 않고, 어떤 종류의 에러라도 상관없이 리턴하고 싶을 때가 있습니다. `std::error::Error`를 이용하면 쉽습니다."
 
 #: src/error-handling/dynamic-errors.md:6
 msgid ""
@@ -10196,17 +9655,11 @@ msgstr ""
 
 #: src/error-handling/dynamic-errors.md:36
 msgid ""
-"This saves on code, but gives up the ability to cleanly handle different error cases differently "
-"in\n"
-"the program. As such it's generally not a good idea to use `Box<dyn Error>` in the public API of "
-"a\n"
-"library, but it can be a good option in a program where you just want to display the error "
-"message\n"
+"This saves on code, but gives up the ability to cleanly handle different error cases differently in\n"
+"the program. As such it's generally not a good idea to use `Box<dyn Error>` in the public API of a\n"
+"library, but it can be a good option in a program where you just want to display the error message\n"
 "somewhere."
-msgstr ""
-"이렇게 하면 코드의 양을 줄일 수 있습니다. 그러나 서로 다른 종류의 에러를 구별하여 다르게 처리하는 "
-"것이 불가능해 집니다. 때문에, `Box<dyn Error>`를 라이브러리의 API로 노출하는게 좋은 디자인은 아닙니"
-"다. 에러 발생시, 그저 에러 메시지를 출력하고 싶은 경우와 같이 제한된 상황에서는 유용할 수 있습니다."
+msgstr "이렇게 하면 코드의 양을 줄일 수 있습니다. 그러나 서로 다른 종류의 에러를 구별하여 다르게 처리하는 것이 불가능해 집니다. 때문에, `Box<dyn Error>`를 라이브러리의 API로 노출하는게 좋은 디자인은 아닙니다. 에러 발생시, 그저 에러 메시지를 출력하고 싶은 경우와 같이 제한된 상황에서는 유용할 수 있습니다."
 
 #: src/error-handling/error-contexts.md:1
 msgid "# Adding Context to Errors"
@@ -10217,10 +9670,7 @@ msgid ""
 "The widely used [anyhow](https://docs.rs/anyhow/) crate can help you add\n"
 "contextual information to your errors and allows you to have fewer\n"
 "custom error types:"
-msgstr ""
-"[anyhow](https://docs.rs/anyhow/) 크레이트는 에러에 에러가 발생한 문맥에 대한 정보를 추가하기 위해 "
-"널리 사용되며, 이를 이용하면 서로 다른 문맥을 나타내기 사용자 정의 오류 타입을 많이 만들어야 하는 "
-"불편함을 피할 수 있습니다:"
+msgstr "[anyhow](https://docs.rs/anyhow/) 크레이트는 에러에 에러가 발생한 문맥에 대한 정보를 추가하기 위해 널리 사용되며, 이를 이용하면 서로 다른 문맥을 나타내기 사용자 정의 오류 타입을 많이 만들어야 하는 불편함을 피할 수 있습니다:"
 
 #: src/error-handling/error-contexts.md:7
 msgid ""
@@ -10260,8 +9710,7 @@ msgstr ""
 #: src/error-handling/error-contexts.md:35
 msgid ""
 "* `anyhow::Result<V>` is a type alias for `Result<V, anyhow::Error>`.\n"
-"* `anyhow::Error` is essentially a wrapper around `Box<dyn Error>`. As such it's again generally "
-"not\n"
+"* `anyhow::Error` is essentially a wrapper around `Box<dyn Error>`. As such it's again generally not\n"
 "  a good choice for the public API of a library, but is widely used in applications.\n"
 "* Actual error type inside of it can be extracted for examination if necessary.\n"
 "* Functionality provided by `anyhow::Result<T>` may be familiar to Go developers, as it provides\n"
@@ -10340,9 +9789,7 @@ msgstr "# 테스트 모듈"
 msgid ""
 "Unit tests are often put in a nested module (run tests on the\n"
 "[Playground](https://play.rust-lang.org/)):"
-msgstr ""
-"단위 테스트는 원래 모듈 밑에 서브 모듈로 만드는 경우가 많습니다. ([플레이그라운드](https://play."
-"rust-lang.org/)에서 다음 테스트를 수행해 보세요):"
+msgstr "단위 테스트는 원래 모듈 밑에 서브 모듈로 만드는 경우가 많습니다. ([플레이그라운드](https://play.rust-lang.org/)에서 다음 테스트를 수행해 보세요):"
 
 #: src/testing/test-modules.md:6
 msgid ""
@@ -10405,14 +9852,11 @@ msgstr ""
 msgid ""
 "* Code blocks in `///` comments are automatically seen as Rust code.\n"
 "* The code will be compiled and executed as part of `cargo test`.\n"
-"* Test the above code on the [Rust Playground](https://play.rust-lang.org/?"
-"version=stable&mode=debug&edition=2021&gist=3ce2ad13ea1302f6572cb15cd96becf0)."
+"* Test the above code on the [Rust Playground](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=3ce2ad13ea1302f6572cb15cd96becf0)."
 msgstr ""
 "* `///` 주석안의 코드 블록은 자동으로 러스트 코드로 인식됩니다.\n"
 "* 이 코드 블록은 `cargo test` 호출하면 자동으로 컴파일되고 실행됩니다.\n"
-"* 위 코드를 [Rust Playground](https://play.rust-lang.org/?"
-"version=stable&mode=debug&edition=2021&gist=3ce2ad13ea1302f6572cb15cd96becf0)에서 테스트 해 보시기 "
-"바랍니다."
+"* 위 코드를 [Rust Playground](https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=3ce2ad13ea1302f6572cb15cd96becf0)에서 테스트 해 보시기 바랍니다."
 
 #: src/testing/integration-tests.md:1
 msgid "# Integration Tests"
@@ -10459,25 +9903,19 @@ msgid ""
 "* **Unsafe Rust:** can trigger undefined behavior if preconditions are violated."
 msgstr ""
 "* **안전한 러스트:** 메모리 관련 오류 발생 불가능, 정의되지 않은 동작 없음.\n"
-"* **안전하지 않은 러스트:** 특별한 조건을 만족하지 않은채로 사용되면 정의되지 않은 동작을 유발할 "
-"수 있음."
+"* **안전하지 않은 러스트:** 특별한 조건을 만족하지 않은채로 사용되면 정의되지 않은 동작을 유발할 수 있음."
 
 #: src/unsafe.md:8
 msgid ""
 "We will be seeing mostly safe Rust in this course, but it's important to know\n"
 "what Unsafe Rust is."
-msgstr ""
-"이 강의는 대부분 안전한 러스트에 대해 다루지만 안전하지 않은 러스트가 무엇인지는 알아 두어야 합니"
-"다."
+msgstr "이 강의는 대부분 안전한 러스트에 대해 다루지만 안전하지 않은 러스트가 무엇인지는 알아 두어야 합니다."
 
 #: src/unsafe.md:11
 msgid ""
 "Unsafe code is usually small and isolated, and its correctness should be carefully\n"
 "documented. It is usually wrapped in a safe abstraction layer."
-msgstr ""
-"보통, 안전하지 않은 러스트 코드는 크기가 작으며, 독립적으로 존재합니다. 그리고 코드가 왜 잘 작동하"
-"는지에 대해 세밀하게 문서화가 되어 있습니다. 그리고, 많은 경우 안전한 러스트 코드를 통해서 추상화"
-"를 시킨 후 사용하게 됩니다."
+msgstr "보통, 안전하지 않은 러스트 코드는 크기가 작으며, 독립적으로 존재합니다. 그리고 코드가 왜 잘 작동하는지에 대해 세밀하게 문서화가 되어 있습니다. 그리고, 많은 경우 안전한 러스트 코드를 통해서 추상화를 시킨 후 사용하게 됩니다."
 
 #: src/unsafe.md:14
 msgid "Unsafe Rust gives you access to five new capabilities:"
@@ -10502,21 +9940,14 @@ msgid ""
 "We will briefly cover unsafe capabilities next. For full details, please see\n"
 "[Chapter 19.1 in the Rust Book](https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html)\n"
 "and the [Rustonomicon](https://doc.rust-lang.org/nomicon/)."
-msgstr ""
-"위 기능들에 대해 간략히 살펴보겠습니다. 자세한 내용은 [러스트 프로그래밍 언어, 19.1절](https://doc."
-"rust-lang.org/book/ch19-01-unsafe-rust.html)과 [Rustonomicon](https://doc.rust-lang.org/nomicon/)"
-"를 참조하세요."
+msgstr "위 기능들에 대해 간략히 살펴보겠습니다. 자세한 내용은 [러스트 프로그래밍 언어, 19.1절](https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html)과 [Rustonomicon](https://doc.rust-lang.org/nomicon/)를 참조하세요."
 
 #: src/unsafe.md:28
 msgid ""
 "Unsafe Rust does not mean the code is incorrect. It means that developers have\n"
 "turned off the compiler safety features and have to write correct code by\n"
 "themselves. It means the compiler no longer enforces Rust's memory-safety rules."
-msgstr ""
-"안전하지 않은 러스트라고 해서 코드가 부정확 하다는 뜻은 아닙니다. 여기서 안전하지 않다의 의미는 컴"
-"파일러가 제공해주는 안전 장치들이 꺼진 상태이며, 개발자가 스스로 정확하고 안전한 코드를 작성해야 함"
-"을 의미합니다. 이는 컴파일러가 더 이상 러스트의 메모리 안전과 관련된 규칙들을 적용하지 않는다는 것"
-"입니다."
+msgstr "안전하지 않은 러스트라고 해서 코드가 부정확 하다는 뜻은 아닙니다. 여기서 안전하지 않다의 의미는 컴파일러가 제공해주는 안전 장치들이 꺼진 상태이며, 개발자가 스스로 정확하고 안전한 코드를 작성해야 함을 의미합니다. 이는 컴파일러가 더 이상 러스트의 메모리 안전과 관련된 규칙들을 적용하지 않는다는 것입니다."
 
 #: src/unsafe/raw-pointers.md:1
 msgid "# Dereferencing Raw Pointers"
@@ -10541,8 +9972,7 @@ msgstr ""
 
 #: src/unsafe/raw-pointers.md:12
 msgid ""
-"    // Safe because r1 and r2 were obtained from references and so are guaranteed to be non-null "
-"and\n"
+"    // Safe because r1 and r2 were obtained from references and so are guaranteed to be non-null and\n"
 "    // properly aligned, the objects underlying the references from which they were obtained are\n"
 "    // live throughout the whole unsafe block, and they are not accessed either through the\n"
 "    // references or concurrently through any other pointers.\n"
@@ -10554,10 +9984,8 @@ msgid ""
 "}\n"
 "```"
 msgstr ""
-"    // 아래 코드는 안전합니다. r1과 r2는 참조로 부터 만들어 졌기 때문에 null이 아니며 align이 맞다"
-"는 것이 보장됩니다.\n"
-"    // 참조가 가리키는 객체들은 unsafe 블럭이 수행되는 동안 메모리에 살아있습니다. 그리고 이 객체들"
-"은 r1과 r2가 아닌 다른\n"
+"    // 아래 코드는 안전합니다. r1과 r2는 참조로 부터 만들어 졌기 때문에 null이 아니며 align이 맞다는 것이 보장됩니다.\n"
+"    // 참조가 가리키는 객체들은 unsafe 블럭이 수행되는 동안 메모리에 살아있습니다. 그리고 이 객체들은 r1과 r2가 아닌 다른\n"
 "    // 어떤 참조나 포인터로도 접근이 안되고 있습니다.\n"
 "    unsafe {\n"
 "        println!(\"r1 is: {}\", *r1);\n"
@@ -10572,17 +10000,13 @@ msgid ""
 "It is good practice (and required by the Android Rust style guide) to write a comment for each\n"
 "`unsafe` block explaining how the code inside it satisfies the safety requirements of the unsafe\n"
 "operations it is doing."
-msgstr ""
-"모든 `unsafe` 블럭에 대해 왜 그 코드가 안전한지에 대한 설명을 주석으로 다는 것은 좋은 습관입니다(사"
-"실 안드로이드의 러스트 스타일 가이드에서는 이게 필수입니다)."
+msgstr "모든 `unsafe` 블럭에 대해 왜 그 코드가 안전한지에 대한 설명을 주석으로 다는 것은 좋은 습관입니다(사실 안드로이드의 러스트 스타일 가이드에서는 이게 필수입니다)."
 
 #: src/unsafe/raw-pointers.md:30
 msgid ""
 "In the case of pointer dereferences, this means that the pointers must be\n"
 "[_valid_](https://doc.rust-lang.org/std/ptr/index.html#safety), i.e.:"
-msgstr ""
-"포인터 역참조를 할 경우, 포인터가 [_유효_](https://doc.rust-lang.org/std/ptr/index.html#safety)해"
-"야 합니다. 예를 들어:"
+msgstr "포인터 역참조를 할 경우, 포인터가 [_유효_](https://doc.rust-lang.org/std/ptr/index.html#safety)해야 합니다. 예를 들어:"
 
 #: src/unsafe/raw-pointers.md:33
 msgid ""
@@ -10597,8 +10021,7 @@ msgstr ""
 "* 포인터는 따라가기가 가능해야 합니다 (객체의 어느 한 부분을 가리키고 있어야 합니다).\n"
 "* 이미 반환된 객체를 가리키면 안됩니다.\n"
 "* 같은 위치에 대해 동시적인 접근이 있으면 안됩니다.\n"
-"* 참조를 캐스팅 해서 포인터를 만들었다면, 그 참조가 가리키는 객체는 살아 있어야 하며, 그 객체의 메"
-"모리를 접근하는 참조가 하나도 없어햐 합니다."
+"* 참조를 캐스팅 해서 포인터를 만들었다면, 그 참조가 가리키는 객체는 살아 있어야 하며, 그 객체의 메모리를 접근하는 참조가 하나도 없어햐 합니다."
 
 #: src/unsafe/raw-pointers.md:40
 msgid "In most cases the pointer must also be properly aligned."
@@ -10660,13 +10083,9 @@ msgstr ""
 
 #: src/unsafe/mutable-static-variables.md:32
 msgid ""
-"Using a mutable static is generally a bad idea, but there are some cases where it might make "
-"sense\n"
+"Using a mutable static is generally a bad idea, but there are some cases where it might make sense\n"
 "in low-level `no_std` code, such as implementing a heap allocator or working with some C APIs."
-msgstr ""
-"일반적으로 이야기 해서, 정적 가변 변수를 쓰는 것은 좋은 아이디어가 아닙니다. 그러나 `no_std`와 같"
-"은 저수준 코딩을 할 경우에는 필요하기도 합니다. 예를 들어 힙 할당기를 구현하거나, C API를 사용하는 "
-"게 그런 경우입니다."
+msgstr "일반적으로 이야기 해서, 정적 가변 변수를 쓰는 것은 좋은 아이디어가 아닙니다. 그러나 `no_std`와 같은 저수준 코딩을 할 경우에는 필요하기도 합니다. 예를 들어 힙 할당기를 구현하거나, C API를 사용하는 게 그런 경우입니다."
 
 #: src/unsafe/unions.md:1
 msgid "# Unions"
@@ -10674,9 +10093,7 @@ msgstr "# 유니온"
 
 #: src/unsafe/unions.md:3
 msgid "Unions are like enums, but you need to track the active field yourself:"
-msgstr ""
-"유니온 타입은 열거형(enum)과 비슷하지만, 어떤 필드에 해당하는 값을 가지고 있는지 여부를 프로그래머"
-"가 수동으로 추적해야 합니다."
+msgstr "유니온 타입은 열거형(enum)과 비슷하지만, 어떤 필드에 해당하는 값을 가지고 있는지 여부를 프로그래머가 수동으로 추적해야 합니다."
 
 #: src/unsafe/unions.md:5
 msgid ""
@@ -10700,22 +10117,16 @@ msgstr ""
 
 #: src/unsafe/unions.md:21
 msgid ""
-"Unions are very rarely needed in Rust as you can usually use an enum. They are occasionally "
-"needed\n"
+"Unions are very rarely needed in Rust as you can usually use an enum. They are occasionally needed\n"
 "for interacting with C library APIs."
-msgstr ""
-"러스트에는 열거형이 있기 때문에 유니온이 필요한 경우는 극히 드뭅니다. 유니온은 C 라이브러리 API를 "
-"사용할 때 가끔 필요합니다."
+msgstr "러스트에는 열거형이 있기 때문에 유니온이 필요한 경우는 극히 드뭅니다. 유니온은 C 라이브러리 API를 사용할 때 가끔 필요합니다."
 
 #: src/unsafe/unions.md:24
 msgid ""
 "If you just want to reinterpret bytes as a different type, you probably want\n"
 "[`std::mem::transmute`](https://doc.rust-lang.org/stable/std/mem/fn.transmute.html) or a safe\n"
 "wrapper such as the [`zerocopy`](https://crates.io/crates/zerocopy) crate."
-msgstr ""
-"바이트들을 특정 타입으로 재해석 하고 싶다면 `std::mem::transmute`](https://doc.rust-lang.org/"
-"stable/std/mem/fn.transmute.html)나 좀 더 안전한 [`zerocopy`](https://crates.io/crates/zerocopy) 크"
-"레이트를 사용하세요."
+msgstr "바이트들을 특정 타입으로 재해석 하고 싶다면 `std::mem::transmute`](https://doc.rust-lang.org/stable/std/mem/fn.transmute.html)나 좀 더 안전한 [`zerocopy`](https://crates.io/crates/zerocopy) 크레이트를 사용하세요."
 
 #: src/unsafe/calling-unsafe-functions.md:1
 msgid "# Calling Unsafe Functions"
@@ -10725,9 +10136,7 @@ msgstr "# 안전하지 않은' 함수 호출"
 msgid ""
 "A function or method can be marked `unsafe` if it has extra preconditions you\n"
 "must uphold to avoid undefined behaviour:"
-msgstr ""
-"함수나 메서드가 정의되지 않은 동작으로 빠지지 않게 하기 위해서 만족해야 하는 전제 조건이 있는 경"
-"우, 그 함수나 메서드를 `unsafe`로 표시할 수 있습니다:"
+msgstr "함수나 메서드가 정의되지 않은 동작으로 빠지지 않게 하기 위해서 만족해야 하는 전제 조건이 있는 경우, 그 함수나 메서드를 `unsafe`로 표시할 수 있습니다:"
 
 #: src/unsafe/calling-unsafe-functions.md:6
 msgid ""
@@ -10746,8 +10155,7 @@ msgid ""
 "        println!(\"emoji: {}\", emojis.get_unchecked(7..11));\n"
 "    }"
 msgstr ""
-"    // 인덱스들이 올바른 순서로 있으며, 문자열 슬라이스의 범위 안에 있고, UTF-8 시퀀스의 범위 안"
-"에\n"
+"    // 인덱스들이 올바른 순서로 있으며, 문자열 슬라이스의 범위 안에 있고, UTF-8 시퀀스의 범위 안에\n"
 "    // 있기 때문에 안전합니다.\n"
 "    unsafe {\n"
 "        println!(\"emoji: {}\", emojis.get_unchecked(0..4));\n"
@@ -10781,11 +10189,9 @@ msgstr "# '안전하지 않은' 함수 작성하기"
 
 #: src/unsafe/writing-unsafe-functions.md:3
 msgid ""
-"You can mark your own functions as `unsafe` if they require particular conditions to avoid "
-"undefined\n"
+"You can mark your own functions as `unsafe` if they require particular conditions to avoid undefined\n"
 "behaviour."
-msgstr ""
-"여러분이 작성한 함수를 사용할 때 어떤 특별한 조건을 만족해야 한다면, `unsafe`로 마킹할 수 있습니다."
+msgstr "여러분이 작성한 함수를 사용할 때 어떤 특별한 조건을 만족해야 한다면, `unsafe`로 마킹할 수 있습니다."
 
 #: src/unsafe/writing-unsafe-functions.md:6
 msgid ""
@@ -10832,10 +10238,7 @@ msgstr "참조를 사용하면 안전하게 구현할 수 있기 때문에, 실
 msgid ""
 "Note that unsafe code is allowed within an unsafe function without an `unsafe` block. We can\n"
 "prohibit this with `#[deny(unsafe_op_in_unsafe_fn)]`. Try adding it and see what happens."
-msgstr ""
-"unsafe 코드가 unsafe 함수의 내부에서 호출될 경우에는 `unsafe`블럭을 지정하지 않아도 됩니다. "
-"`unsafe`블럭을 항상 지정하도록 하고 싶다면 `#[deny(unsafe_op_in_unsafe_fn)]`를 이용하세요. 이 어트"
-"리뷰트를 추가해 보고 어떤 일이 일어나는지 확인해 보세요."
+msgstr "unsafe 코드가 unsafe 함수의 내부에서 호출될 경우에는 `unsafe`블럭을 지정하지 않아도 됩니다. `unsafe`블럭을 항상 지정하도록 하고 싶다면 `#[deny(unsafe_op_in_unsafe_fn)]`를 이용하세요. 이 어트리뷰트를 추가해 보고 어떤 일이 일어나는지 확인해 보세요."
 
 #: src/unsafe/extern-functions.md:1
 msgid "# Calling External Code"
@@ -10845,9 +10248,7 @@ msgstr "# 외부 코드 호출"
 msgid ""
 "Functions from other languages might violate the guarantees of Rust. Calling\n"
 "them is thus unsafe:"
-msgstr ""
-"다른 언어의 함수는 러스트의 보증을 위반할 수 있습니다. 따라서 이를 호출하는 것은 '안전하지 않습니"
-"다':"
+msgstr "다른 언어의 함수는 러스트의 보증을 위반할 수 있습니다. 따라서 이를 호출하는 것은 '안전하지 않습니다':"
 
 #: src/unsafe/extern-functions.md:6
 msgid ""
@@ -10871,21 +10272,15 @@ msgstr ""
 #: src/unsafe/extern-functions.md:21
 msgid ""
 "This is usually only a problem for extern functions which do things with pointers which might\n"
-"violate Rust's memory model, but in general any C function might have undefined behaviour under "
-"any\n"
+"violate Rust's memory model, but in general any C function might have undefined behaviour under any\n"
 "arbitrary circumstances."
-msgstr ""
-"이게 문제가 되는 경우는 대부분 외부 함수가 러스트의 메모리 모델을 위반하고 있을 경우입니다. 그러나 "
-"어떤 C함수라도 어떤 임의의 상황에서는 정의되지 않은 동작을 할 수 있기 때문에, 엄밀히 말해서는 모든 "
-"외부 함수에 대해서 문제입니다."
+msgstr "이게 문제가 되는 경우는 대부분 외부 함수가 러스트의 메모리 모델을 위반하고 있을 경우입니다. 그러나 어떤 C함수라도 어떤 임의의 상황에서는 정의되지 않은 동작을 할 수 있기 때문에, 엄밀히 말해서는 모든 외부 함수에 대해서 문제입니다."
 
 #: src/unsafe/extern-functions.md:25
 msgid ""
 "The `\"C\"` in this example is the ABI;\n"
 "[other ABIs are available too](https://doc.rust-lang.org/reference/items/external-blocks.html)."
-msgstr ""
-"위 예제 코드에서 `\"C\"`는 ABI를 의미합니다. [다른 ABI도 있습니다.](https://doc.rust-lang.org/"
-"reference/items/external-blocks.html)"
+msgstr "위 예제 코드에서 `\"C\"`는 ABI를 의미합니다. [다른 ABI도 있습니다.](https://doc.rust-lang.org/reference/items/external-blocks.html)"
 
 #: src/unsafe/unsafe-traits.md:1
 msgid "# Implementing Unsafe Traits"
@@ -10895,17 +10290,13 @@ msgstr "# 안전하지 않은 트레이트 구현하기"
 msgid ""
 "Like with functions, you can mark a trait as `unsafe` if the implementation must guarantee\n"
 "particular conditions to avoid undefined behaviour."
-msgstr ""
-"함수에서와 마찬가지로 트레이트도 `unsafe`로 마킹 가능합니다. 만약 그 트레이트를 구현할 때 정의되지 "
-"않은 동작을 피하기 위해 특별한 조건이 필요하다면 말이지요."
+msgstr "함수에서와 마찬가지로 트레이트도 `unsafe`로 마킹 가능합니다. 만약 그 트레이트를 구현할 때 정의되지 않은 동작을 피하기 위해 특별한 조건이 필요하다면 말이지요."
 
 #: src/unsafe/unsafe-traits.md:6
 msgid ""
 "For example, the `zerocopy` crate has an unsafe trait that looks\n"
 "[something like this](https://docs.rs/zerocopy/latest/zerocopy/trait.AsBytes.html):"
-msgstr ""
-"예를 들어 `zerocopy` 크레이트에는 [안전하지 않은 트레이트](https://docs.rs/zerocopy/latest/"
-"zerocopy/trait.AsBytes.html)가 있습니다:"
+msgstr "예를 들어 `zerocopy` 크레이트에는 [안전하지 않은 트레이트](https://docs.rs/zerocopy/latest/zerocopy/trait.AsBytes.html)가 있습니다:"
 
 #: src/unsafe/unsafe-traits.md:9
 msgid ""
@@ -10939,9 +10330,7 @@ msgstr ""
 msgid ""
 "There should be a `# Safety` section on the Rustdoc for the trait explaining the requirements for\n"
 "the trait to be safely implemented."
-msgstr ""
-"안전하지 않은 트레이트를 만들 때에는 주석에 `# Safety` 항목이 있어서 이 트레이트를 안전하게 구현하"
-"려면 어떤 요구사항들을 만족해야 하는지를 설명해야 합니다."
+msgstr "안전하지 않은 트레이트를 만들 때에는 주석에 `# Safety` 항목이 있어서 이 트레이트를 안전하게 구현하려면 어떤 요구사항들을 만족해야 하는지를 설명해야 합니다."
 
 #: src/unsafe/unsafe-traits.md:33
 msgid "The actual safety section for `AsBytes` is rather longer and more complicated."
@@ -10976,9 +10365,7 @@ msgid ""
 "Rust has great support for calling functions through a _foreign function\n"
 "interface_ (FFI). We will use this to build a safe wrapper for the `libc`\n"
 "functions you would use from C to read the filenames of a directory."
-msgstr ""
-"러스트는 _외부 기능 호출(FFI)_을 지원합니다. 우리는 이를 이용하여 디렉터리에서 파일 이름을 읽어오"
-"는 `libc` 함수에 대한 안전한 래퍼를 만들 것입니다."
+msgstr "러스트는 _외부 기능 호출(FFI)_을 지원합니다. 우리는 이를 이용하여 디렉터리에서 파일 이름을 읽어오는 `libc` 함수에 대한 안전한 래퍼를 만들 것입니다."
 
 #: src/exercises/day-3/safe-ffi-wrapper.md:7
 msgid "You will want to consult the manual pages:"
@@ -10999,10 +10386,7 @@ msgid ""
 "You will also want to browse the [`std::ffi`] module, particular for [`CStr`]\n"
 "and [`CString`] types which are used to hold NUL-terminated strings coming from\n"
 "C. The [Nomicon] also has a very useful chapter about FFI."
-msgstr ""
-"[`std::ffi`] 모듈을 탐색하는게 필요할 지도 모르겠습니다. C에서 사용되는 NUL-terminated 문자열을 담"
-"기 위한 [`CStr`]과 [`CString`] 타입을 확인해 보세요. [Nomicon]문서 또한 FFI에 대한 유용한 내용을 담"
-"고 있습니다."
+msgstr "[`std::ffi`] 모듈을 탐색하는게 필요할 지도 모르겠습니다. C에서 사용되는 NUL-terminated 문자열을 담기 위한 [`CStr`]과 [`CString`] 타입을 확인해 보세요. [Nomicon]문서 또한 FFI에 대한 유용한 내용을 담고 있습니다."
 
 #: src/exercises/day-3/safe-ffi-wrapper.md:17
 msgid ""
@@ -11028,7 +10412,8 @@ msgid ""
 "    use std::os::raw::{c_char, c_int, c_long, c_ulong, c_ushort};"
 msgstr ""
 
-#: src/exercises/day-3/safe-ffi-wrapper.md:32 src/exercises/day-3/solutions-afternoon.md:26
+#: src/exercises/day-3/safe-ffi-wrapper.md:32
+#: src/exercises/day-3/solutions-afternoon.md:26
 msgid ""
 "    // Opaque type. See https://doc.rust-lang.org/nomicon/ffi.html.\n"
 "    #[repr(C)]\n"
@@ -11038,7 +10423,8 @@ msgid ""
 "    }"
 msgstr ""
 
-#: src/exercises/day-3/safe-ffi-wrapper.md:39 src/exercises/day-3/solutions-afternoon.md:33
+#: src/exercises/day-3/safe-ffi-wrapper.md:39
+#: src/exercises/day-3/solutions-afternoon.md:33
 msgid ""
 "    // Layout as per readdir(3) and definitions in /usr/include/x86_64-linux-gnu.\n"
 "    #[repr(C)]\n"
@@ -11051,7 +10437,8 @@ msgid ""
 "    }"
 msgstr ""
 
-#: src/exercises/day-3/safe-ffi-wrapper.md:49 src/exercises/day-3/solutions-afternoon.md:43
+#: src/exercises/day-3/safe-ffi-wrapper.md:49
+#: src/exercises/day-3/solutions-afternoon.md:43
 msgid ""
 "    extern \"C\" {\n"
 "        pub fn opendir(s: *const c_char) -> *mut DIR;\n"
@@ -11061,7 +10448,8 @@ msgid ""
 "}"
 msgstr ""
 
-#: src/exercises/day-3/safe-ffi-wrapper.md:56 src/exercises/day-3/solutions-afternoon.md:50
+#: src/exercises/day-3/safe-ffi-wrapper.md:56
+#: src/exercises/day-3/solutions-afternoon.md:50
 msgid ""
 "use std::ffi::{CStr, CString, OsStr, OsString};\n"
 "use std::os::unix::ffi::OsStrExt;"
@@ -11134,9 +10522,7 @@ msgstr "* 동시성: 쓰레드, 채널, 상태 공유, `Send`와 `Sync`"
 msgid ""
 "* Android: building binaries and libraries, using AIDL, logging, and\n"
 "  interoperability with C, C++, and Java."
-msgstr ""
-"* 안드로이드: 바이너리와 라이브러리 만드는 방법, AIDL 사용법, 로깅하는 방법, C/C++, 자바와의 상호 "
-"운용성"
+msgstr "* 안드로이드: 바이너리와 라이브러리 만드는 방법, AIDL 사용법, 로깅하는 방법, C/C++, 자바와의 상호 운용성"
 
 #: src/welcome-day-4.md:10
 msgid ""
@@ -11157,18 +10543,14 @@ msgstr "# 겂없는 동시성"
 msgid ""
 "Rust has full support for concurrency using OS threads with mutexes and\n"
 "channels."
-msgstr ""
-"러스트는 동시성 지원이 막강합니다. 운영체제 레벨의 스레드를 사용하며, 뮤택스와 채널도 지원합니다."
+msgstr "러스트는 동시성 지원이 막강합니다. 운영체제 레벨의 스레드를 사용하며, 뮤택스와 채널도 지원합니다."
 
 #: src/concurrency.md:6
 msgid ""
 "The Rust type system plays an important role in making many concurrency bugs\n"
 "compile time bugs. This is often referred to as _fearless concurrency_ since you\n"
 "can rely on the compiler to ensure correctness at runtime."
-msgstr ""
-"러스트의 타입 시스템은 프로그램에 동시성 버그가 있을 경우, 컴파일 시에 에러가 발생하도록 해 줍니"
-"다. 컴파일러를 이용해서 프로그램이 수행시에 정확히 동작함을 미리 보장해 주기 때문에, 사람들은 이를 "
-"종종 _겁없는 동시성_ 이라고 합니다."
+msgstr "러스트의 타입 시스템은 프로그램에 동시성 버그가 있을 경우, 컴파일 시에 에러가 발생하도록 해 줍니다. 컴파일러를 이용해서 프로그램이 수행시에 정확히 동작함을 미리 보장해 주기 때문에, 사람들은 이를 종종 _겁없는 동시성_ 이라고 합니다."
 
 #: src/concurrency/threads.md:1
 msgid "# Threads"
@@ -11220,16 +10602,13 @@ msgstr ""
 msgid ""
 "* Notice that the thread is stopped before it reaches 10 — the main thread is\n"
 "  not waiting."
-msgstr ""
-"* 메인 스레드가 자식 스레드를 기다리지 않기 때문에 자식 스레드의 for문은 10까지 가지 않습니다."
+msgstr "* 메인 스레드가 자식 스레드를 기다리지 않기 때문에 자식 스레드의 for문은 10까지 가지 않습니다."
 
 #: src/concurrency/threads.md:35
 msgid ""
 "* Use `let handle = thread::spawn(...)` and later `handle.join()` to wait for\n"
 "  the thread to finish."
-msgstr ""
-"* 만약 메인 스레드가 자식 스레드가 끝날 때 까지 기다리기를 원한다면 `let handle = thread::"
-"spawn(...)`으로 스레드를 선언한 후 `handle.join()`로 연결하여 사용합니다."
+msgstr "* 만약 메인 스레드가 자식 스레드가 끝날 때 까지 기다리기를 원한다면 `let handle = thread::spawn(...)`으로 스레드를 선언한 후 `handle.join()`로 연결하여 사용합니다."
 
 #: src/concurrency/threads.md:38
 msgid "* Trigger a panic in the thread, notice how this doesn't affect `main`."
@@ -11239,9 +10618,7 @@ msgstr "* 자식 스레드에서 발생한 패닉이 메인 스레드에는 영
 msgid ""
 "* Use the `Result` return value from `handle.join()` to get access to the panic\n"
 "  payload. This is a good time to talk about [`Any`]."
-msgstr ""
-"* `handle.join()`사용시 `Result` 반환값을 통해 패닉의 추가정보에 접근할 수 있습니다. 이 시점에서 "
-"[`Any`]에 대해 이야기를 해 보면 좋습니다."
+msgstr "* `handle.join()`사용시 `Result` 반환값을 통해 패닉의 추가정보에 접근할 수 있습니다. 이 시점에서 [`Any`]에 대해 이야기를 해 보면 좋습니다."
 
 #: src/concurrency/threads.md:43
 msgid "[`Any`]: https://doc.rust-lang.org/std/any/index.html"
@@ -11305,19 +10682,15 @@ msgstr ""
 msgid ""
 "<details>\n"
 "    \n"
-"* The reason for that is that when the `thread::scope` function completes, all the threads are "
-"guaranteed to be joined, so they can return borrowed data.\n"
-"* Normal Rust borrowing rules apply: you can either borrow mutably by one thread, or immutably by "
-"any number of threads.\n"
+"* The reason for that is that when the `thread::scope` function completes, all the threads are guaranteed to be joined, so they can return borrowed data.\n"
+"* Normal Rust borrowing rules apply: you can either borrow mutably by one thread, or immutably by any number of threads.\n"
 "    \n"
 "</details>"
 msgstr ""
 "<details>\n"
 "    \n"
-"* `thread::scope` 함수가 완료되면 그 안에서 생성된 모든 스레드들이 종료했음이 보장되기 때문에, 그 "
-"때 빌렸던 데이터들을 다시 반환할 수 있기 때문입니다.\n"
-"* 일반적인 러스트의 빌림 규칙이 적용됩니다: 한 스레드에 의한 가변 빌림 또는 여러 스레드에 대한 불"
-"변 빌림중 하나만 가능합니다.\n"
+"* `thread::scope` 함수가 완료되면 그 안에서 생성된 모든 스레드들이 종료했음이 보장되기 때문에, 그 때 빌렸던 데이터들을 다시 반환할 수 있기 때문입니다.\n"
+"* 일반적인 러스트의 빌림 규칙이 적용됩니다: 한 스레드에 의한 가변 빌림 또는 여러 스레드에 대한 불변 빌림중 하나만 가능합니다.\n"
 "    \n"
 "</details>"
 
@@ -11331,8 +10704,7 @@ msgid ""
 "are connected via the channel, but you only see the end-points."
 msgstr ""
 "러스트의 채널은 `Sender<T>` 와 `Receiver<T>` 두 부분으로 구성됩니다.\n"
-"이 둘은 채널을 통해 서로 연결되어 있지만, 우리는 채널을 볼 수는 없고 이 양 끝단만을 사용하게 됩니"
-"다."
+"이 둘은 채널을 통해 서로 연결되어 있지만, 우리는 채널을 볼 수는 없고 이 양 끝단만을 사용하게 됩니다."
 
 #: src/concurrency/channels.md:6
 msgid ""
@@ -11370,18 +10742,14 @@ msgstr ""
 
 #: src/concurrency/channels.md:27
 msgid ""
-"* `mpsc` stands for Multi-Producer, Single-Consumer. `Sender` and `SyncSender` implement `Clone` "
-"(so\n"
+"* `mpsc` stands for Multi-Producer, Single-Consumer. `Sender` and `SyncSender` implement `Clone` (so\n"
 "  you can make multiple producers) but `Receiver` does not.\n"
-"* `send()` and `recv()` return `Result`. If they return `Err`, it means the counterpart `Sender` "
-"or\n"
+"* `send()` and `recv()` return `Result`. If they return `Err`, it means the counterpart `Sender` or\n"
 "  `Receiver` is dropped and the channel is closed."
 msgstr ""
-"* `mpsc`는 “Multi-Produce, Single-Consumer”를 의미합니다. `Sender`와 `SyncSender`는 `Clone`을 구현"
-"하지만 (즉, 여러개의 producer를 만들수 있습니다)\n"
+"* `mpsc`는 “Multi-Produce, Single-Consumer”를 의미합니다. `Sender`와 `SyncSender`는 `Clone`을 구현하지만 (즉, 여러개의 producer를 만들수 있습니다)\n"
 "  `Receiver`는 `Clone`을 구현하지 않습니다.\n"
-"* `send()`와 `recv()`는 `Result`를 반환합니다. 만일 `Err`가 반환된다면, 상대방의 `Sender`또는 "
-"`Receiver`가 삭제되었고 채널이 닫혔다는 뜻입니다."
+"* `send()`와 `recv()`는 `Result`를 반환합니다. 만일 `Err`가 반환된다면, 상대방의 `Sender`또는 `Receiver`가 삭제되었고 채널이 닫혔다는 뜻입니다."
 
 #: src/concurrency/channels/unbounded.md:1
 msgid "# Unbounded Channels"
@@ -11391,7 +10759,8 @@ msgstr "# 무경계 채널(Unbounded Channels)"
 msgid "You get an unbounded and asynchronous channel with `mpsc::channel()`:"
 msgstr "`mpsc::channel()` 함수는 경계가 없는 비동기 채널을 생성합니다: "
 
-#: src/concurrency/channels/unbounded.md:5 src/concurrency/channels/bounded.md:5
+#: src/concurrency/channels/unbounded.md:5
+#: src/concurrency/channels/bounded.md:5
 msgid ""
 "```rust,editable\n"
 "use std::sync::mpsc;\n"
@@ -11399,7 +10768,8 @@ msgid ""
 "use std::time::Duration;"
 msgstr ""
 
-#: src/concurrency/channels/unbounded.md:13 src/concurrency/channels/bounded.md:13
+#: src/concurrency/channels/unbounded.md:13
+#: src/concurrency/channels/bounded.md:13
 msgid ""
 "    thread::spawn(move || {\n"
 "        let thread_id = thread::current().id();\n"
@@ -11460,8 +10830,7 @@ msgid ""
 "  takes care to deallocate `T` when the last reference is dropped,\n"
 "* [`Mutex<T>`][2]: ensures mutually exclusive access to the `T` value."
 msgstr ""
-"* [`Arc<T>`][1], `T`에 대한 아토믹 참조 카운트: 이 참조는 다수의 스레드 사이에서 공유될 수 있고, 참"
-"조하던 마지막 스레드가 종료할 경우 `T`를 반환합니다.\n"
+"* [`Arc<T>`][1], `T`에 대한 아토믹 참조 카운트: 이 참조는 다수의 스레드 사이에서 공유될 수 있고, 참조하던 마지막 스레드가 종료할 경우 `T`를 반환합니다.\n"
 "* [`Mutex<T>`][2]: `T`값에 대한 상호 배제 엑세스를 보장합니다."
 
 #: src/concurrency/shared_state.md:10
@@ -11478,9 +10847,7 @@ msgstr "# `Arc`"
 
 #: src/concurrency/shared_state/arc.md:3
 msgid "[`Arc<T>`][1] allows shared read-only access via its `clone` method:"
-msgstr ""
-"[`Arc<T>`][1]의 `clone` 메서드를 이용하면 여러 스레드가 한 데이터를 동시에 (_역주_: 그리고 안전하"
-"게. 스레드가 하나라도 살아있는 동안에는 `T`가 반환되지 않음) 읽을 수 있습니다:"
+msgstr "[`Arc<T>`][1]의 `clone` 메서드를 이용하면 여러 스레드가 한 데이터를 동시에 (_역주_: 그리고 안전하게. 스레드가 하나라도 살아있는 동안에는 `T`가 반환되지 않음) 읽을 수 있습니다:"
 
 #: src/concurrency/shared_state/arc.md:5
 msgid ""
@@ -11521,20 +10888,15 @@ msgid ""
 "  operations.\n"
 "* `Arc<T>` implements `Clone` whether or not `T` does. It implements `Send` and `Sync` iff `T`\n"
 "  implements them both.\n"
-"* `Arc::clone()` has the cost of atomic operations that get executed, but after that the use of "
-"the\n"
+"* `Arc::clone()` has the cost of atomic operations that get executed, but after that the use of the\n"
 "  `T` is free.\n"
 "* Beware of reference cycles, `Arc` does not use a garbage collector to detect them.\n"
 "    * `std::sync::Weak` can help."
 msgstr ""
-"* `Arc`는 \"Atomic Reference Counted\"를 의미하며, 스레드 안정성을 보장하는 `Rc`라고 생각하면 됩니"
-"다.\n"
-"* `T`가 `Clone`을 구현하든 안하든 `Arc<T>`는 `Clone`을 구현합니다. `Send`와 `Sync`는 `T`가 이들을 "
-"구현하는 경우에만 구현됩니다.\n"
-"* `Arc::clone()`는 아토믹 연산을 수행하기 때문에 그 때 코스트가 좀 있지만, 일단 `clone()`이 끝난 "
-"후 `T`를 사용하는 대에는 아무런 오버헤드가 없습니다.\n"
-"* 순환 참조가 발생하지 않도록 주의해야 합니다. 러스트는 순환 참조를 감지하는 가비지 컬랙터가 없습니"
-"다.\n"
+"* `Arc`는 \"Atomic Reference Counted\"를 의미하며, 스레드 안정성을 보장하는 `Rc`라고 생각하면 됩니다.\n"
+"* `T`가 `Clone`을 구현하든 안하든 `Arc<T>`는 `Clone`을 구현합니다. `Send`와 `Sync`는 `T`가 이들을 구현하는 경우에만 구현됩니다.\n"
+"* `Arc::clone()`는 아토믹 연산을 수행하기 때문에 그 때 코스트가 좀 있지만, 일단 `clone()`이 끝난 후 `T`를 사용하는 대에는 아무런 오버헤드가 없습니다.\n"
+"* 순환 참조가 발생하지 않도록 주의해야 합니다. 러스트는 순환 참조를 감지하는 가비지 컬랙터가 없습니다.\n"
 "    * 순환 참조를 피하는데 `std::sync::Weak`가 도움이 될 것입니다."
 
 #: src/concurrency/shared_state/mutex.md:1
@@ -11545,9 +10907,7 @@ msgstr "# `Mutex`"
 msgid ""
 "[`Mutex<T>`][1] ensures mutual exclusion _and_ allows mutable access to `T`\n"
 "behind a read-only interface:"
-msgstr ""
-"[`Mutex<T>`][1]를 이용하면 불변 참조를 통해서도 `T`의 값을 수정할 수가 있으며, _이에 더해서_ 한 번"
-"에 한 스레드만 `T`의 값을 접근(읽거나 쓰거나)함을 보장해 줍니다:"
+msgstr "[`Mutex<T>`][1]를 이용하면 불변 참조를 통해서도 `T`의 값을 수정할 수가 있으며, _이에 더해서_ 한 번에 한 스레드만 `T`의 값을 접근(읽거나 쓰거나)함을 보장해 줍니다:"
 
 #: src/concurrency/shared_state/mutex.md:6
 msgid ""
@@ -11600,34 +10960,26 @@ msgid ""
 "    \n"
 "* `Mutex` in Rust looks like a collection with just one element - the protected data.\n"
 "    * It is not possible to forget to acquire the mutex before accessing the protected data.\n"
-"* You can get an `&mut T` from an `&Mutex<T>` by taking the lock. The `MutexGuard` ensures that "
-"the\n"
+"* You can get an `&mut T` from an `&Mutex<T>` by taking the lock. The `MutexGuard` ensures that the\n"
 "  `&mut T` doesn't outlive the lock being held.\n"
 "* `Mutex<T>` implements both `Send` and `Sync` iff `T` implements `Send`.\n"
 "* A read-write lock counterpart - `RwLock`.\n"
 "* Why does `lock()` return a `Result`? \n"
-"    * If the thread that held the `Mutex` panicked, the `Mutex` becomes \"poisoned\" to signal "
-"that\n"
-"      the data it protected might be in an inconsistent state. Calling `lock()` on a poisoned "
-"mutex\n"
+"    * If the thread that held the `Mutex` panicked, the `Mutex` becomes \"poisoned\" to signal that\n"
+"      the data it protected might be in an inconsistent state. Calling `lock()` on a poisoned mutex\n"
 "      fails with a [`PoisonError`]. You can call `into_inner()` on the error to recover the data\n"
 "      regardless."
 msgstr ""
 "<details>\n"
 "    \n"
-"* 러스트의 `Mutex`는 오직 하나의 데이터만 담을 수 있는 컬렉션처럼 볼 수도 있습니다. 다른 컬렉션과 "
-"다른 점은, 그 데이터가 동시성 문제로부터 자유롭다는 점입니다.\n"
-"  * `Mutex`는 뮤텍스를 획득하지 않으면 보호된 데이터에 접근하는 것이 불가능  하도록 디자인 되어 있"
-"습니다.\n"
-"* `&Mutex<T>`에 대해 lock을 획득하면 `&mut T`를 얻을 수 있습니다. `MutexGuard`는 `&mut T`가 획득한 "
-"lock보다 오래 살아남지 않음을 보장합니다.\n"
+"* 러스트의 `Mutex`는 오직 하나의 데이터만 담을 수 있는 컬렉션처럼 볼 수도 있습니다. 다른 컬렉션과 다른 점은, 그 데이터가 동시성 문제로부터 자유롭다는 점입니다.\n"
+"  * `Mutex`는 뮤텍스를 획득하지 않으면 보호된 데이터에 접근하는 것이 불가능  하도록 디자인 되어 있습니다.\n"
+"* `&Mutex<T>`에 대해 lock을 획득하면 `&mut T`를 얻을 수 있습니다. `MutexGuard`는 `&mut T`가 획득한 lock보다 오래 살아남지 않음을 보장합니다.\n"
 "* `Mutex<T>`는 오직 `T`가 `Send`를 구현하는 경우에만 `Send`와 `Sync`를 구현합니다.\n"
 "* 읽기-쓰기 lock은 `RwLock`을 사용합니다.\n"
 "* 왜 `lock()`이 `Result`를 반환할까요?\n"
-"  * `Mutex`를 획득한 스레드에서 패닉이 발생하면, 데이터가 올바르지 않은 상황이 될 수 있습니다. 이"
-"를 `Mutex`가 \"중독(poisoned)\" 되었다고 표현하며,\n"
-"    중독된 뮤텍스에서 `lock()`을 호출하면 실패하고 [`PoisonError`]가 발생합니다. 이러한 오류로부터 "
-"데이터를 복구하기 위해 `into_inner()`를 호출할 수 있습니다."
+"  * `Mutex`를 획득한 스레드에서 패닉이 발생하면, 데이터가 올바르지 않은 상황이 될 수 있습니다. 이를 `Mutex`가 \"중독(poisoned)\" 되었다고 표현하며,\n"
+"    중독된 뮤텍스에서 `lock()`을 호출하면 실패하고 [`PoisonError`]가 발생합니다. 이러한 오류로부터 데이터를 복구하기 위해 `into_inner()`를 호출할 수 있습니다."
 
 #: src/concurrency/shared_state/mutex.md:43
 msgid ""
@@ -11730,16 +11082,13 @@ msgstr ""
 msgid ""
 "* `v` is wrapped in both `Arc` and `Mutex`, because their concerns are orthogonal.\n"
 "  * Wrapping a `Mutex` in an `Arc` is a common pattern to share mutable state between threads.\n"
-"* `v: Arc<_>` needs to be cloned as `v2` before it can be moved into another thread. Note `move` "
-"was added to the lambda signature.\n"
+"* `v: Arc<_>` needs to be cloned as `v2` before it can be moved into another thread. Note `move` was added to the lambda signature.\n"
 "* Blocks are introduced to narrow the scope of the `LockGuard` as much as possible.\n"
 "* We still need to acquire the `Mutex` to print our `Vec`."
 msgstr ""
-"* `v`는 `Arc`와 `Mutex` 모두에 포함되어 있습니다. 이는 `Arc`와 `Mutex`가 서로 완전히 다른 문제를 위"
-"한 도구이기 때문입니다.\n"
+"* `v`는 `Arc`와 `Mutex` 모두에 포함되어 있습니다. 이는 `Arc`와 `Mutex`가 서로 완전히 다른 문제를 위한 도구이기 때문입니다.\n"
 "  * `Mutex`를 `Arc`로 래핑하는 것은 가변 상태를 스레드들 간에 공유할 때 흔히 사용하는 패턴입니다.\n"
-"* `v: Arc<_>`를 다른 스레드에서 사용하려면, 먼저 `v2`로 복사를 하고 이를 그 스레드로 이동 해야 합니"
-"다. 그래서 람다의 시그니처에 `move`가 있는 것입니다.\n"
+"* `v: Arc<_>`를 다른 스레드에서 사용하려면, 먼저 `v2`로 복사를 하고 이를 그 스레드로 이동 해야 합니다. 그래서 람다의 시그니처에 `move`가 있는 것입니다.\n"
 "* 블록은 `LockGuard`의 범위를 최대한 좁히기 위해 사용되었습니다.\n"
 "* `Vec`을 단순히 출력하기 위해서도 여전히 `Mutex`를 획득해야 합니다."
 
@@ -11749,9 +11098,7 @@ msgstr "# `Send`와 `Sync`"
 
 #: src/concurrency/send-sync.md:3
 msgid "How does Rust know to forbid shared access across thread? The answer is in two traits:"
-msgstr ""
-"러스트는 어떻게 해서 스레드 간에 특정 데이터 타입이 공유될 수 있거나, 안된다는 것을 알까요? 정답은 "
-"다음 두 트레이트에 있습니다:"
+msgstr "러스트는 어떻게 해서 스레드 간에 특정 데이터 타입이 공유될 수 있거나, 안된다는 것을 알까요? 정답은 다음 두 트레이트에 있습니다:"
 
 #: src/concurrency/send-sync.md:5
 msgid ""
@@ -11765,16 +11112,12 @@ msgstr ""
 
 #: src/concurrency/send-sync.md:10
 msgid ""
-"`Send` and `Sync` are [unsafe traits][3]. The compiler will automatically derive them for your "
-"types\n"
-"as long as they only contain `Send` and `Sync` types. You can also implement them manually when "
-"you\n"
+"`Send` and `Sync` are [unsafe traits][3]. The compiler will automatically derive them for your types\n"
+"as long as they only contain `Send` and `Sync` types. You can also implement them manually when you\n"
 "know it is valid."
 msgstr ""
-"`Send`와 `Sync` 트레이트는 [안전하지 않은 트레이트][3]입니다. 컴파일러는 타입의 요소들이 모두 "
-"`Send`와 `Sync` 타입이면\n"
-"자동으로 이 트레이트들을 적용시켜 줍니다. 물론 여러분 스스로 맞다고 알고 있다면 직접 구현해도 됩니"
-"다."
+"`Send`와 `Sync` 트레이트는 [안전하지 않은 트레이트][3]입니다. 컴파일러는 타입의 요소들이 모두 `Send`와 `Sync` 타입이면\n"
+"자동으로 이 트레이트들을 적용시켜 줍니다. 물론 여러분 스스로 맞다고 알고 있다면 직접 구현해도 됩니다."
 
 #: src/concurrency/send-sync.md:14
 msgid ""
@@ -11793,8 +11136,7 @@ msgid ""
 "  \n"
 "</details>"
 msgstr ""
-"* `Sync`와 `Send`는 어떤 타입이 특정한 스레드-안전 속성을 가짐을 나타내는 마커로 생각할 수 있습니"
-"다.\n"
+"* `Sync`와 `Send`는 어떤 타입이 특정한 스레드-안전 속성을 가짐을 나타내는 마커로 생각할 수 있습니다.\n"
 "* 이 두 트레이트는 제너릭에서 제약 조건을 나타내는 트레이트로 사용될 수도 있습니다.\n"
 "\n"
 "</details>"
@@ -11814,8 +11156,7 @@ msgid ""
 "and deallocate it in another."
 msgstr ""
 "소유권을 다른 스레드로 이동하면 소멸자가 해당 스레드에서 실행됩니다.  \n"
-"여기서 의문은 \"언제 한 스레드에서 값을 할당하고 다른 스레드에서 값을 할당 해제할 수 있는가\" 입니"
-"다. "
+"여기서 의문은 \"언제 한 스레드에서 값을 할당하고 다른 스레드에서 값을 할당 해제할 수 있는가\" 입니다. "
 
 #: src/concurrency/send-sync/send.md:9
 msgid "[1]: https://doc.rust-lang.org/std/marker/trait.Send.html"
@@ -11844,24 +11185,12 @@ msgid "[1]: https://doc.rust-lang.org/std/marker/trait.Sync.html"
 msgstr ""
 
 #: src/concurrency/send-sync/sync.md:14
-msgid ""
-"This statement is essentially a shorthand way of saying that if a type is thread-safe for shared "
-"use, it is also thread-safe to pass references of it across threads."
-msgstr ""
-"위 문장을 풀어서 이야기 하면, 어떤 타입이 스레드 간에 공유되어서 사용되기에 안전하다면 그 타입의 참"
-"조 타입은 스레드 간에 이동 가능하다는 것입니다."
+msgid "This statement is essentially a shorthand way of saying that if a type is thread-safe for shared use, it is also thread-safe to pass references of it across threads."
+msgstr "위 문장을 풀어서 이야기 하면, 어떤 타입이 스레드 간에 공유되어서 사용되기에 안전하다면 그 타입의 참조 타입은 스레드 간에 이동 가능하다는 것입니다."
 
 #: src/concurrency/send-sync/sync.md:16
-msgid ""
-"This is because if a type is Sync it means that it can be shared across multiple threads without "
-"the risk of data races or other synchronization issues, so it is safe to move it to another "
-"thread. A reference to the type is also safe to move to another thread, because the data it "
-"references can be accessed from any thread safely."
-msgstr ""
-"이는 다음과 같이 증명할 수 있습니다: 어떤 타입이 `Sync`라는 말은 곧 그 타입이 여러 스레드들 사이에"
-"서 데이터 레이스나 여타 동기화 문제 없이 공유 가능하다는 말입니다. 스레드 간 공유가 안전하다면, 스"
-"레드간 이동도 안전할 수 밖에 없습니다. 어떤 타입의 스레드간 이동이 안전하다면, 그 타입의 참조 또한 "
-"스레드간 이동이 안전할 수 밖에 없습니다."
+msgid "This is because if a type is Sync it means that it can be shared across multiple threads without the risk of data races or other synchronization issues, so it is safe to move it to another thread. A reference to the type is also safe to move to another thread, because the data it references can be accessed from any thread safely."
+msgstr "이는 다음과 같이 증명할 수 있습니다: 어떤 타입이 `Sync`라는 말은 곧 그 타입이 여러 스레드들 사이에서 데이터 레이스나 여타 동기화 문제 없이 공유 가능하다는 말입니다. 스레드 간 공유가 안전하다면, 스레드간 이동도 안전할 수 밖에 없습니다. 어떤 타입의 스레드간 이동이 안전하다면, 그 타입의 참조 또한 스레드간 이동이 안전할 수 밖에 없습니다."
 
 #: src/concurrency/send-sync/examples.md:1
 msgid "# Examples"
@@ -11905,9 +11234,7 @@ msgstr ""
 msgid ""
 "These types can be moved to other threads, but they're not thread-safe.\n"
 "Typically because of interior mutability:"
-msgstr ""
-"아래 타입들은 다른 스레드로 이동될 수 있지만 내부적으로 값이 변경될 수 있기 때문에 스레드 안전하지 "
-"않습니다."
+msgstr "아래 타입들은 다른 스레드로 이동될 수 있지만 내부적으로 값이 변경될 수 있기 때문에 스레드 안전하지 않습니다."
 
 #: src/concurrency/send-sync/examples.md:22
 msgid ""
@@ -11929,9 +11256,7 @@ msgstr "아래 타입들은 스레드 안전하지만 다른 스레드로 이동
 msgid ""
 "* `MutexGuard<T>`: Uses OS level primitives which must be deallocated on the\n"
 "  thread which created them."
-msgstr ""
-"* `MutexGuard<T>`: 내부적으로, 운영체제가 제공하는 primitive를 사용하는데, 이 primitive는 생성된 스"
-"레드에서 해제가 이루어져야 합니다. (_역주_: 그래서 다른 스레드로 옮길 수 없습니다.)"
+msgstr "* `MutexGuard<T>`: 내부적으로, 운영체제가 제공하는 primitive를 사용하는데, 이 primitive는 생성된 스레드에서 해제가 이루어져야 합니다. (_역주_: 그래서 다른 스레드로 옮길 수 없습니다.)"
 
 #: src/concurrency/send-sync/examples.md:34
 msgid "## `!Send + !Sync`"
@@ -11967,9 +11292,7 @@ msgstr "* 식사하는 철학자 문제: 고적적인 동시성 문제입니다.
 msgid ""
 "* Multi-threaded link checker: a larger project where you'll use Cargo to\n"
 "  download dependencies and then check links in parallel."
-msgstr ""
-"* 멀티 스레드 링크 검사기: 병렬적으로 웹페이지의 링크들을 체크합니다. 카고를 통해 몇 가지 의존성들"
-"을 다운도르 받아야 하는 큰 프로젝트 입니다."
+msgstr "* 멀티 스레드 링크 검사기: 병렬적으로 웹페이지의 링크들을 체크합니다. 카고를 통해 몇 가지 의존성들을 다운도르 받아야 하는 큰 프로젝트 입니다."
 
 #: src/exercises/day-4/dining-philosophers.md:1
 msgid "# Dining Philosophers"
@@ -12005,8 +11328,7 @@ msgid ""
 "and test that `cargo run` does not deadlock:"
 msgstr ""
 "이번 훈련에서는 [카고 설치하기](../../cargo/running-locally.md)가 필요합니다.\n"
-"아래 코드를 복사해서 `src/main.rs`에 붙여놓고 빈 부분을 채우고, `cargo run` 커맨드로 테스트 해서 교"
-"착상태(데드락)가 발생하지 않는지 확인합니다:"
+"아래 코드를 복사해서 `src/main.rs`에 붙여놓고 빈 부분을 채우고, `cargo run` 커맨드로 테스트 해서 교착상태(데드락)가 발생하지 않는지 확인합니다:"
 
 #: src/exercises/day-4/dining-philosophers.md:17
 msgid ""
@@ -12017,7 +11339,8 @@ msgid ""
 "use std::time::Duration;"
 msgstr ""
 
-#: src/exercises/day-4/dining-philosophers.md:23 src/exercises/day-4/solutions-morning.md:28
+#: src/exercises/day-4/dining-philosophers.md:23
+#: src/exercises/day-4/solutions-morning.md:28
 msgid "struct Fork;"
 msgstr ""
 
@@ -12051,7 +11374,8 @@ msgid ""
 "}"
 msgstr ""
 
-#: src/exercises/day-4/dining-philosophers.md:46 src/exercises/day-4/solutions-morning.md:60
+#: src/exercises/day-4/dining-philosophers.md:46
+#: src/exercises/day-4/solutions-morning.md:60
 msgid ""
 "static PHILOSOPHERS: &[&str] =\n"
 "    &[\"Socrates\", \"Plato\", \"Aristotle\", \"Thales\", \"Pythagoras\"];"
@@ -12097,9 +11421,7 @@ msgstr ""
 msgid ""
 "For this, you will need an HTTP client such as [`reqwest`][1]. Create a new\n"
 "Cargo project and `reqwest` it as a dependency with:"
-msgstr ""
-"이를 위해서 [`reqwest`][1]와 같은 HTTP 클라이언트가 필요합니다. 새로운 로컬 프로젝트를 만들고 "
-"[`reqwest`][1]를 의존성에 추가하십시요"
+msgstr "이를 위해서 [`reqwest`][1]와 같은 HTTP 클라이언트가 필요합니다. 새로운 로컬 프로젝트를 만들고 [`reqwest`][1]를 의존성에 추가하십시요"
 
 #: src/exercises/day-4/link-checker.md:11
 msgid ""
@@ -12250,10 +11572,8 @@ msgid ""
 "  `www.google.org` domain. Put an upper limit of 100 pages or so so that you\n"
 "  don't end up being blocked by the site."
 msgstr ""
-"* 스레드를 사용하여 링크를 병렬로 확인합니다: URL을 채널로 보내서 몇 개의 스레드가 URL을 병렬로 체"
-"크하도록 합니다.\n"
-"* `www.google.org`도메인의 모든 페이지를 재귀적으로 확인하기 위해 코드를 확장해서 작성합니다: 차단"
-"당하지 않도록 100페이지 정도로 제한을 두시기 바랍니다."
+"* 스레드를 사용하여 링크를 병렬로 확인합니다: URL을 채널로 보내서 몇 개의 스레드가 URL을 병렬로 체크하도록 합니다.\n"
+"* `www.google.org`도메인의 모든 페이지를 재귀적으로 확인하기 위해 코드를 확장해서 작성합니다: 차단당하지 않도록 100페이지 정도로 제한을 두시기 바랍니다."
 
 #: src/exercises/day-4/link-checker.md:104
 msgid ""
@@ -12271,9 +11591,7 @@ msgid ""
 "Rust is supported for native platform development on Android. This means that\n"
 "you can write new operating system services in Rust, as well as extending\n"
 "existing services."
-msgstr ""
-"러스트는 안드로이드 네이티브 플랫폼 개발을 지원합니다. 기존의 OS 서비스를 확장하거나, 새로운 서비스"
-"를 만드는데 러스트를 쓸 수 있습니다."
+msgstr "러스트는 안드로이드 네이티브 플랫폼 개발을 지원합니다. 기존의 OS 서비스를 확장하거나, 새로운 서비스를 만드는데 러스트를 쓸 수 있습니다."
 
 #: src/android/setup.md:1
 msgid "# Setup"
@@ -12283,9 +11601,7 @@ msgstr "# 설치"
 msgid ""
 "We will be using an Android Virtual Device to test our code. Make sure you have\n"
 "access to one or create a new one with:"
-msgstr ""
-"안드로이드 가상 디바이스(Android Virtual Device)를 사용하여 여러분의 코드를 수행할 겁니다. 새로운 "
-"가상 디바이스를 생성하려면 아래의 명령어를 사용하세요."
+msgstr "안드로이드 가상 디바이스(Android Virtual Device)를 사용하여 여러분의 코드를 수행할 겁니다. 새로운 가상 디바이스를 생성하려면 아래의 명령어를 사용하세요."
 
 #: src/android/setup.md:6
 msgid ""
@@ -12314,34 +11630,23 @@ msgstr "안드로이드 빌드 시스템(Soong)은 다음과 같은 여러 모
 
 #: src/android/build-rules.md:5
 msgid ""
-"| Module Type       | "
-"Description                                                                                        "
-"|\n"
+"| Module Type       | Description                                                                                        |\n"
 "|-------------------|----------------------------------------------------------------------------------------------------|\n"
-"| `rust_binary`     | Produces a Rust "
-"binary.                                                                            |\n"
-"| `rust_library`    | Produces a Rust library, and provides both `rlib` and `dylib` "
-"variants.                            |\n"
-"| `rust_ffi`        | Produces a Rust C library usable by `cc` modules, and provides both static "
-"and shared variants.    |\n"
-"| `rust_proc_macro` | Produces a `proc-macro` Rust library. These are analogous to compiler "
-"plugins.                     |\n"
-"| `rust_test`       | Produces a Rust test binary that uses the standard Rust test "
-"harness.                              |\n"
-"| `rust_fuzz`       | Produces a Rust fuzz binary leveraging "
-"`libfuzzer`.                                                |\n"
-"| `rust_protobuf`   | Generates source and produces a Rust library that provides an interface for "
-"a particular protobuf. |\n"
-"| `rust_bindgen`    | Generates source and produces a Rust library containing Rust bindings to C "
-"libraries.              |"
+"| `rust_binary`     | Produces a Rust binary.                                                                            |\n"
+"| `rust_library`    | Produces a Rust library, and provides both `rlib` and `dylib` variants.                            |\n"
+"| `rust_ffi`        | Produces a Rust C library usable by `cc` modules, and provides both static and shared variants.    |\n"
+"| `rust_proc_macro` | Produces a `proc-macro` Rust library. These are analogous to compiler plugins.                     |\n"
+"| `rust_test`       | Produces a Rust test binary that uses the standard Rust test harness.                              |\n"
+"| `rust_fuzz`       | Produces a Rust fuzz binary leveraging `libfuzzer`.                                                |\n"
+"| `rust_protobuf`   | Generates source and produces a Rust library that provides an interface for a particular protobuf. |\n"
+"| `rust_bindgen`    | Generates source and produces a Rust library containing Rust bindings to C libraries.              |"
 msgstr ""
 "| Module Type       | Description                                          |\n"
 "|-------------------|------------------------------------------------------|\n"
 "| `rust_binary`     | 러스트 바이너리를 생성합니다.|\n"
 "| `rust_library`    | 러스트 라이브러리(rlib혹은 dylib)를 생성합니다.|\n"
 "| `rust_ffi`        | cc 모듈에서 사용할 수 있는 C library (정적 혹은 동적)를 생성합니다.|\n"
-"| `rust_proc_macro` | `proc-macro`를 구현하는 러스트 라이브러리를 생성합니다. 컴파일러의 플러그인으"
-"로 생각해도 좋습니다.|\n"
+"| `rust_proc_macro` | `proc-macro`를 구현하는 러스트 라이브러리를 생성합니다. 컴파일러의 플러그인으로 생각해도 좋습니다.|\n"
 "| `rust_test`       | 표준 러스트 테스트 러너를 사용하는 테스트 바이너리를 생성합니다.|\n"
 "| `rust_fuzz`       | `libfuzzer`를 사용하여 fuzz 바이너리를 생성합니다.|\n"
 "| `rust_protobuf`   | 프로토버프(protobuf) 인터페이스를 제공하는 러스트 라이브러리를 생성합니다.|\n"
@@ -12522,9 +11827,7 @@ msgstr "# AIDL"
 msgid ""
 "The [Android Interface Definition Language\n"
 "(AIDL)](https://developer.android.com/guide/components/aidl) is supported in Rust:"
-msgstr ""
-"러스트는 [안드로이드 인터페이스 정의 언어(AIDL)](https://developer.android.com/guide/components/"
-"aidl)를 지원합니다:"
+msgstr "러스트는 [안드로이드 인터페이스 정의 언어(AIDL)](https://developer.android.com/guide/components/aidl)를 지원합니다:"
 
 #: src/android/aidl.md:6
 msgid ""
@@ -12586,8 +11889,7 @@ msgstr ""
 msgid ""
 "Add `vendor_available: true` if your AIDL file is used by a binary in the vendor\n"
 "partition."
-msgstr ""
-"AIDL 파일이 벤더 파티션에 있는 바이너리에서 사용될 경우 `vendor_available: true`를 추가합니다."
+msgstr "AIDL 파일이 벤더 파티션에 있는 바이너리에서 사용될 경우 `vendor_available: true`를 추가합니다."
 
 #: src/android/aidl/implementation.md:1
 msgid "# Service Implementation"
@@ -12605,8 +11907,7 @@ msgstr ""
 msgid ""
 "```rust,ignore\n"
 "//! Implementation of the `IBirthdayService` AIDL interface.\n"
-"use com_example_birthdayservice::aidl::com::example::birthdayservice::IBirthdayService::"
-"IBirthdayService;\n"
+"use com_example_birthdayservice::aidl::com::example::birthdayservice::IBirthdayService::IBirthdayService;\n"
 "use com_example_birthdayservice::binder;"
 msgstr ""
 
@@ -12632,7 +11933,8 @@ msgid ""
 "```"
 msgstr ""
 
-#: src/android/aidl/implementation.md:26 src/android/aidl/server.md:28 src/android/aidl/client.md:37
+#: src/android/aidl/implementation.md:26 src/android/aidl/server.md:28
+#: src/android/aidl/client.md:37
 msgid "*birthday_service/Android.bp*:"
 msgstr ""
 
@@ -12668,8 +11970,7 @@ msgid ""
 "```rust,ignore\n"
 "//! Birthday service.\n"
 "use birthdayservice::BirthdayService;\n"
-"use com_example_birthdayservice::aidl::com::example::birthdayservice::IBirthdayService::"
-"BnBirthdayService;\n"
+"use com_example_birthdayservice::aidl::com::example::birthdayservice::IBirthdayService::BnBirthdayService;\n"
 "use com_example_birthdayservice::binder;"
 msgstr ""
 
@@ -12775,8 +12076,7 @@ msgstr ""
 msgid ""
 "```rust,ignore\n"
 "//! Birthday service.\n"
-"use com_example_birthdayservice::aidl::com::example::birthdayservice::IBirthdayService::"
-"IBirthdayService;\n"
+"use com_example_birthdayservice::aidl::com::example::birthdayservice::IBirthdayService::IBirthdayService;\n"
 "use com_example_birthdayservice::binder;"
 msgstr ""
 
@@ -12854,9 +12154,7 @@ msgstr "# API 수정"
 msgid ""
 "Let us extend the API with more functionality: we want to let clients specify a\n"
 "list of lines for the birthday card:"
-msgstr ""
-"API를 확장하여 더 많은 기능을 제공해 봅시다. 클라이언트가 생일 카드에 담길 내용을 지정할 수 있도록 "
-"하겠습니다:"
+msgstr "API를 확장하여 더 많은 기능을 제공해 봅시다. 클라이언트가 생일 카드에 담길 내용을 지정할 수 있도록 하겠습니다:"
 
 #: src/android/aidl/changing.md:9
 msgid ""
@@ -12876,9 +12174,7 @@ msgstr "# 로깅"
 msgid ""
 "You should use the `log` crate to automatically log to `logcat` (on-device) or\n"
 "`stdout` (on-host):"
-msgstr ""
-"`log` 크레이트를 사용하면 안드로이드 디바이스 안에서 수행될 때에는 `logcat`으로, 호스트에서 수행될 "
-"때에는 `stdout`으로 로그가 자동으로 출력이 되도록 할 수 있습니다."
+msgstr "`log` 크레이트를 사용하면 안드로이드 디바이스 안에서 수행될 때에는 `logcat`으로, 호스트에서 수행될 때에는 `stdout`으로 로그가 자동으로 출력이 되도록 할 수 있습니다."
 
 #: src/android/logging.md:6
 msgid "_hello_rust_logs/Android.bp_:"
@@ -13021,9 +12317,7 @@ msgstr ""
 msgid ""
 "We already saw this in the [Safe FFI Wrapper\n"
 "exercise](../../exercises/day-3/safe-ffi-wrapper.md)."
-msgstr ""
-"우리는 이미 [Safe FFI 래퍼 연습문제](../../exercises/day-3/safe-ffi-wrapper.md)에서 이를 다루었습니"
-"다. "
+msgstr "우리는 이미 [Safe FFI 래퍼 연습문제](../../exercises/day-3/safe-ffi-wrapper.md)에서 이를 다루었습니다. "
 
 #: src/android/interoperability/with-c.md:23
 msgid ""
@@ -13045,9 +12339,7 @@ msgstr "# Bindgen 사용하기"
 msgid ""
 "The [bindgen](https://rust-lang.github.io/rust-bindgen/introduction.html) tool\n"
 "can auto-generate bindings from a C header file."
-msgstr ""
-"[bindgen](https://rust-lang.github.io/rust-bindgen/introduction.html)는 C 헤더파일에서 러스트 바인"
-"딩을 자동으로 생성하는 도구입니다."
+msgstr "[bindgen](https://rust-lang.github.io/rust-bindgen/introduction.html)는 C 헤더파일에서 러스트 바인딩을 자동으로 생성하는 도구입니다."
 
 #: src/android/interoperability/with-c/bindgen.md:6
 msgid "First create a small C library:"
@@ -13355,12 +12647,10 @@ msgstr ""
 
 #: src/android/interoperability/with-c/rust.md:83
 msgid ""
-"`#[no_mangle]` disables Rust's usual name mangling, so the exported symbol will just be the name "
-"of\n"
+"`#[no_mangle]` disables Rust's usual name mangling, so the exported symbol will just be the name of\n"
 "the function. You can also use `#[export_name = \"some_name\"]` to specify whatever name you want."
 msgstr ""
-"`#[no_mangle]`은 러스트의 네임 맹글링(name mangling)을 비활성화하므로 외부로 노출되는 심볼의 이름"
-"은 함수의 이름 그대로가 됩니다.\n"
+"`#[no_mangle]`은 러스트의 네임 맹글링(name mangling)을 비활성화하므로 외부로 노출되는 심볼의 이름은 함수의 이름 그대로가 됩니다.\n"
 "심볼 이름을 바꾸고 싶다면 `#[export_name = \"some_name\"]`을 사용합니다."
 
 #: src/android/interoperability/cpp.md:1
@@ -13400,10 +12690,7 @@ msgid ""
 "Java can load shared objects via [Java Native Interface\n"
 "(JNI)](https://en.wikipedia.org/wiki/Java_Native_Interface). The [`jni`\n"
 "crate](https://docs.rs/jni/) allows you to create a compatible library."
-msgstr ""
-"자바는 [Java Native Interface(JNI)](https://en.wikipedia.org/wiki/Java_Native_Interface)를 통해 공"
-"유 라이브러리를 로드할 수 있습니다. [`jni` 크레이트](https://docs.rs/jni/)를 사용하여 JNI 라이브러"
-"리를 만들 수 있습니다."
+msgstr "자바는 [Java Native Interface(JNI)](https://en.wikipedia.org/wiki/Java_Native_Interface)를 통해 공유 라이브러리를 로드할 수 있습니다. [`jni` 크레이트](https://docs.rs/jni/)를 사용하여 JNI 라이브러리를 만들 수 있습니다."
 
 #: src/android/interoperability/java.md:7
 msgid "First, we create a Rust function to export to Java:"
@@ -13443,7 +12730,8 @@ msgid ""
 "```"
 msgstr ""
 
-#: src/android/interoperability/java.md:32 src/android/interoperability/java.md:62
+#: src/android/interoperability/java.md:32
+#: src/android/interoperability/java.md:62
 msgid "_interoperability/java/Android.bp_:"
 msgstr ""
 
@@ -13520,9 +12808,7 @@ msgstr ""
 msgid ""
 "For the last exercise, we will look at one of the projects you work with. Let us\n"
 "group up and do this together. Some suggestions:"
-msgstr ""
-"마지막 연습문제는 여러분이 작업하고 있는 프로젝트 중 하나를 FFI로 러스트와 연계 해보는 것입니다. "
-"몇 가지 예시입니다: "
+msgstr "마지막 연습문제는 여러분이 작업하고 있는 프로젝트 중 하나를 FFI로 러스트와 연계 해보는 것입니다. 몇 가지 예시입니다: "
 
 #: src/exercises/day-4/afternoon.md:6
 msgid "* Call your AIDL service with a client written in Rust."
@@ -13555,9 +12841,7 @@ msgid ""
 "[contact with us on\n"
 "GitHub](https://github.com/google/comprehensive-rust/discussions). We would love\n"
 "to hear from you."
-msgstr ""
-"강의가 완벽하진 않으니 실수나 개선점이 있다면 언제든지 [깃허브](https://github.com/google/"
-"comprehensive-rust/discussions)로 연락주세요"
+msgstr "강의가 완벽하진 않으니 실수나 개선점이 있다면 언제든지 [깃허브](https://github.com/google/comprehensive-rust/discussions)로 연락주세요"
 
 #: src/other-resources.md:1
 msgid "# Other Rust Resources"
@@ -13575,8 +12859,7 @@ msgstr "## 공식 문서들"
 
 #: src/other-resources.md:8
 msgid "The Rust project hosts many resources. These cover Rust in general:"
-msgstr ""
-"러스트 프로젝트에는 참조할 만한 자료가 많습니다. 일반적인 내용을 다루는 몇가지 참고 문서들입니다:"
+msgstr "러스트 프로젝트에는 참조할 만한 자료가 많습니다. 일반적인 내용을 다루는 몇가지 참고 문서들입니다:"
 
 #: src/other-resources.md:10
 msgid ""
@@ -13592,14 +12875,10 @@ msgid ""
 "* [The Rust Reference](https://doc.rust-lang.org/reference/): an incomplete book\n"
 "  which describes the Rust grammar and memory model."
 msgstr ""
-"* [The Rust Programming Language](https://doc.rust-lang.org/book/): 러스트에 대한 무료 표준 서적입"
-"니다. 언어에 대한 자세한 설명과 사람들이 빌드 할수 있는 몇가지 프로젝트를 포함합니다.\n"
-"* [Rust By Example](https://doc.rust-lang.org/rust-by-example/): 여러 예제를 통해 러스트의 문법을 "
-"보여주며 때때로 코드를 확장하는 약간의 연습문제들이 포함되어 있습니다.\n"
-"* [Rust Standard Library](https://doc.rust-lang.org/std/): 러스트 표준 라이브러리 전체 문서입니"
-"다.\n"
-"* [The Rust Reference](https://doc.rust-lang.org/reference/): 메모리 모델링과 러스트 문법을 설명하"
-"는 문서입니다.(아직 불완전하다함)"
+"* [The Rust Programming Language](https://doc.rust-lang.org/book/): 러스트에 대한 무료 표준 서적입니다. 언어에 대한 자세한 설명과 사람들이 빌드 할수 있는 몇가지 프로젝트를 포함합니다.\n"
+"* [Rust By Example](https://doc.rust-lang.org/rust-by-example/): 여러 예제를 통해 러스트의 문법을 보여주며 때때로 코드를 확장하는 약간의 연습문제들이 포함되어 있습니다.\n"
+"* [Rust Standard Library](https://doc.rust-lang.org/std/): 러스트 표준 라이브러리 전체 문서입니다.\n"
+"* [The Rust Reference](https://doc.rust-lang.org/reference/): 메모리 모델링과 러스트 문법을 설명하는 문서입니다.(아직 불완전하다함)"
 
 #: src/other-resources.md:22
 msgid "More specialized guides hosted on the official Rust site:"
@@ -13616,12 +12895,9 @@ msgid ""
 "* [The Embedded Rust Book](https://doc.rust-lang.org/stable/embedded-book/): an\n"
 "  introduction to using Rust on embedded devices without an operating system."
 msgstr ""
-"* [The Rustonomicon](https://doc.rust-lang.org/nomicon/): 안전하지 않은 러스트, FFI, raw포인터 작업"
-"을 다룹니다.\n"
-"* [Asynchronous Programming in Rust](https://rust-lang.github.io/async-book/): 러스트 북이 작성 된 "
-"이후 도입된 새로운 비동기 프로그래밍 모델을 다룹니다.\n"
-"* [The Embedded Rust Book](https://doc.rust-lang.org/stable/embedded-book/): 운영체제가 없는 임베디"
-"드 장치에서의 러스트 사용법을 소개합니다."
+"* [The Rustonomicon](https://doc.rust-lang.org/nomicon/): 안전하지 않은 러스트, FFI, raw포인터 작업을 다룹니다.\n"
+"* [Asynchronous Programming in Rust](https://rust-lang.github.io/async-book/): 러스트 북이 작성 된 이후 도입된 새로운 비동기 프로그래밍 모델을 다룹니다.\n"
+"* [The Embedded Rust Book](https://doc.rust-lang.org/stable/embedded-book/): 운영체제가 없는 임베디드 장치에서의 러스트 사용법을 소개합니다."
 
 #: src/other-resources.md:33
 msgid "## Unofficial Learning Material"
@@ -13659,30 +12935,20 @@ msgid ""
 "  exploration of Rust's memory management rules, through implementing a few\n"
 "  different types of list structures."
 msgstr ""
-"* [Learn Rust the Dangerous Way](http://cliffle.com/p/dangerust/): C언어 프로그래머 관점에서 러스트"
-"를 다룹니다.\n"
-"* [Rust for Embedded C Programmers](https://docs.opentitan.org/doc/ug/rust_for_c/): 임베디드 C개발"
-"자(펌웨어 개발자)를 위한 러스트 가이드입니다.\n"
-"* [Rust for professionals](https://overexact.com/rust-for-professionals/): 다른 언어(C/C++, Java, "
-"Python, Javascript)와의 병렬비교를 사용하여 러스트 문법을 다룹니다.\n"
-"* [Rust on Exercism](https://exercism.org/tracks/rust): 러스트를 배우는데 도움이 되는 100개 이상의 "
-"연습문제\n"
-"* [Ferrous Teaching Material](https://ferrous-systems.github.io/teaching-material/index.html): 러스"
-"트 언어의 기본부터 고급을 전부 다루는 일련의 작은 프레젠테이션, 웹 어셈블리, async/await 같은 부분"
-"도 함께 다룹니다.\n"
-"* [Beginner's Series to Rust](https://docs.microsoft.com/en-us/shows/beginners-series-to-rust/), "
-"[Take your first steps with Rust](https://docs.microsoft.com/en-us/learn/paths/rust-first-steps/): "
-"첫번째는 35개의 시리즈 영상이며 두번째는 러스트의 문법과 구조를 다루는 11개의 모듈 세트입니다.\n"
-"* [Learn Rust With Entirely Too Many Linked Lists](https://rust-unofficial.github.io/too-many-"
-"lists/):\n"
+"* [Learn Rust the Dangerous Way](http://cliffle.com/p/dangerust/): C언어 프로그래머 관점에서 러스트를 다룹니다.\n"
+"* [Rust for Embedded C Programmers](https://docs.opentitan.org/doc/ug/rust_for_c/): 임베디드 C개발자(펌웨어 개발자)를 위한 러스트 가이드입니다.\n"
+"* [Rust for professionals](https://overexact.com/rust-for-professionals/): 다른 언어(C/C++, Java, Python, Javascript)와의 병렬비교를 사용하여 러스트 문법을 다룹니다.\n"
+"* [Rust on Exercism](https://exercism.org/tracks/rust): 러스트를 배우는데 도움이 되는 100개 이상의 연습문제\n"
+"* [Ferrous Teaching Material](https://ferrous-systems.github.io/teaching-material/index.html): 러스트 언어의 기본부터 고급을 전부 다루는 일련의 작은 프레젠테이션, 웹 어셈블리, async/await 같은 부분도 함께 다룹니다.\n"
+"* [Beginner's Series to Rust](https://docs.microsoft.com/en-us/shows/beginners-series-to-rust/), [Take your first steps with Rust](https://docs.microsoft.com/en-us/learn/paths/rust-first-steps/): 첫번째는 35개의 시리즈 영상이며 두번째는 러스트의 문법과 구조를 다루는 11개의 모듈 세트입니다.\n"
+"* [Learn Rust With Entirely Too Many Linked Lists](https://rust-unofficial.github.io/too-many-lists/):\n"
 "  몇가지 유형의 리스트 자료구조를 구현해보면서 러스트의 메모리 관리 규칙들을 깊이있게 탐색합니다."
 
 #: src/other-resources.md:63
 msgid ""
 "Please see the [Little Book of Rust Books](https://lborb.github.io/book/) for\n"
 "even more Rust books."
-msgstr ""
-"[Little Book of Rust Books](https://lborb.github.io/book/)에서 더 많은 러스트 북을 확인해보세요."
+msgstr "[Little Book of Rust Books](https://lborb.github.io/book/)에서 더 많은 러스트 북을 확인해보세요."
 
 #: src/credits.md:1
 msgid "# Credits"
@@ -13701,9 +12967,7 @@ msgstr ""
 msgid ""
 "The material of Comprehensive Rust is licensed under the terms of the Apache 2.0\n"
 "license, please see [`LICENSE`](../LICENSE) for details."
-msgstr ""
-"Comprehensive Rust의 자료는 Apache 2.0 라이선스를 따릅니다. 자세한건 [`LICENSE`](../LICENSE) 확인"
-"해 보시기 바랍니다."
+msgstr "Comprehensive Rust의 자료는 Apache 2.0 라이선스를 따릅니다. 자세한건 [`LICENSE`](../LICENSE) 확인해 보시기 바랍니다."
 
 #: src/credits.md:10
 msgid "## Rust by Example"
@@ -13715,9 +12979,7 @@ msgid ""
 "Example](https://doc.rust-lang.org/rust-by-example/). Please see the\n"
 "`third_party/rust-by-example/` directory for details, including the license\n"
 "terms."
-msgstr ""
-"일부 예제와 연습문제는 [Rust by Example](https://doc.rust-lang.org/rust-by-example/)을 참조하였습니"
-"다. 라이선스 조항을 포함하여 저장소의 `third_party/rust-by-example/` 폴더를 참조하시기 바랍니다."
+msgstr "일부 예제와 연습문제는 [Rust by Example](https://doc.rust-lang.org/rust-by-example/)을 참조하였습니다. 라이선스 조항을 포함하여 저장소의 `third_party/rust-by-example/` 폴더를 참조하시기 바랍니다."
 
 #: src/credits.md:17
 msgid "## Rust on Exercism"
@@ -13743,8 +13005,7 @@ msgid ""
 "image from [CXX](https://cxx.rs/). Please see the `third_party/cxx/` directory\n"
 "for details, including the license terms."
 msgstr ""
-"4일차 오후 강의 중 [Interoperability with C++](android/interoperability/cpp.md)에서는 [CXX]"
-"(https://cxx.rs/)의 이미지를 사용하였습니다. \n"
+"4일차 오후 강의 중 [Interoperability with C++](android/interoperability/cpp.md)에서는 [CXX](https://cxx.rs/)의 이미지를 사용하였습니다. \n"
 "라이선스 조항을 포함하여 저장소의 `third_party/cxx/`폴더를 참조하시기 바랍니다."
 
 #: src/exercises/solutions.md:1
@@ -13760,18 +13021,14 @@ msgid ""
 "Feel free to ask questions about the solutions [on\n"
 "GitHub](https://github.com/google/comprehensive-rust/discussions). Let us know\n"
 "if you have a different or better solution than what is presented here."
-msgstr ""
-"[깃허브](https://github.com/google/comprehensive-rust/discussions)에서 이에 대해 자유롭게 질문하시"
-"고 더 나은 솔루션이 있다면 알려주시기 바랍니다."
+msgstr "[깃허브](https://github.com/google/comprehensive-rust/discussions)에서 이에 대해 자유롭게 질문하시고 더 나은 솔루션이 있다면 알려주시기 바랍니다."
 
 #: src/exercises/solutions.md:10
 msgid ""
 "> **Note:** Please ignore the `// ANCHOR: label` and `// ANCHOR_END: label`\n"
 "> comments you see in the solutions. They are there to make it possible to\n"
 "> re-use parts of the solutions as the exercises."
-msgstr ""
-"> **참고:** `// ANCHOR: label`과  `// ANCHOR_END: label` 주석은 문제를 구성하기 위한 메타 주석으로 "
-"무시하시면 됩니다."
+msgstr "> **참고:** `// ANCHOR: label`과  `// ANCHOR_END: label` 주석은 문제를 구성하기 위한 메타 주석으로 무시하시면 됩니다."
 
 #: src/exercises/day-1/solutions-morning.md:1
 msgid "# Day 1 Morning Exercises"
@@ -13785,10 +13042,14 @@ msgstr "## 배열과 `for`반복문"
 msgid "([back to exercise](for-loops.md))"
 msgstr "([연습문제로 돌아가기](for-loops.md))"
 
-#: src/exercises/day-1/solutions-morning.md:7 src/exercises/day-1/solutions-afternoon.md:7
-#: src/exercises/day-2/solutions-morning.md:7 src/exercises/day-2/solutions-afternoon.md:7
-#: src/exercises/day-2/solutions-afternoon.md:102 src/exercises/day-3/solutions-morning.md:7
-#: src/exercises/day-3/solutions-afternoon.md:7 src/exercises/day-4/solutions-morning.md:7
+#: src/exercises/day-1/solutions-morning.md:7
+#: src/exercises/day-1/solutions-afternoon.md:7
+#: src/exercises/day-2/solutions-morning.md:7
+#: src/exercises/day-2/solutions-afternoon.md:7
+#: src/exercises/day-2/solutions-afternoon.md:102
+#: src/exercises/day-3/solutions-morning.md:7
+#: src/exercises/day-3/solutions-afternoon.md:7
+#: src/exercises/day-4/solutions-morning.md:7
 msgid ""
 "```rust\n"
 "// Copyright 2022 Google LLC\n"
@@ -13884,34 +13145,18 @@ msgstr ""
 "### 보너스 문제"
 
 #: src/exercises/day-1/solutions-morning.md:80
-msgid ""
-"It requires more advanced concepts. It might seem that we could use a slice-of-slices "
-"(`&[&[i32]]`) as the input type to transpose and thus make our function handle any size of matrix. "
-"However, this quickly breaks down: the return type cannot be `&[&[i32]]` since it needs to own the "
-"data you return."
+msgid "It requires more advanced concepts. It might seem that we could use a slice-of-slices (`&[&[i32]]`) as the input type to transpose and thus make our function handle any size of matrix. However, this quickly breaks down: the return type cannot be `&[&[i32]]` since it needs to own the data you return."
 msgstr ""
-"사실 이 문제는 고급 개념이 필요합니다. 슬라이스의 슬라이스(slice-of-slices, `&[&[i32]]`)를 입력 타"
-"입으로 사용하면 모든 크기의 행렬을 처리할 수 있을것 같습니다.\n"
-"하지만 실제로 해보면 금방 안된다는 걸 알 수 있습니다. 반환값을 소유해야 하기때문에 `&[&[i32]]` 반"
-"환 타입으로 사용할 수 없습니다. "
+"사실 이 문제는 고급 개념이 필요합니다. 슬라이스의 슬라이스(slice-of-slices, `&[&[i32]]`)를 입력 타입으로 사용하면 모든 크기의 행렬을 처리할 수 있을것 같습니다.\n"
+"하지만 실제로 해보면 금방 안된다는 걸 알 수 있습니다. 반환값을 소유해야 하기때문에 `&[&[i32]]` 반환 타입으로 사용할 수 없습니다. "
 
 #: src/exercises/day-1/solutions-morning.md:82
-msgid ""
-"You can attempt to use something like `Vec<Vec<i32>>`, but this doesn't work out-of-the-box "
-"either: it's hard to convert from `Vec<Vec<i32>>` to `&[&[i32]]` so now you cannot easily use "
-"`pretty_print` either."
-msgstr ""
-"`Vec<Vec<i32>>`와 같은 타입을 사용하려고 시도할 수도 있지만 역시 쉽게 되진 않습니다. "
-"`Vec<Vec<i32>>` 타입을 `&[&[i32]]`로 변환하는 것이 어렵기 때문에 `pretty_print`을 사용하는데 어려움"
-"이 있습니다."
+msgid "You can attempt to use something like `Vec<Vec<i32>>`, but this doesn't work out-of-the-box either: it's hard to convert from `Vec<Vec<i32>>` to `&[&[i32]]` so now you cannot easily use `pretty_print` either."
+msgstr "`Vec<Vec<i32>>`와 같은 타입을 사용하려고 시도할 수도 있지만 역시 쉽게 되진 않습니다. `Vec<Vec<i32>>` 타입을 `&[&[i32]]`로 변환하는 것이 어렵기 때문에 `pretty_print`을 사용하는데 어려움이 있습니다."
 
 #: src/exercises/day-1/solutions-morning.md:84
-msgid ""
-"Once we get to traits and generics, we'll be able to use the [`std::convert::AsRef`][1] trait to "
-"abstract over anything that can be referenced as a slice."
-msgstr ""
-"트레이트나 제너릭을 다루고 나면 [`std::convert::AsRef`][1] 트레이트를 사용하여 슬라이스처럼 사용될 "
-"수 있는 타입을 추상화할 수 있습니다."
+msgid "Once we get to traits and generics, we'll be able to use the [`std::convert::AsRef`][1] trait to abstract over anything that can be referenced as a slice."
+msgstr "트레이트나 제너릭을 다루고 나면 [`std::convert::AsRef`][1] 트레이트를 사용하여 슬라이스처럼 사용될 수 있는 타입을 추상화할 수 있습니다."
 
 #: src/exercises/day-1/solutions-morning.md:86
 msgid ""
@@ -13950,12 +13195,8 @@ msgid ""
 msgstr ""
 
 #: src/exercises/day-1/solutions-morning.md:113
-msgid ""
-"In addition, the type itself would not enforce that the child slices are of the same length, so "
-"such variable could contain an invalid matrix."
-msgstr ""
-"또한, 슬라이스 타입은 길이를 포함하지 않기 때문에 한 단계 아래의 슬라이스들이 같은 길이임을 보장할 "
-"수 없습니다. 때문에 슬라이스 타입의 변수에는 잘못된 행렬이 전달될 수 있습니다."
+msgid "In addition, the type itself would not enforce that the child slices are of the same length, so such variable could contain an invalid matrix."
+msgstr "또한, 슬라이스 타입은 길이를 포함하지 않기 때문에 한 단계 아래의 슬라이스들이 같은 길이임을 보장할 수 없습니다. 때문에 슬라이스 타입의 변수에는 잘못된 행렬이 전달될 수 있습니다."
 
 #: src/exercises/day-1/solutions-morning.md:115
 msgid "[1]: https://doc.rust-lang.org/std/convert/trait.AsRef.html"
@@ -14417,7 +13658,8 @@ msgid ""
 "// ANCHOR_END: unit-tests"
 msgstr ""
 
-#: src/exercises/day-2/solutions-morning.md:233 src/exercises/day-2/solutions-afternoon.md:174
+#: src/exercises/day-2/solutions-morning.md:233
+#: src/exercises/day-2/solutions-afternoon.md:174
 msgid ""
 "fn main() {}\n"
 "```"
@@ -14935,19 +14177,16 @@ msgstr ""
 #~ msgstr ""
 #~ "<details>\n"
 #~ "    \n"
-#~ "`Vec<T>` 역시 제너릭 타입임을 주목하시기 바랍니다. 하지만 러스트는 첫 `push`를 통해 타입을 추론"
-#~ "할 수 있으므로 `T`를 항상 명시할 필요는 없습니다."
+#~ "`Vec<T>` 역시 제너릭 타입임을 주목하시기 바랍니다. 하지만 러스트는 첫 `push`를 통해 타입을 추론할 수 있으므로 `T`를 항상 명시할 필요는 없습니다."
 
 #~ msgid ""
 #~ "`vec![...]` is a canonical macro to use instead of `Vec::new()` and it supports\n"
 #~ "adding initial elements to the vector."
-#~ msgstr ""
-#~ "`vec![...]` 표준 매크로로 `Vec::new()`를 대체하고, 벡터에 추가 초기요소를 추가할 수 있습니다."
+#~ msgstr "`vec![...]` 표준 매크로로 `Vec::new()`를 대체하고, 벡터에 추가 초기요소를 추가할 수 있습니다."
 
 #~ msgid ""
 #~ "* `Box` is like `std::unique_ptr` in C++.\n"
-#~ "* In the above example, you can even leave out the `*` in the `println!` statement thanks to "
-#~ "`Deref`."
+#~ "* In the above example, you can even leave out the `*` in the `println!` statement thanks to `Deref`."
 #~ msgstr ""
 #~ "* `Box`는 C++의 `std::unique_ptr`와 유사합니다.\n"
 #~ "* 위의 예제에서 `Deref` 덕분에 `println!`구문에서  `*`를 생략할 수 도 있습니다."
@@ -14955,6 +14194,4 @@ msgstr ""
 #~ msgid ""
 #~ "Both traits are not to be implemented. They are implemented automatically when \n"
 #~ "the compiler determines it’s appropriate."
-#~ msgstr ""
-#~ "이 트레이트는 프로그래머가 수동으로 구현을 해야 하는 트레이트가 아닙니다. 컴파일러는 적당하다고 "
-#~ "판단되면 이 두 트레이트를 자동으로 구현합니다."
+#~ msgstr "이 트레이트는 프로그래머가 수동으로 구현을 해야 하는 트레이트가 아닙니다. 컴파일러는 적당하다고 판단되면 이 두 트레이트를 자동으로 구현합니다."