diff --git a/po/ko.po b/po/ko.po
index 33bd39ea5959..fd15fba9ca3a 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-20 13:05+0900\n"
+"PO-Revision-Date: 2023-02-23 16:38+0900\n"
 "Last-Translator: keispace <keispace.kyj@google.com>\n"
 "Language-Team: \n"
 "Language: ko\n"
@@ -415,11 +415,11 @@ msgstr "3일차 오전"
 
 #: src/SUMMARY.md:128
 msgid "Traits"
-msgstr "트레이트(Trait)"
+msgstr "트레잇(Trait)"
 
 #: src/SUMMARY.md:129
 msgid "Deriving Traits"
-msgstr "트레이트 상속하기"
+msgstr "트레잇 상속하기"
 
 #: src/SUMMARY.md:130
 msgid "Default Methods"
@@ -427,7 +427,7 @@ msgstr "기본 메서드"
 
 #: src/SUMMARY.md:131
 msgid "Important Traits"
-msgstr "중요한 트레이트"
+msgstr "중요한 트레잇"
 
 #: src/SUMMARY.md:132
 msgid "Iterator"
@@ -459,23 +459,23 @@ msgstr "Default"
 
 #: src/SUMMARY.md:139
 msgid "Generics"
-msgstr "제너릭"
+msgstr "제네릭"
 
 #: src/SUMMARY.md:140
 msgid "Generic Data Types"
-msgstr "제너릭 데이터 타입"
+msgstr "제네릭 데이터 타입"
 
 #: src/SUMMARY.md:141
 msgid "Generic Methods"
-msgstr "제너릭 메서드"
+msgstr "제네릭 메서드"
 
 #: src/SUMMARY.md:142
 msgid "Trait Bounds"
-msgstr "제너릭 타입 제한(트레이트 경계)"
+msgstr "제네릭 타입 제한(트레잇 경계)"
 
 #: src/SUMMARY.md:143
 msgid "impl Trait"
-msgstr "트레이트 구현하기"
+msgstr "트레잇 구현하기"
 
 #: src/SUMMARY.md:144
 msgid "Closures"
@@ -487,7 +487,7 @@ msgstr "단형화"
 
 #: src/SUMMARY.md:146
 msgid "Trait Objects"
-msgstr "트레이트 객체"
+msgstr "트레잇 객체"
 
 #: src/SUMMARY.md:148
 msgid "A Simple GUI Library"
@@ -583,7 +583,7 @@ msgstr "외부(다른언어) 함수들"
 
 #: src/SUMMARY.md:174
 msgid "Implementing Unsafe Traits"
-msgstr "안전하지 않은 트레이트 구현하기"
+msgstr "안전하지 않은 트레잇 구현하기"
 
 #: src/SUMMARY.md:176
 msgid "Safe FFI Wrapper"
@@ -790,16 +790,13 @@ msgid ""
 "This is a four day Rust course developed by the Android team. The course covers\n"
 "the full spectrum of Rust, from basic syntax to advanced topics like generics\n"
 "and error handling. It also includes Android-specific content on the last day."
-msgstr ""
-"이 4일짜리 러스트 강의는 안드로이드 팀이 만들었습니다.\n"
-"기본 문법부터 제너릭, 에러 핸들링과 같은 고급주제까지 러스트의 모든 것을 포함합니다.\n"
-"마지막 날에는 안드로이드에 대한 것 까지 다룹니다."
+msgstr "이 4일짜리 러스트 강의는 안드로이드 팀이 만들었습니다. 기본 문법부터 제네릭, 에러 핸들링과 같은 고급주제까지 러스트의 모든 것을 포함합니다. 마지막 날에는 안드로이드에 대한 것 까지 다룹니다."
 
 #: src/welcome.md:7
 msgid ""
 "The goal of the course is to teach you Rust. We assume you don't know anything\n"
 "about Rust and hope to:"
-msgstr "강의는 당신이 러스트에 대해서 아무것도 모른다고 가정하고 아래의 목표를가지고 있습니다."
+msgstr "강의는 당신이 러스트에 대해서 아무것도 모른다고 가정하고 아래의 목표를가지고 있습니다:"
 
 #: src/welcome.md:10
 msgid ""
@@ -813,7 +810,7 @@ msgstr ""
 
 #: src/welcome.md:14
 msgid "On Day 4, we will cover Android-specific things such as:"
-msgstr "4일차 강의에 우리는 아래와 같은 안드로이드 특화된 내용들도 설명합니다."
+msgstr "4일차 강의에 우리는 아래와 같은 안드로이드 특화된 내용들도 설명합니다:"
 
 #: src/welcome.md:16
 msgid ""
@@ -830,9 +827,7 @@ msgid ""
 "It is important to note that this course does not cover Android **application** \n"
 "development in Rust, and that the Android-specific parts are specifically about\n"
 "writing code for Android itself, the operating system. "
-msgstr ""
-"이 강의에서는 러스트로 안드로이드 **어플리케이션**을 개발하는 것은 다루지 않습니다.\n"
-"이 강의에서 다루는 안드로이드 특화된 내용은 안드로이드 OS의 일부를 러스트로개발하는 것에 대한 것입니다."
+msgstr "이 강의에서는 러스트로 안드로이드 **어플리케이션**을 개발하는 것은 다루지 않습니다. 이 강의에서 다루는 안드로이드 특화된 내용은 안드로이드 OS의 일부를 러스트로개발하는 것에 대한 것입니다. "
 
 #: src/welcome.md:24
 msgid "## Non-Goals"
@@ -842,7 +837,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 ""
@@ -866,17 +861,13 @@ msgid ""
 "The course assumes that you already know how to program. Rust is a statically\n"
 "typed language and we will sometimes make comparisons with C and C++ to better\n"
 "explain or contrast the Rust approach."
-msgstr ""
-"본 강의는 여러분이 프로그래밍 자체에 대해서는 알고 있다고 가정합니다.\n"
-"러스트는 정적타입 언어이며, 강좌에서는 C/C++ 와의 비교, 대조를 통해 러스트를 설명할 것입니다."
+msgstr "본 강의는 여러분이 프로그래밍 자체에 대해서는 알고 있다고 가정합니다. 러스트는 정적타입 언어이며, 강좌에서는 C/C++ 와의 비교, 대조를 통해 러스트를 설명할 것입니다."
 
 #: src/welcome.md:43
 msgid ""
 "If you know how to program in a dynamically typed language such as Python or\n"
 "JavaScript, then you will be able to follow along just fine too."
-msgstr ""
-"C/C++을 모르더라도 동적 타입 언어(Python이나 JavaScript 등) 프로그래밍 경험이 \n"
-"있다면 따라오는데 큰 문제는 없을 것입니다."
+msgstr "C/C++을 모르더라도 동적 타입 언어(Python이나 JavaScript 등) 프로그래밍 경험이 있다면 따라오는데 큰 문제는 없을 것입니다."
 
 #: src/welcome.md:46 src/cargo/rust-ecosystem.md:19
 #: src/cargo/code-samples.md:22 src/cargo/running-locally.md:68
@@ -898,7 +889,7 @@ msgstr ""
 #: 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/pattern-matching/destructuring-arrays.md:19
 #: 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
@@ -936,9 +927,7 @@ msgid ""
 "This is an example of a _speaker note_. We will use these to add additional\n"
 "information to the slides. This could be key points which the instructor should\n"
 "cover as well as answers to typical questions which come up in class."
-msgstr ""
-"이것은 _발표자 노트_의 예제입니다. 이 부분을 이용해서 추가 정보를 제공합니다.\n"
-"주로 강의실에서 제기되는 일반적인 질문에 대한 답변과 강사가 다루어야 할 키 포인트일 수 있습니다."
+msgstr "이것은 _발표자 노트_의 예제입니다. 이 부분을 이용해서 추가 정보를 제공합니다. 주로 강의실에서 제기되는 일반적인 질문에 대한 답변과 강사가 다루어야 할 키 포인트일 수 있습니다."
 
 #: src/welcome.md:52 src/cargo/rust-ecosystem.md:67
 #: src/cargo/code-samples.md:35 src/cargo/running-locally.md:74
@@ -957,13 +946,14 @@ msgstr ""
 #: 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/structs.md:41 src/structs/field-shorthand.md:41 src/enums/sizes.md:136
 #: src/methods/example.md:53 src/pattern-matching/destructuring-enums.md:39
+#: src/pattern-matching/destructuring-arrays.md:46
 #: 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/option-result.md:25 src/std/string.md:40 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
@@ -1020,7 +1010,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 ""
@@ -1037,10 +1027,7 @@ msgid ""
 "   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 ""
-"4. 강의 당일 조금 일찍 와서 준비합니다. 강사 노트북에서 `mdbook serve -d book/ko`를 이용해\n"
-"   직접 프레젠테이션 하면 페이지 이동 시의 지연이 없습니다.([설치 방법][5]을 참조하세요.) 또한,\n"
-"   그렇게 하면 강의 도중 오타를 발견했을 때 그 자리에서 바로 수정 가능하다는 장점도 있습니다."
+msgstr "4. 강의 당일 조금 일찍 와서 준비합니다. 강사 노트북에서 `mdbook serve -d book/ko`를 이용해 직접 프레젠테이션 하면 페이지 이동 시의 지연이 없습니다.([설치 방법][5]을 참조하세요.) 또한, 그렇게 하면 강의 도중 오타를 발견했을 때 그 자리에서 바로 수정 가능하다는 장점도 있습니다."
 
 #: src/running-the-course.md:32
 msgid ""
@@ -1049,10 +1036,7 @@ msgid ""
 "   you see that several people have the same problem, call it out to the class\n"
 "   and offer a solution, e.g., by showing people where to find the relevant\n"
 "   information in the standard library."
-msgstr ""
-"5. 수강생들이 직접 (개별 혹은 그룹으로) 연습문제를 풀도록 합니다. 진행이 막혀 도움을 필요로 하는 수강생이\n"
-"   없는지 수시로 확인합니다. 만약 같은 문제를 여러 사람이 겪고 있다면, 그 문제를 강의실 전체 인원에게 알리고\n"
-"   해결책을 제시합니다. 예를 들어 표준 라이브러리 어디에 가면 그 문제에 대한 해답을 찾을 수 있는지 알려 줍니다."
+msgstr "5. 수강생들이 직접 (개별 혹은 그룹으로) 연습문제를 풀도록 합니다. 진행이 막혀 도움을 필요로 하는 수강생이 없는지 수시로 확인합니다. 만약 같은 문제를 여러 사람이 겪고 있다면, 그 문제를 강의실 전체 인원에게 알리고 해결책을 제시합니다. 예를 들어 표준 라이브러리 어디에 가면 그 문제에 대한 해답을 찾을 수 있는지 알려 줍니다."
 
 #: src/running-the-course.md:38
 msgid ""
@@ -1061,37 +1045,27 @@ msgid ""
 "   machine and move the `src/android/` directory into the root of your AOSP\n"
 "   checkout. This will ensure that the Android build system sees the\n"
 "   `Android.bp` files in `src/android/`."
-msgstr ""
-"6. 4일차에 있을 안드로이드 부분을 건너띄지 않는다면 [AOSP 코드][1]를 체크아웃해야 합니다. 그런 다음,\n"
-"   같은 컴퓨터에서 [과정 저장소][2]를 체크아웃하고 `src/android/` 디렉터리를 AOSP 코드의 루트로\n"
-"   이동합니다. 이렇게 하면 안드로이드 빌드 시스템에서 과제용으로 추가된 `Android.bp`파일을 인식할 수 있습니다."
+msgstr "6. 4일차에 있을 안드로이드 부분을 건너띄지 않는다면 [AOSP 코드][1]를 체크아웃해야 합니다. 그런 다음, 같은 컴퓨터에서 [과정 저장소][2]를 체크아웃하고 `src/android/` 디렉터리를 AOSP 코드의 루트로 이동합니다. 이렇게 하면 안드로이드 빌드 시스템에서 과제용으로 추가된 `Android.bp`파일을 인식할 수 있습니다."
 
 #: src/running-the-course.md:44
 msgid ""
 "   Ensure that `adb sync` works with your emulator or real device and pre-build\n"
 "   all Android examples using `src/android/build_all.sh`. Read the script to see\n"
 "   the commands it runs and make sure they work when you run them by hand."
-msgstr ""
-"   `adb sync` 명렁어가 에뮬레이터 혹은 실제 장치와 작동하는지 확인합니다. 그리고 \n"
-"   `src/android/build_all.sh`를 수행해서 모든 안드로이드 예제를 미리 빌드해 보세요.\n"
-"   그 쉘 스크립트를 읽고, 그 안에서 수행되는 명령어들을 확인한 후 각 명령어들을 \n"
-"   수동으로 실행해도 잘 되는지 확인하세요."
+msgstr "   `adb sync` 명렁어가 에뮬레이터 혹은 실제 장치와 작동하는지 확인합니다. 그리고 `src/android/build_all.sh`를 수행해서 모든 안드로이드 예제를 미리 빌드해 보세요. 그 쉘 스크립트를 읽고, 그 안에서 수행되는 명령어들을 확인한 후 각 명령어들을 수동으로 실행해도 잘 되는지 확인하세요."
 
 #: src/running-the-course.md:48
 msgid ""
 "That is all, good luck running the course! We hope it will be as much fun for\n"
 "you as it has been for us!"
-msgstr "이제 준비는 끝났습니다. 우리가 그랬듯이 여러분들도 이 강의를 즐기시길 바랍니다."
+msgstr "이제 준비는 끝났습니다. 우리가 그랬듯이 여러분들도 이 강의를 즐기시길 바랍니다!"
 
 #: src/running-the-course.md:51
 msgid ""
 "Please [provide feedback][3] afterwards so that we can keep improving the\n"
 "course. We would love to hear what worked well for you and what can be made\n"
 "better. Your students are also very welcome to [send us feedback][4]!"
-msgstr ""
-"강의를 계속 개선할 수 있도록 [피드백][3]을 제공해 주십시오. 우리는 무엇이 \n"
-"좋았고, 무엇이 모자랐는지 듣고 싶습니다. 수강생들로 부터의 [피드백][4]도 \n"
-"환영합니다."
+msgstr "강의를 계속 개선할 수 있도록 [피드백][3]을 제공해 주십시오. 우리는 무엇이 좋았고, 무엇이 모자랐는지 듣고 싶습니다. 수강생들로 부터의 [피드백][4]도 환영합니다!"
 
 #: src/running-the-course.md:55
 msgid ""
@@ -1113,7 +1087,7 @@ msgstr "# 강의 구성"
 
 #: src/running-the-course/course-structure.md:5
 msgid "The course is fast paced and covers a lot of ground:"
-msgstr "강의는 빠른 속도로 진행되며, 아래 내용들을 다룹니다."
+msgstr "강의는 빠른 속도로 진행되며, 아래 내용들을 다룹니다:"
 
 #: src/running-the-course/course-structure.md:7
 msgid ""
@@ -1124,7 +1098,7 @@ msgid ""
 msgstr ""
 "* 1일차: 러스트 기본, 소유권(ownership)과 빌림(borrow) 체크\n"
 "* 2일차: 복합 데이터 유형, 패턴 매칭, 표준 라이브러리\n"
-"* 3일차: 트레이트(trait)와 제너릭(generic), 오류 처리, 테스트, 안전하지 않은 러스트\n"
+"* 3일차: 트레잇(trait)와 제네릭(generic), 오류 처리, 테스트, 안전하지 않은 러스트\n"
 "* 4일차: 러스트의 동시성 및 다른 언어와의 상호 운용성"
 
 #: src/running-the-course/course-structure.md:12
@@ -1132,9 +1106,7 @@ msgid ""
 "> **Exercise for Day 4:** Do you interface with some C/C++ code in your project\n"
 "> which we could attempt to move to Rust? The fewer dependencies the better.\n"
 "> Parsing code would be ideal."
-msgstr ""
-"> **4일차 연습문제:** 러스트 프로젝트에서 C/C++로 작성된 코드를 이전해서 연결하려고 한다면 종속성이\n"
-"> 적을 수록 좋습니다. 구문 분석 코드라면 이상적입니다."
+msgstr "> **4일차 연습문제:** 러스트 프로젝트에서 C/C++로 작성된 코드를 이전해서 연결하려고 한다면 종속성이 적을 수록 좋습니다. 구문 분석 코드라면 이상적입니다."
 
 #: src/running-the-course/course-structure.md:16
 msgid "## Format"
@@ -1144,9 +1116,7 @@ msgstr "## 강의 형식"
 msgid ""
 "The course is meant to be very interactive and we recommend letting the\n"
 "questions drive the exploration of Rust!"
-msgstr ""
-"이 강의는 강사와 수강생이 양방향으로 소통하면서 진행하도록 디자인 되었습니다.\n"
-"다양한 질문을 통해 러스트의 여러 부분을 탐험할 수 있도록 하세요!"
+msgstr "이 강의는 강사와 수강생이 양방향으로 소통하면서 진행하도록 디자인 되었습니다. 다양한 질문을 통해 러스트의 여러 부분을 탐험할 수 있도록 하세요!"
 
 #: src/running-the-course/keyboard-shortcuts.md:1
 msgid "# Keyboard Shortcuts"
@@ -1154,7 +1124,7 @@ msgstr "# 단축키"
 
 #: src/running-the-course/keyboard-shortcuts.md:3
 msgid "There are several useful keyboard shortcuts in mdBook:"
-msgstr "mdBook 시스템(현 사이트)에서 유용한 단축키들 입니다."
+msgstr "mdBook 시스템(현 사이트)에서 유용한 단축키들 입니다:"
 
 #: src/running-the-course/keyboard-shortcuts.md:5
 msgid ""
@@ -1232,9 +1202,7 @@ msgid ""
 "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"
-"여기서는 카고가 무엇인지, 그리고 카고가 러스트 생태계에서 어떤 역할을 하는지, 그리고 이 강의에서 어떻게 사용될 지에 대해 간략히 설명하겠습니다."
+msgstr "러스트를 시작하려고하면 당신은 곧 [Cargo](https://doc.rust-lang.org/cargo/)라는, 러스트 생태계에서 사용하는 표준 빌드/실행 도구를 만날 것 입니다. 여기서는 카고가 무엇인지, 그리고 카고가 러스트 생태계에서 어떤 역할을 하는지, 그리고 이 강의에서 어떻게 사용될 지에 대해 간략히 설명하겠습니다."
 
 #: src/cargo.md:8
 msgid "## Installation"
@@ -1250,10 +1218,7 @@ 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."
-msgstr ""
-"카고(cargo)와 러스트 컴파일러(rustc)와 함께, rustup은 툴체인을 설치하고, 다른 \n"
-"툴체인으로 전환하고, 크로스 컴파일 설정을 하는 일을 담당하는 커맨드 라인 유틸리티 \n"
-"입니다."
+msgstr "카고(cargo)와 러스트 컴파일러(rustc)와 함께, rustup은 툴체인을 설치하고, 다른 툴체인으로 전환하고, 크로스 컴파일 설정을 하는 일을 담당하는 커맨드 라인 유틸리티 입니다."
 
 #: src/cargo.md:16
 msgid "### Package Managers"
@@ -1281,10 +1246,7 @@ msgstr ""
 msgid ""
 "This will allow [rust-analyzer][1] to jump to the definitions. We suggest using\n"
 "[VS Code][2] to edit the code (but any LSP compatible editor works)."
-msgstr ""
-"이렇게 하면 [rust-analyzer][1]를 이용해서 특정 심볼이 정의된 위치로 쉽게 \n"
-"이동할 수 있습니다. 우리는 에디터로 [VS Code][2]를 추천합니다만, 사실 LSP \n"
-"를 지원한다면 어떤 에디터도 무방합니다."
+msgstr "이렇게 하면 [rust-analyzer][1]를 이용해서 특정 심볼이 정의된 위치로 쉽게 이동할 수 있습니다. 우리는 에디터로 [VS Code][2]를 추천합니다만, 사실 LSP를 지원한다면 어떤 에디터도 무방합니다."
 
 #: 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."
@@ -1312,7 +1274,7 @@ msgstr "# 러스트 생태계"
 
 #: src/cargo/rust-ecosystem.md:3
 msgid "The Rust ecosystem consists of a number of tools, of which the main ones are:"
-msgstr "러스트의 생태계는 여러가지 도구들로 구성되어 있으며, 그 중 중요한 것들은 아래와 같습니다: "
+msgstr "러스트의 생태계는 여러가지 도구들로 구성되어 있으며, 그 중 중요한 것들은 아래와 같습니다:"
 
 #: src/cargo/rust-ecosystem.md:5
 msgid ""
@@ -1326,11 +1288,7 @@ msgid ""
 "  download dependencies hosted on <https://crates.io> and it will pass them to\n"
 "  `rustc` when building your project. Cargo also comes with a built-in test\n"
 "  runner which is used to execute unit tests."
-msgstr ""
-"* `cargo`: 러스트 의존성 관리자 및 빌드도구 입니다. 여러분의 프로젝트에 명시된 \n"
-"  의존성들을 <https://crates.io>에서 자동으로 다운로드 받고, 그 소스코드를 \n"
-"  `rustc`로 전달하여 빌드를 시킵니다. 또한 유닛 테스트를 실행하는 테스트 러너를 \n"
-"  내장하고 있습니다."
+msgstr "* `cargo`: 러스트 의존성 관리자 및 빌드도구 입니다. 여러분의 프로젝트에 명시된 의존성들을 <https://crates.io>에서 자동으로 다운로드 받고, 그 소스코드를 `rustc`로 전달하여 빌드를 시킵니다. 또한 유닛 테스트를 실행하는 테스트 러너를 내장하고 있습니다."
 
 #: src/cargo/rust-ecosystem.md:13
 msgid ""
@@ -1339,11 +1297,7 @@ msgid ""
 "  In addition, `rustup` can also download documentation for the standard\n"
 "  library. You can have multiple versions of Rust installed at once and `rustup`\n"
 "  will let you switch between them as needed."
-msgstr ""
-"* `rustup`: 러스트 툴체인 설치 프로그램 및 업데이트 프로그램. \n"
-"  이 도구는 새 버전의 러스트가 출시될 때 `rustc` 및 `cargo` 설치하고 업데이트하는 데 사용됩니다. \n"
-"  또한 `rustup`은 표준 라이브러리에 대한 문서를 다운로드할 수도 있습니다. \n"
-"  한 번에 여러 버전의 러스트를 설치할 수 있으며 `rustup`을 통해 필요에 따라 이들 버전을 전환할 수 있습니다."
+msgstr "* `rustup`: 러스트 툴체인 설치 프로그램 및 업데이트 프로그램. 이 도구는 새 버전의 러스트가 출시될 때 `rustc` 및 `cargo` 설치하고 업데이트하는 데 사용됩니다. 또한 `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
@@ -1375,9 +1329,7 @@ msgstr "* 새로운 기능은 \"nightly\" -> \"beta\" -(6주 후)-> \"stable\" 
 msgid ""
 "* Rust also has [editions]: the current edition is Rust 2021. Previous\n"
 "  editions were Rust 2015 and Rust 2018."
-msgstr ""
-"* 러스트는 [에디션][editions]으로 구분됩니다. 현재는 Rust 2021 에디션입니다.\n"
-"  이 전 에디션으로 Rust 2015와 Rust 2018이 있습니다."
+msgstr "* 러스트는 [에디션][editions]으로 구분됩니다. 현재는 Rust 2021 에디션입니다. 이 전 에디션으로 Rust 2015와 Rust 2018이 있습니다."
 
 #: src/cargo/rust-ecosystem.md:35
 msgid ""
@@ -1389,19 +1341,13 @@ msgstr "  * 에디션은 이전 에디션과 호환이 되지 않을 수 있습
 msgid ""
 "  * To prevent breaking code, editions are opt-in: you select the\n"
 "    edition for your crate via the `Cargo.toml` file."
-msgstr ""
-"  * 에디션이 바뀌면서 프로그램이 의도치 않게 깨지는 문제를 막기 위해, \n"
-"    각 프로그램은 자신이 빌드될 에디션을 명시적으로 `Cargo.toml`에 지정\n"
-"    해야 합니다."
+msgstr "  * 에디션이 바뀌면서 프로그램이 의도치 않게 깨지는 문제를 막기 위해, 각 프로그램은 자신이 빌드될 에디션을 명시적으로 `Cargo.toml`에 지정해야 합니다."
 
 #: src/cargo/rust-ecosystem.md:41
 msgid ""
 "  * To avoid splitting the ecosystem, Rust compilers can mix code\n"
 "    written for different editions."
-msgstr ""
-"  * 러스트 생태계가 에디션 별로 파편회 되는 것을 막기 위해, 러스트 컴파일\n"
-"    러는 서로 다른 에디션에서 작성된 코드들을 하나의 바이너리로 묶을 수 \n"
-"    있습니다."
+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)."
@@ -1461,24 +1407,18 @@ msgid ""
 "For this training, we will mostly explore the Rust language through examples\n"
 "which can be executed through your browser. This makes the setup much easier and\n"
 "ensures a consistent experience for everyone."
-msgstr ""
-"이 강의자료에 있는 모든 예제는 브라우저에서 바로 수행 가능합니다. \n"
-"이렇게 한 이유는, 준비 과정을 단순화 시키고, 모두가 같은 환경에서 작업할 수 \n"
-"있도록 하기 위함입니다."
+msgstr "이 강의자료에 있는 모든 예제는 브라우저에서 바로 수행 가능합니다. 이렇게 한 이유는, 준비 과정을 단순화 시키고, 모두가 같은 환경에서 작업할 수 있도록 하기 위함입니다."
 
 #: src/cargo/code-samples.md:7
 msgid ""
 "Installing Cargo is still encouraged: it will make it easier for you to do the\n"
 "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"
-"또한, 마지막 날에는 의존성이 있는 예제를 작업하게 될 텐데, 그 때에는 어차피 \n"
-"카고가 필요합니다."
+msgstr "그럼에도 불구하고, 카고(cargo)를 직접 설치하는 것을 강력 권장합니다. 이게 과제 작성에 더 도움이 될겁니다. 또한, 마지막 날에는 의존성이 있는 예제를 작업하게 될 텐데, 그 때에는 어차피 카고가 필요합니다."
 
 #: src/cargo/code-samples.md:11
 msgid "The code blocks in this course are fully interactive:"
-msgstr "이 강의 자료의 코드 블록들은 전부 인터엑티브 합니다."
+msgstr "이 강의 자료의 코드 블록들은 전부 인터엑티브 합니다:"
 
 #: src/cargo/code-samples.md:13
 msgid ""
@@ -1504,7 +1444,7 @@ 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 ""
@@ -1518,7 +1458,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"
@@ -1530,10 +1470,7 @@ msgid ""
 "to first install Rust. Do this by following the [instructions in the Rust\n"
 "Book][1]. This should give you a working `rustc` and `cargo`. At the time of\n"
 "writing, the latest stable Rust release has these version numbers:"
-msgstr ""
-"만약 개인용 컴퓨터에서 코드를 실행해보려면 먼저 러스트를 설치해야 합니다. \n"
-"[Rust Book][1]의 지침에 따라 `rustc`와 `cargo`를 함께  설치 하시기 바랍니다. \n"
-"  설치 후 아래 커맨드를 통해 각 툴의 버전을 확인 할 수 있습니다. "
+msgstr "만약 개인용 컴퓨터에서 코드를 실행해보려면 먼저 러스트를 설치해야 합니다. [Rust Book][1]의 지침에 따라 `rustc`와 `cargo`를 함께 설치 하시기 바랍니다. 설치 후 아래 커맨드를 통해 각 툴의 버전을 확인 할 수 있습니다:"
 
 #: src/cargo/running-locally.md:8
 msgid ""
@@ -1549,7 +1486,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."
@@ -1557,7 +1494,7 @@ msgstr "1. 예시 블록에 있는 \"Copy to clipboard\"버튼을 클릭해서 
 
 #: src/cargo/running-locally.md:20
 msgid "2. Use `cargo new exercise` to create a new `exercise/` directory for your code:"
-msgstr "2. 터미널에서 `cargo new exercise`를 입력해서 새로운 `exercise/` 폴더를 만듭니다."
+msgstr "2. 터미널에서 `cargo new exercise`를 입력해서 새로운 `exercise/` 폴더를 만듭니다:"
 
 #: src/cargo/running-locally.md:22
 msgid ""
@@ -1569,7 +1506,7 @@ msgstr ""
 
 #: src/cargo/running-locally.md:27
 msgid "3. Navigate into `exercise/` and use `cargo run` to build and run your binary:"
-msgstr "3. `exercise/` 폴더로 이동한 후, `cargo run` 커맨드로 코드를 실행합니다."
+msgstr "3. `exercise/` 폴더로 이동한 후, `cargo run` 커맨드로 코드를 실행합니다:"
 
 #: src/cargo/running-locally.md:29
 msgid ""
@@ -1587,7 +1524,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 ""
@@ -1600,7 +1537,7 @@ msgstr ""
 
 #: src/cargo/running-locally.md:47
 msgid "5. Use `cargo run` to build and run your updated binary:"
-msgstr "5. `cargo run`커맨드로 소스를 빌드하고 실행합니다."
+msgstr "5. `cargo run`커맨드로 소스를 빌드하고 실행합니다:"
 
 #: src/cargo/running-locally.md:49
 msgid ""
@@ -1619,19 +1556,14 @@ msgid ""
 "   to compile it without running it. You will find the output in `target/debug/`\n"
 "   for a normal debug build. Use `cargo build --release` to produce an optimized\n"
 "   release build in `target/release/`."
-msgstr ""
-"6. `cargo check`커맨드는 빠르게 에러를 확인할 수 있습니다.\n"
-"    * `cargo build`는 실행없이 컴파일만 합니다. 이 경우에 `target/debug/`폴더에서 output을 확인 할 수 있습니다. \n"
-"    * `cargo build --release`커맨드는 릴리즈 버전용 최적화를 켜서 컴파일하며 `target/release/`폴더에서 확인 할 수 있습니다."
+msgstr "6. `cargo check`커맨드는 빠르게 에러를 확인할 수 있습니다. `cargo build`는 실행없이 컴파일만 합니다. 이 경우에 `target/debug/`폴더에서 output을 확인 할 수 있습니다. `cargo build --release`커맨드는 릴리즈 버전용 최적화를 켜서 컴파일하며 `target/release/`폴더에서 확인 할 수 있습니다."
 
 #: src/cargo/running-locally.md:62
 msgid ""
 "7. You can add dependencies for your project by editing `Cargo.toml`. When you\n"
 "   run `cargo` commands, it will automatically download and compile missing\n"
 "   dependencies for you."
-msgstr ""
-"7. `Cargo.toml`파일에는 의존성 패키지를 추가할 수 있습니다. \n"
-"    - `cargo`커맨드를 실행하면 자동으로 의존성 패키지를 다운로드하고 컴파일 까지 해 줍니다."
+msgstr "7. `Cargo.toml`파일에는 의존성 패키지를 추가할 수 있습니다. `cargo`커맨드를 실행하면 자동으로 의존성 패키지를 다운로드하고 컴파일 까지 해 줍니다."
 
 #: src/cargo/running-locally.md:66
 msgid "[1]: https://doc.rust-lang.org/book/ch01-01-installation.html"
@@ -1642,10 +1574,7 @@ msgid ""
 "Try to encourage the class participants to install Cargo and use a\n"
 "local editor. It will make their life easier since they will have a\n"
 "normal development environment."
-msgstr ""
-"수강생들이 카고를 설치하고 로컬 편집기를 이용하도록 독려하세요. \n"
-"조금 귀찮을 수도 있지만, 이렇게 해야만 좀 더 실제와 가까운 개발환경을 \n"
-"갖추게 되는 것입니다."
+msgstr "수강생들이 카고를 설치하고 로컬 편집기를 이용하도록 독려하세요. 조금 귀찮을 수도 있지만, 이렇게 해야만 좀 더 실제와 가까운 개발환경을 갖추게 되는 것입니다."
 
 #: src/welcome-day-1.md:1
 msgid "# Welcome to Day 1"
@@ -1655,7 +1584,7 @@ msgstr "# 1일차 개요"
 msgid ""
 "This is the first day of Comprehensive Rust. We will cover a lot of ground\n"
 "today:"
-msgstr "강의 첫 날입니다. 오늘 배울 것이 참 많습니다."
+msgstr "강의 첫 날입니다. 오늘 배울 것이 참 많습니다:"
 
 #: src/welcome-day-1.md:6
 msgid ""
@@ -1671,7 +1600,7 @@ msgstr "* 메모리 관리: 스택과 힙, 수동 메모리 관리, 스코프(
 
 #: src/welcome-day-1.md:12
 msgid "* Ownership: move semantics, copying and cloning, borrowing, and lifetimes."
-msgstr "* 소유권: Move 문법, 복사와 복제, 빌림, 수명"
+msgstr "* 소유권: Move 문법, 복사와 복제, 빌림, 수명."
 
 #: src/welcome-day-1.md:16
 msgid "Please remind the students that:"
@@ -1692,9 +1621,7 @@ msgid ""
 msgstr ""
 "* 궁금한 점이 있으면 주저하지 말고 질문 해야 합니다.\n"
 "* 이 수업은 상호작용이 중요하고 토론을 권장합니다.\n"
-"  * 강사로서 토론이 옆길로 새지 않게 주의하세요. 예를 들어 러스트와 다른 언어들을 비교한다든지 하는 것은\n"
-"    좋습니다. 적절한 균형을 찾기 애매한 경우라면 토론을 허용하는 쪽이 일방적인 강의보다는 더 많은 사람들의\n"
-"    참여를 이끌어 낼 수 있습니다.\n"
+"  * 강사로서 토론이 옆길로 새지 않게 주의하세요. 예를 들어 러스트와 다른 언어들을 비교한다든지 하는 것은 좋습니다. 적절한 균형을 찾기 애매한 경우라면 토론을 허용하는 쪽이 일방적인 강의보다는 더 많은 사람들의 참여를 이끌어 낼 수 있습니다.\n"
 "* 질문이 슬라이드보다 앞서가도 괜찮습니다.\n"
 "  * 학습에 있어서 반복은 매우 중요합니다. 슬라이드는 그저 도움을 줄 뿐, 원하는 대로 건너띄어도 됩니다."
 
@@ -1703,33 +1630,27 @@ msgid ""
 "The idea for the first day is to show _just enough_ of Rust to be able to speak\n"
 "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"
-"러스트의 가장 독특한 특징이 메모리를 다루는 방식이기 때문에, 학생들에게 이 부분 을 우선적으로 보여주려 합니다."
+msgstr "첫 날 강의의 목표는, 러스트에서 그 유명한 빌림 확인에 대해서 이야기 할 수 있을 정도 까지만 러스트를 소개하는 것입니다. 러스트의 가장 독특한 특징이 메모리를 다루는 방식이기 때문에, 학생들에게 이 부분 을 우선적으로 보여주려 합니다."
 
 #: src/welcome-day-1.md:33
 msgid ""
 "If you're teaching this in a classroom, this is a good place to go over the\n"
 "schedule. We suggest splitting the day into two parts (following the slides):"
-msgstr ""
-"만약 당신이 강의실에서 가르치고 있다면, 이 슬라이드는 일정을 검토하기에 적합한 곳입니다. \n"
-"하루치 강의를 아래처럼 오전 오후로 나누어 진행하는 것을 추천합니다. (슬라이드가 그런식으로나뉘어 있습니다.)"
+msgstr "만약 당신이 강의실에서 가르치고 있다면, 이 슬라이드는 일정을 검토하기에 적합한 곳입니다. 하루치 강의를 아래처럼 오전 오후로 나누어 진행하는 것을 추천합니다. (슬라이드가 그런식으로나뉘어 있습니다.)"
 
 #: src/welcome-day-1.md:36
 msgid ""
 "* Morning: 9:00 to 12:00,\n"
 "* Afternoon: 13:00 to 16:00."
 msgstr ""
-"* 오전: 9:00 ~ 12:00\n"
-"* 오후: 13:00 ~ 16:00"
+"* 오전: 9:00 ~ 12:00,\n"
+"* 오후: 13:00 ~ 16:00."
 
 #: src/welcome-day-1.md:39
 msgid ""
 "You can of course adjust this as necessary. Please make sure to include breaks,\n"
 "we recommend a break every hour!"
-msgstr ""
-"물론 필요에 따라 조절할 수 있습니다. 강의 중간에 쉬는시간을 넣는 것을 잊지 마세요.\n"
-"매 시간 휴식을 갖는걸 추천합니다."
+msgstr "물론 필요에 따라 조절할 수 있습니다. 강의 중간에 쉬는시간을 넣는 것을 잊지 마세요. 매 시간 휴식을 갖는걸 추천합니다!"
 
 #: src/welcome-day-1/what-is-rust.md:1
 msgid "# What is Rust?"
@@ -1737,7 +1658,7 @@ msgstr "# 러스트란?"
 
 #: src/welcome-day-1/what-is-rust.md:3
 msgid "Rust is a new programming language which had its [1.0 release in 2015][1]:"
-msgstr "러스트는 2015년에 [버전 1.0][1]을 릴리즈 한 새로운 프로그램 언어입니다."
+msgstr "러스트는 2015년에 [버전 1.0][1]을 릴리즈 한 새로운 프로그램 언어입니다:"
 
 #: src/welcome-day-1/what-is-rust.md:5
 msgid ""
@@ -1759,16 +1680,16 @@ msgstr ""
 "* 러스트는 다양한 플랫폼과 아키텍쳐를 지원합니다.\n"
 "  * x86, ARM, WebAssembly, ...\n"
 "  * Linux, Mac, Windows, ...\n"
-"* 러스트는 다양한 장치에서 사용될 수 있습니다. \n"
+"* 러스트는 다양한 장치에서 사용될 수 있습니다:\n"
 "  * 펌웨어와 부트로더(임베디드)\n"
 "  * 스마트 디스플레이\n"
 "  * 스마트폰\n"
 "  * 데스크탑\n"
-"  * 서버"
+"  * 서버."
 
 #: src/welcome-day-1/what-is-rust.md:21
 msgid "Rust fits in the same area as C++:"
-msgstr "러스트는 C++가 사용되는 대부분의 곳에서 사용 가능합니다."
+msgstr "러스트는 C++가 사용되는 대부분의 곳에서 사용 가능합니다:"
 
 #: src/welcome-day-1/what-is-rust.md:23
 msgid ""
@@ -1778,11 +1699,11 @@ msgid ""
 "* Has no runtime or garbage collection.\n"
 "* Focuses on reliability and safety without sacrificing performance."
 msgstr ""
-"* 높은 유연성\n"
-"* 높은 레벨 수준의 제어\n"
-"* 휴대폰과 같은 매우 제한된 장치로 스케일 다운 가능\n"
-"* 별도의 런타임을 필요로 하지 않으며, 가비지 컬렉션도 없음\n"
-"* 성능을 타협하지 않으면서도 안정성과 안전에 중점을 둠"
+"* 높은 유연성.\n"
+"* 높은 레벨 수준의 제어.\n"
+"* 휴대폰과 같은 매우 제한된 장치로 스케일 다운 가능.\n"
+"* 별도의 런타임을 필요로 하지 않으며, 가비지 컬렉션도 없음.\n"
+"* 성능을 타협하지 않으면서도 안정성과 안전에 중점을 둠."
 
 #: src/welcome-day-1/what-is-rust.md:31
 msgid "[1]: https://blog.rust-lang.org/2015/05/15/Rust-1.0.html"
@@ -1796,7 +1717,7 @@ msgstr "# Hello World!"
 msgid ""
 "Let us jump into the simplest possible Rust program, a classic Hello World\n"
 "program:"
-msgstr "가장 간단한 러스트 프로그램으로써, 고전적인 Hello World 를 작성해 보겠습니다."
+msgstr "가장 간단한 러스트 프로그램으로써, 고전적인 Hello World 를 작성해 보겠습니다:"
 
 #: src/hello-world.md:6
 msgid ""
@@ -1809,7 +1730,7 @@ msgstr ""
 
 #: src/hello-world.md:12
 msgid "What you see:"
-msgstr "확인 할 수 있는 것들: "
+msgstr "확인할 수 있는 것들:"
 
 #: src/hello-world.md:14
 msgid ""
@@ -1820,8 +1741,8 @@ msgid ""
 "* Rust strings are UTF-8 encoded and can contain any Unicode character."
 msgstr ""
 "* 함수는 `fn`으로 선언합니다.\n"
-"* C/C++ 와 마찬가지로 중괄호`{}`로 블록을 표시합니다. \n"
-"* `main` 함수는 프로그램 진입점입니다. \n"
+"* C/C++ 와 마찬가지로 중괄호`{}`로 블록을 표시합니다.\n"
+"* `main` 함수는 프로그램 진입점입니다.\n"
 "* 러스트는 똑똑한 매크로(hygienic macros) 시스템을 가지고 있습니다. `println!`는 그 예시입니다.\n"
 "* 러스트의 문자열은 UTF-8로 인코딩되며 이모지와 같은 유니코드 문자를 포함할 수 있습니다."
 
@@ -1836,10 +1757,7 @@ msgid ""
 "* Rust is very much like other languages in the C/C++/Java tradition. It is\n"
 "  imperative (not functional) and it doesn't try to reinvent things unless\n"
 "  absolutely necessary."
-msgstr ""
-"* 러스트는 C/C++/Java와 같은 전통적인 다른 언어와 매우 유사합니다. 러스트는 \n"
-"  절차적(함수형 아님) 언어입니다. 정말로 필요한 경우가 아니라면, 러스트는 \n"
-"  이미 존재하는 것을 새로 구현하려고 하지 않습니다."
+msgstr "* 러스트는 C/C++/Java와 같은 전통적인 다른 언어와 매우 유사합니다. 러스트는 절차적(함수형 아님) 언어입니다. 정말로 필요한 경우가 아니라면, 러스트는 이미 존재하는 것을 새로 구현하려고 하지 않습니다."
 
 #: src/hello-world.md:31
 msgid "* Rust is modern with full support for things like Unicode."
@@ -1857,7 +1775,7 @@ msgstr "# 작은 예제"
 
 #: src/hello-world/small-example.md:3
 msgid "Here is a small example program in Rust:"
-msgstr "러스트로 작성된 작은 예제입니다. "
+msgstr "러스트로 작성된 작은 예제입니다:"
 
 #: src/hello-world/small-example.md:5
 msgid ""
@@ -1904,7 +1822,7 @@ msgstr "이 코드는 콜라츠 추측(Collatz conjecture)으로 구현됩니다
 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."
@@ -1943,15 +1861,15 @@ msgid ""
 "* Lack of undefined runtime behavior.\n"
 "* Modern language features."
 msgstr ""
-"* 컴파일 시 메모리 안전이 보장됨\n"
-"* 정의되지 않은 런타임 동작이 없음\n"
-"* 현대적인 언어 기능"
+"* 컴파일 시 메모리 안전이 보장됨.\n"
+"* 정의되지 않은 런타임 동작이 없음.\n"
+"* 현대적인 언어 기능."
 
 #: src/why-rust.md:11
 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 ""
@@ -1959,7 +1877,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 ""
@@ -2001,7 +1919,7 @@ msgstr ""
 msgid ""
 "It is possible to produce memory leaks in (safe) Rust. Some examples\n"
 "are:"
-msgstr "(안전한) 러스트에서도 메모리 누출이 발생할 수 있는 몇 가지 경우가 있습니다."
+msgstr "(안전한) 러스트에서도 메모리 누출이 발생할 수 있는 몇 가지 경우가 있습니다:"
 
 #: src/why-rust/compile-time.md:19
 msgid ""
@@ -2014,7 +1932,7 @@ 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"
+"* [`Box::leak`]을 이용하여 포인터를 의도적으로 누출시킬 수 있습니다. 이를 이용해서 런타임이 생성하고 런타임이 크기를 정한 정적 변수를 가져올 수 있습니다.\n"
 "* [`std::mem::forget`]을 사용하여 컴파일러가 값에 대해 \"잊도록\" 만들 수 있습니다(소멸자가 실행되지 않음을 의미합니다).\n"
 "* `Rc` 또는 `Arc`를 사용하여 실수로 [순환참조][reference cycle]을 생성할 수도 있습니다.\n"
 "* 컬렉션을 무한정 채우는 것을 메모리 누출로 간주할 수도 있지만, 러스트는 이를 보호하진 못합니다."
@@ -2083,11 +2001,11 @@ msgid ""
 "* No overhead FFI.\n"
 "* Zero-cost abstractions."
 msgstr ""
-"* 열거형과 패턴 매칭\n"
-"* 제너릭\n"
+"* 열거형과 패턴 매칭.\n"
+"* 제네릭.\n"
 "* FFI 런타임 오버헤드 없음.\n"
 "  * _역주: FFI: Foreign Function Interface. 타 언어 코드를 호출하기 위한 인터페이스_\n"
-"* 제로 코스트 추상화"
+"* 제로 코스트 추상화."
 
 #: src/why-rust/modern.md:12
 msgid "## Tooling"
@@ -2100,10 +2018,10 @@ msgid ""
 "* Built-in support for testing.\n"
 "* Excellent Language Server Protocol support."
 msgstr ""
-"* 친절한 컴파일러 오류메시지\n"
-"* 내장 종속성 관리자\n"
-"* 내장 테스트 지원\n"
-"* LSP (Language Server Protocol, 언어 서버 프로토콜) 지원이 잘되어 있음"
+"* 친절한 컴파일러 오류메시지.\n"
+"* 내장 종속성 관리자.\n"
+"* 내장 테스트 지원.\n"
+"* LSP (Language Server Protocol, 언어 서버 프로토콜) 지원이 잘되어 있음."
 
 #: src/why-rust/modern.md:23
 msgid ""
@@ -2111,9 +2029,7 @@ msgid ""
 "  for higher-level programming constructs with memory or CPU. For example,\n"
 "  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()` 구조를 사용하는 것과 거의 동일한 낮은 수준의 명령어가 생성될 것 입니다."
+msgstr "* C++ 와 유사하게 제로 코스트 추상화는 CPU나 메모리를 사용하여 상위레벨 프로그래밍 구조를 만드는데 '비용'을 지불할 필요가 없습니다. 예를 들어 `for` 루프와와 `iter().fold()` 구조를 사용하는 것과 거의 동일한 낮은 수준의 명령어가 생성될 것 입니다."
 
 #: src/why-rust/modern.md:28
 msgid ""
@@ -2128,17 +2044,14 @@ msgid ""
 "  ignore lengthy compiler output. The Rust compiler is significantly more\n"
 "  talkative than other compilers. It will often provide you with _actionable_\n"
 "  feedback, ready to copy-paste into your code."
-msgstr ""
-"* 오류를 읽어보시기 바랍니다 --- 오랜기간 많은 개발자들이 컴파일러 출력을 무시하는데 익숙해져 있습니다.\n"
-"  러스트 컴파일러는 다른 컴파일러보다 더 수다스럽고, 복사-붙여넣기 할 수 있는 정도의 코드 피드백을 제공하는\n"
-"  경우가 많습니다. "
+msgstr "* 오류를 읽어보시기 바랍니다 --- 오랜기간 많은 개발자들이 컴파일러 출력을 무시하는데 익숙해져 있습니다. 러스트 컴파일러는 다른 컴파일러보다 더 수다스럽고, 복사-붙여넣기 할 수 있는 정도의 코드 피드백을 제공하는 경우가 많습니다."
 
 #: src/why-rust/modern.md:37
 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 ""
@@ -2156,19 +2069,14 @@ msgid ""
 "  go away, so it has to be very stable. For the examples above, the Rust\n"
 "  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"
-"  않았습니다. 어쩌면 이들 중 몇 개는 '최고의 솔루션'이 아예 존재할 수 없을 지도 모릅니다."
+msgstr "  그 이유는 표준 라이브러리에서 한 번 어떤 기능을 제공하면 뺄 수 없으며, 매우 안정적이어야 하기 때문입니다. 위에 언급한 기능들은 아직 러스트 커뮤니티가 최고의 솔루션을 찾지 못했기 때문에 표준 라이브러리에 포함되지 않았습니다. 어쩌면 이들 중 몇 개는 '최고의 솔루션'이 아예 존재할 수 없을 지도 모릅니다."
 
 #: src/why-rust/modern.md:50
 msgid ""
 "  Rust comes with a built-in package manager in the form of Cargo and this makes\n"
 "  it trivial to download and compile third-party crates. A consequence of this\n"
 "  is that the standard library can be smaller."
-msgstr ""
-"  러스트는 카고라는 패키지 관리자가 내장되어 있고, 서드파티 크레이트를 다운로드, 컴파일 하기 매우 쉽습니다.\n"
-"  이 또한 표준 라이브러리가 작은 이유입니다."
+msgstr "  러스트는 카고라는 패키지 관리자가 내장되어 있고, 서드파티 크레이트를 다운로드, 컴파일 하기 매우 쉽습니다. 이 또한 표준 라이브러리가 작은 이유입니다."
 
 #: src/why-rust/modern.md:54
 msgid ""
@@ -2179,9 +2087,7 @@ msgid ""
 "* [rust-analyzer] is a well supported LSP implementation used in major\n"
 "  IDEs and text editors."
 msgstr ""
-"  좋은 서드파티 크레이트를 찾는 것은 어렵습니다. <https://lib.rs> 와 같은 사이트가 신뢰할수\n"
-"  있는 좋은 크레이트를 비교하여 찾는데 좋습니다.\n"
-"  \n"
+"  좋은 서드파티 크레이트를 찾는 것은 어렵습니다. <https://lib.rs> 와 같은 사이트가 신뢰할수 있는 좋은 크레이트를 비교하여 찾는데 좋습니다.\n"
 "* [rust-analyzer]는 주요 IDE나 텍스트 에디터에서 사용되는 러스트용 LSP서버 입니다."
 
 #: src/why-rust/modern.md:61
@@ -2202,7 +2108,7 @@ msgstr "# 기본 문법"
 
 #: src/basic-syntax.md:3
 msgid "Much of the Rust syntax will be familiar to you from C, C++ or Java:"
-msgstr "대부분의 러스트 문법은 C/C++/Java 와 유사합니다."
+msgstr "대부분의 러스트 문법은 C/C++/Java 와 유사합니다:"
 
 #: src/basic-syntax.md:5
 msgid ""
@@ -2212,9 +2118,9 @@ msgid ""
 "* Keywords like `if` and `while` work the same.\n"
 "* Variable assignment is done with `=`, comparison is done with `==`."
 msgstr ""
-"* 블록과  범위는 중괄호`{}`로 표현합니다. \n"
-"* 인라인 주석은 `//`, 블록 주석은 `/* ... */`로 사용합니다. \n"
-"* `if`나 `while`같은 키워드도 동일합니다. \n"
+"* 블록과 범위는 중괄호`{}`로 표현합니다.\n"
+"* 인라인 주석은 `//`, 블록 주석은 `/* ... */`로 사용합니다.\n"
+"* `if`나 `while`같은 키워드도 동일합니다.\n"
 "* 변수 할당은 `=`, 비교는 `==`를 사용합니다."
 
 #: src/basic-syntax/scalar-types.md:1
@@ -2258,7 +2164,7 @@ msgstr ""
 "* `isize` 와 `usize` 는 포인터와 같은 크기입니다.\n"
 "  * _역주: 32 비트 시스템에서는 32 비트, 64 비트 시스템에서는 64 비트. C의 `int`와 같음._\n"
 "* `char` 32 비트 입니다.\n"
-"* `bool`은 8 비트 입니다. "
+"* `bool`은 8 비트 입니다."
 
 #: src/basic-syntax/compound-types.md:1
 msgid "# Compound Types"
@@ -2279,9 +2185,7 @@ 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"
-"\n"
+"* _역주: js기준으로 설명하면 튜플은 ‘순서가 중요해서 사이즈 N으로 고정된 불변(immutable) 배열’ 이라고 보면 됨. 정확히는 서수(순서가 의미가 있는 내용)의 묶음(모음).  갯수N개에 대해서 N-tuple이라고 부르며 2-tuple을 흔히 쓰긴 함.(cf. 열거형)_\n"
 "배열 선언과 접근:"
 
 #: src/basic-syntax/compound-types.md:10
@@ -2361,7 +2265,9 @@ 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)이라고도 합니다. 이는 타입이면서 해당 타입의 유일하며 유효한 값입니다. 즉 타입과 값이 모두 `()`입니다. 예를 들어 함수나 식에서 반환 값이 없음을 나타낼 때 사용합니다.\n"
+"  * 다른 언어에서 익숙한 `void` 개념으로 생각할 수 있습니다."
 
 #: src/basic-syntax/references.md:1
 msgid "# References"
@@ -2411,10 +2317,7 @@ msgid ""
 "* Be sure to note the difference between `let mut ref_x: &i32` and `let ref_x:\n"
 "  &mut i32`. The first one represents a mutable reference which can be bound to\n"
 "  different values, while the second represents a reference to a mutable value."
-msgstr ""
-"`let mut ref_x: &i32`와 `let ref_x: &mut i32`의 차이점에 주의 하시기 바랍니다.\n"
-"첫번째 값은 다른 값에 바인딩 될 수 있는 가변 참조이고, \n"
-"두번째 값은 가변 값에 대한 참조입니다."
+msgstr "`let mut ref_x: &i32`와 `let ref_x: &mut i32`의 차이점에 주의 하시기 바랍니다. 첫번째 값은 다른 값에 바인딩 될 수 있는 가변 참조이고, 두번째 값은 가변 값에 대한 참조입니다."
 
 #: src/basic-syntax/references-dangling.md:1
 msgid "# Dangling References"
@@ -2422,9 +2325,7 @@ msgstr "# 허상(dangling) 참조"
 
 #: src/basic-syntax/references-dangling.md:3
 msgid "Rust will statically forbid dangling references:"
-msgstr ""
-"러스트는 허상(dangling) 참조를 컴파일러 단계에서 찾아내고 금지합니다:\n"
-"* _역주: 허상 참조: 참조 포인터가 더이상 유효하지 않은 값을 가르키게 되는 경우_"
+msgstr "러스트는 허상(dangling) 참조를 컴파일러 단계에서 찾아내고 금지합니다:"
 
 #: src/basic-syntax/references-dangling.md:5
 msgid ""
@@ -2457,7 +2358,7 @@ msgstr "# 슬라이스"
 
 #: src/basic-syntax/slices.md:3
 msgid "A slice gives you a view into a larger collection:"
-msgstr "슬라이스는 큰 컬랙션의 일부(혹은 전체)를 보여주는 뷰(view)입니다."
+msgstr "슬라이스는 큰 컬랙션의 일부(혹은 전체)를 보여주는 뷰(view)입니다:"
 
 #: src/basic-syntax/slices.md:5
 msgid ""
@@ -2480,7 +2381,7 @@ msgid ""
 "* Slices borrow data from the sliced type.\n"
 "* Question: What happens if you modify `a[3]`?"
 msgstr ""
-"* 슬라이스는 다른(슬라이스 된) 타입으로부터 데이터를 '빌려'옵니다. \n"
+"* 슬라이스는 다른(슬라이스 된) 타입으로부터 데이터를 '빌려'옵니다.\n"
 "* 질문: `a[3]`을 수정하면 무슨 일이 있어날까요?"
 
 #: src/basic-syntax/slices.md:20
@@ -2510,10 +2411,8 @@ msgid ""
 "  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"
-" \n"
-"* 슬라이스는 항상 다른 객체로부터 '빌려' 옵니다. 이 예시에서 객체 `a`는 슬라이스  `s`보다 더 오래 살아 있어야만 합니다.\n"
-"    \n"
+"* `s`는 `i32`들로 이루어진 슬라이스에 대한 참조입니다. `s`의 타입(`&[i32]`)에 배열의 크기가 빠져있음에 주목하시기 바랍니다. 즉, 슬라이스를 이용하면 다양한 길이의 데이터를 다룰 수 있습니다.\n"
+"* 슬라이스는 항상 다른 객체로부터 '빌려' 옵니다. 이 예시에서 객체 `a`는 슬라이스 `s`보다 더 오래 살아 있어야만 합니다.\n"
 "* `a[3]`의 값을 바꿀 수 있냐는 질문은 좋은 질문입니다. 여기에 대한 답은 `a`와 `s`를 통해 데이터를 읽을 수는 있지만 수정할 수는 없으며, 이는 메모리 안전을 위해서라는 것입니다. 왜 그런지에 대한 좀더 구체적인 답은 빌림 검사 부분에서 자세히 설명합니다."
 
 #: src/basic-syntax/string-slices.md:1
@@ -2561,9 +2460,7 @@ msgstr ""
 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"
-" 문자열 리터럴(`”Hello”`)은 프로그램 바이너리에 저장됩니다. "
+msgstr "* `&str`은 문자열 슬라이스의 불변 참조입니다. 러스트에서 문자열은 UTF-8로 인코딩된 데이터를 의미합니다. 문자열 리터럴(`”Hello”`)은 프로그램 바이너리에 저장됩니다."
 
 #: src/basic-syntax/string-slices.md:30
 msgid ""
@@ -2573,9 +2470,7 @@ msgid ""
 "  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::from`는 문자열 리터럴로부터 문자열을 생성합니다.\n"
-"  * `String::new()`는 새로운 빈 문자열을 생성합니다. \n"
-"  * `push()`와 `push_str()`메서드를 사용하여 문자열 데이터를 추가 할 수 있습니다."
+"* 다른 많은 타입들처럼 `String::from`는 문자열 리터럴로부터 문자열을 생성합니다. `String::new()`는 새로운 빈 문자열을 생성합니다. `push()`와 `push_str()`메서드를 사용하여 문자열 데이터를 추가 할 수 있습니다."
 
 #: src/basic-syntax/string-slices.md:35
 msgid ""
@@ -2590,11 +2485,9 @@ msgid ""
 "    \n"
 "</details>"
 msgstr ""
-"* `format!()` 매크로는 변수의 값을 문자열로 변환하는 편리한 방법입니다.\n"
-"  이 매크로는 `println!()` 매크로와 동일한 포맷팅 형식을 지원합니다.\n"
+"* `format!()` 매크로는 변수의 값을 문자열로 변환하는 편리한 방법입니다. 이 매크로는 `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` 과 대략 거의 동일합니다. (주요 차이점: 러스트의 `String`은 UTF-8 인코딩 바이트만 포함할 수 있으며 작은 문자열 최적화(small-string optimization)는 사용하지 않습니다.\n"
 "    \n"
 "</details>"
 
@@ -2604,12 +2497,7 @@ msgstr "# 함수"
 
 #: src/basic-syntax/functions.md:3
 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"
-"    * _edge case: 경계조건. 매개변수 값이 극단적인 최대/최소값  (로직 유효범위 끝) 이상인 경우._\n"
-"  * _fizzbuzz: 숫자를 입력받아서 3으로 나뉘면 fizz, 5으로 나뉘면 buss, 둘다  나뉘면 fizzbuzz, 안나뉘면 입력값을 출력하는 테스트로 자주 쓰는 문제입니다._"
+msgstr "러스트 버전의 [FizzBuzz](https://en.wikipedia.org/wiki/Fizz_buzz) 함수입니다:"
 
 #: src/basic-syntax/functions.md:5
 msgid ""
@@ -2687,7 +2575,7 @@ msgstr ""
 "* `main` 함수에서 그 다음에 오는 함수들을 사용할 수 있습니다. 상단에 선언이나 헤더 같은건 필요 없습니다.\n"
 "* 매개변수를 선언할 때에는 이름을 먼저 쓰고, 타입을 나중에 씁니다. 이름과 타입은 `:` 로 구분합니다. 이는 일부 언어(예를 들어 C)와 반대임에 유의하시기 바랍니다. 마찬가지로, 리턴 타입도 함수의 시작이 아닌 가장 뒷부분에 선언합니다.\n"
 "* 함수 본문의 마지막 표현식은 반환 값이 됩니다. 간단히, 식 끝에 있는 `;`를 생략하면 됩니다.\n"
-"* 반환값이 없는 함수의 경우, `유닛 타입 ()`을 반환합니다. `-> ()`가 생략된 경우 컴파일러는 이를 추론합니다.* `fizzbuzz_to()`함수 내 `for` 반목문의 rage 표현식 중 `=n`은 해당 범위까지 포함한다는 의미입니다. \n"
+"* 반환값이 없는 함수의 경우, `유닛 타입 ()`을 반환합니다. `-> ()`가 생략된 경우 컴파일러는 이를 추론합니다.* `fizzbuzz_to()`함수 내 `for` 반목문의 rage 표현식 중 `=n`은 해당 범위까지 포함한다는 의미입니다.\n"
 "* `fizzbuzz()`함수의 `match` 표현식은 많은 일을 합니다. 무슨 일이 일어나는지 조금 더 이해하기 쉽도록 아래 코드를 확인하시기 바랍니다."
 
 #: src/basic-syntax/functions.md:42
@@ -2717,9 +2605,7 @@ msgstr "# 메서드"
 msgid ""
 "Rust has methods, they are simply functions that are associated with a particular type. The\n"
 "first argument of a method is an instance of the type it is associated with:"
-msgstr ""
-"러스트의 메서드는 특정 타입과 연결된 함수입니다.\n"
-"메서드의 첫번째 인자의 타입이 바로 그 메서드가 연결된 타입입니다."
+msgstr "러스트의 메서드는 특정 타입과 연결된 함수입니다. 메서드의 첫번째 인자의 타입이 바로 그 메서드가 연결된 타입입니다:"
 
 #: src/basic-syntax/methods.md:6
 msgid ""
@@ -2767,7 +2653,7 @@ msgstr "# (함수) 오버로딩"
 
 #: src/basic-syntax/functions-interlude.md:3
 msgid "Overloading is not supported:"
-msgstr "오버로딩은 지원되지 않습니다: "
+msgstr "오버로딩은 지원되지 않습니다:"
 
 #: src/basic-syntax/functions-interlude.md:5
 msgid ""
@@ -2783,11 +2669,11 @@ msgstr ""
 "  * 파라매터들의 타입은 항상 고정되어 있습니다.\n"
 "* 파라매터의 기본 값은 지원되지 않습니다.\n"
 "  * 모든 호출부에서는 동일한 수의 인자를 설정해야합니다. \n"
-"  * 이런 사항들이 제약이 될 경우, 대안으로 매크로를 사용하기도 합니다. "
+"  * 이런 사항들이 제약이 될 경우, 대안으로 매크로를 사용하기도 합니다."
 
 #: src/basic-syntax/functions-interlude.md:12
 msgid "However, function parameters can be generic:"
-msgstr "하지만, 함수의 매개변수는 제너릭을 적용할 수 있습니다:"
+msgstr "하지만, 함수의 매개변수는 제네릭을 적용할 수 있습니다:"
 
 #: src/basic-syntax/functions-interlude.md:14
 msgid ""
@@ -2810,7 +2696,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>"
@@ -2826,15 +2712,15 @@ msgstr "이번 연습문제는 러스트의 두 부분을 알아볼 것입니다
 
 #: src/exercises/day-1/morning.md:5
 msgid "* Implicit conversions between types."
-msgstr "* 타입의 묵시적 변환 "
+msgstr "* 타입의 묵시적 변환."
 
 #: src/exercises/day-1/morning.md:7
 msgid "* Arrays and `for` loops."
-msgstr "* 배열과 `for` 반복문"
+msgstr "* 배열과 `for` 반복문."
 
 #: src/exercises/day-1/morning.md:11
 msgid "A few things to consider while solving the exercises:"
-msgstr "연습문제를 해결하는데 고려해야 할 사항들: "
+msgstr "연습문제를 해결하는데 고려해야 할 사항들:"
 
 #: src/exercises/day-1/morning.md:13
 msgid ""
@@ -2845,13 +2731,13 @@ msgstr "* 가능하다면 러스트가 설치된 로컬 환경에서 진행하
 
 #: src/exercises/day-1/morning.md:17
 msgid "* Alternatively, use the Rust Playground."
-msgstr "* 혹은 러스트 플레이그라운드를 이용할 수 있습니다. "
+msgstr "* 혹은 러스트 플레이그라운드를 이용할 수 있습니다."
 
 #: src/exercises/day-1/morning.md:19
 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
@@ -2876,9 +2762,7 @@ msgstr "# 묵시적 형변환"
 msgid ""
 "Rust will not automatically apply _implicit conversions_ between types ([unlike\n"
 "C++][3]). You can see this in a program like this:"
-msgstr ""
-"러스트는 [C++ 와 다르게][3] 타입 간 _묵시적 변환_을 자동으로 적용하지  않습니다.\n"
-"아래 예시를 확인해 보세요:"
+msgstr "러스트는 [C++ 와 다르게][3] 타입 간 _묵시적 변환_을 자동으로 적용하지  않습니다. 아래 예시를 확인해 보세요:"
 
 #: src/exercises/day-1/implicit-conversions.md:6
 msgid ""
@@ -2909,10 +2793,7 @@ msgid ""
 "method and similarly, the `Into<T>` trait has a single `into()` method.\n"
 "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`과 `Into` 트레이트를 구현함으로써, 타입 간 변환이 가능하다는 것을 표현합니다."
+msgstr "러스트의 정수형 타입은 모두 [`From<T>`][1] 와 [`Into<T>`][2] 트레잇을 구현하고 있으며, 이를 통해 타입 변환이 이루어 집니다. `From<T>` 트레잇은 `from()` 메서드를 가지고 있고, `Into<T>`트레잇은 `into()` 메서드를 가지고 있습니다. 러스트에서는 `From`과 `Into` 트레잇을 구현함으로써, 타입 간 변환이 가능하다는 것을 표현합니다."
 
 #: src/exercises/day-1/implicit-conversions.md:25
 msgid ""
@@ -2920,9 +2801,7 @@ msgid ""
 "that we can convert a variable `x` of type `i8` to an `i16` by calling \n"
 "`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` 구현이 자동으로 생성되기 때문입니다."
+msgstr "표준 라이브러리에는 `From<i8> for i16`가 구현되어 있는데 이것은 `i8` 타입의 변수 `x`를 `i16::from(x)`를 호출하여 `i16`타입으로 변환할 수 있다는 의미입니다. 혹은 더 간단하게 `x.into()`를 사용할 수도 있습니다. 이것이 가능한 이유는 `From<i8> for i16` 구현을 가지고 있으면 `Into<i16> for i8` 구현이 자동으로 생성되기 때문입니다."
 
 #: src/exercises/day-1/implicit-conversions.md:30
 msgid ""
@@ -2945,10 +2824,7 @@ msgid ""
 "   converting small types to big types and the other way around. Check the\n"
 "   [standard library documentation][1] to see if `From<T>` is implemented for\n"
 "   the pairs you check."
-msgstr ""
-"3. `x`와 `y`를 `f32'이나 'bool', 'i128' 등으로 바꿔서 해당 타입들로 변환이 되는지 확인해보세요.\n"
-"   - 작은 사이즈 타입에서 큰 사이즈로 변경해보시고 그 반대로도 해보세요.\n"
-"   - [표준 라이브러리 문서][1]에서 시도해 본 케이스가 구현되어 있는지 확인해 보세요."
+msgstr "3. `x`와 `y`를 `f32'이나 'bool', 'i128' 등으로 바꿔서 해당 타입들로 변환이 되는지 확인해보세요. 작은 사이즈 타입에서 큰 사이즈로 변경해보시고 그 반대로도 해보세요. [표준 라이브러리 문서][1]에서 시도해 본 케이스가 구현되어 있는지 확인해 보세요."
 
 #: src/exercises/day-1/implicit-conversions.md:43
 msgid ""
@@ -2974,7 +2850,7 @@ msgstr ""
 
 #: src/exercises/day-1/for-loops.md:9
 msgid "You can print such an array by asking for its debug representation with `{:?}`:"
-msgstr "배열을 출력하려면 `{:?}`를 씁니다."
+msgstr "배열을 출력하려면 `{:?}`를 씁니다:"
 
 #: src/exercises/day-1/for-loops.md:11
 msgid ""
@@ -3019,7 +2895,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 ""
@@ -3038,7 +2914,7 @@ msgstr "두 함수 모두 행렬의 크기는 3 x 3 으로 하드코딩 합니
 msgid ""
 "Copy the code below to <https://play.rust-lang.org/> and implement the\n"
 "functions:"
-msgstr "아래 코드를 <https://play.rust-lang.org/>에 복사해서 구현하시면 됩니다."
+msgstr "아래 코드를 <https://play.rust-lang.org/>에 복사해서 구현하시면 됩니다:"
 
 #: src/exercises/day-1/for-loops.md:52 src/exercises/day-1/book-library.md:20
 #: src/exercises/day-2/health-statistics.md:13
@@ -3100,9 +2976,7 @@ msgid ""
 "Could you use `&[i32]` slices instead of hard-coded 3 × 3 matrices for your\n"
 "argument and return types? Something like `&[&[i32]]` for a two-dimensional\n"
 "slice-of-slices. Why or why not?"
-msgstr ""
-"`&[i32]`슬라이스를 잘 이용하면 행렬 크기를 3 x 3으로 하드코딩 하지 않을 수 있을까요?\n"
-"예컨데 `&[&[i32]]`는 2차원 슬라이스의 슬라이스 입니다. 가능하다면/하지 않다면 왜 그런가요?"
+msgstr "`&[i32]`슬라이스를 잘 이용하면 행렬 크기를 3 x 3으로 하드코딩 하지 않을 수 있을까요? 예컨데 `&[&[i32]]`는 2차원 슬라이스의 슬라이스 입니다. 가능하다면/하지 않다면 왜 그런가요?"
 
 #: src/exercises/day-1/for-loops.md:87
 msgid ""
@@ -3124,9 +2998,7 @@ msgstr "# 변수"
 msgid ""
 "Rust provides type safety via static typing. Variable bindings are immutable by\n"
 "default:"
-msgstr ""
-"러스트는 정적 타이핑을 통해 타입 안전성을 제공합니다.\n"
-"변수는 기본적으로 불변(immutable)합니다."
+msgstr "러스트는 정적 타이핑을 통해 타입 안전성을 제공합니다. 변수는 기본적으로 불변(immutable)합니다:"
 
 #: src/basic-syntax/variables.md:6
 msgid ""
@@ -3162,7 +3034,7 @@ msgstr "# 타입 추론"
 
 #: src/basic-syntax/type-inference.md:3
 msgid "Rust will look at how the variable is _used_ to determine the type:"
-msgstr "러스트는 변수가 어떻게 사용되는지를 보고 그 변수의 타입을 추론합니다. "
+msgstr "러스트는 변수가 어떻게 사용되는지를 보고 그 변수의 타입을 추론합니다:"
 
 #: src/basic-syntax/type-inference.md:5
 msgid ""
@@ -3202,15 +3074,11 @@ msgid ""
 "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"
-"명시적인 타입 선언이 있던 없던, 컴파일러가 생성한 머신코드는 동일합니다. 컴파일러는 단지 타입 선언을 생략할 수 있도록 해서 프로그래머가 더 간결한 코드를 쓸 수 있도록 도와줄 뿐입니다."
+msgstr "이 슬라이드는, 러스트 컴파일러가 변수가 어떻게 선언되어 있고, 어떻게 사용되는지를 제약 조건으로 삼아서 변수의 타입을 추론하는 모습을 보여줍니다. 여기서 중요한 것은, 이렇게 명시적인 타입을 생략하고 선언되었다고 해서 \"어떤 타입\"이라도 다 담을 수 있는 타입이 되는 것은 아니라는 점입니다. 명시적인 타입 선언이 있던 없던, 컴파일러가 생성한 머신코드는 동일합니다. 컴파일러는 단지 타입 선언을 생략할 수 있도록 해서 프로그래머가 더 간결한 코드를 쓸 수 있도록 도와줄 뿐입니다."
 
 #: 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 "아래 코드는, 제너릭 컨테이너를 쓸 때 컨테이터 안에 포함된 데이터의 타입을 명시적으로 쓰지 않고 `_`로 대체하여도 된다는 것을 보여줍니다."
+msgstr "아래 코드는, 제네릭 컨테이너를 쓸 때 컨테이터 안에 포함된 데이터의 타입을 명시적으로 쓰지 않고 `_`로 대체하여도 된다는 것을 보여줍니다:"
 
 #: src/basic-syntax/type-inference.md:34
 msgid ""
@@ -3248,7 +3116,7 @@ msgstr "## 상수(`const`)"
 
 #: src/basic-syntax/static-and-const.md:7
 msgid "You can declare compile-time constants:"
-msgstr "컴파일 시 값이 정해지는 상수를 선언할 수 있습니다."
+msgstr "컴파일 시 값이 정해지는 상수를 선언할 수 있습니다:"
 
 #: src/basic-syntax/static-and-const.md:9
 msgid ""
@@ -3287,7 +3155,7 @@ msgstr "## 정적변수(`static`)"
 
 #: src/basic-syntax/static-and-const.md:31
 msgid "You can also declare static variables:"
-msgstr "마찬가지로 정적 변수도 선언할 수 있습니다."
+msgstr "마찬가지로 정적 변수도 선언할 수 있습니다:"
 
 #: src/basic-syntax/static-and-const.md:33
 msgid ""
@@ -3402,7 +3270,7 @@ msgid ""
 "* Full safety via automatic memory management at runtime: Java, Python, Go, Haskell, ..."
 msgstr ""
 "* 메모리 관리가 프로그래머의 완전한 통제하에 있지만 수동(_역주_: 그래서 안전하지 않을 수 있는)이 언어: C, C++, Pascal, ...\n"
-"* 메모리 관리가 런타임에 의해 되므로 안전하지만 자동(_역주_: 그래서 프로그래머가 개입할 여지가 적거나 없는)인 언어: Java, Python, Go, Haskell, ... "
+"* 메모리 관리가 런타임에 의해 되므로 안전하지만 자동(_역주_: 그래서 프로그래머가 개입할 여지가 적거나 없는)인 언어: Java, Python, Go, Haskell, ..."
 
 #: src/memory-management.md:8
 msgid "Rust offers a new mix:"
@@ -3412,7 +3280,7 @@ msgstr "러스트는 이 둘을 혼합한 새로운 형태의 메모리 관리 
 msgid ""
 "> Full control *and* safety via compile time enforcement of correct memory\n"
 "> management."
-msgstr "> 완전한 통제와 안전"
+msgstr "> 완전한 통제와 안전."
 
 #: src/memory-management.md:13
 msgid "It does this with an explicit ownership concept."
@@ -3494,13 +3362,11 @@ msgstr "* 문자열(`String`)은 실제로는 `Vec`입니다. 크기(capacity)
 
 #: 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]"
-msgstr ""
-"* 힙은 기본적으로 [System Allocator]를 통해 할당됩니다. 그리고 [Allocator API]를 이용해서\n"
-"  커스텀 메모리 할당자를 만들 수도 있습니다."
+msgstr "* 힙은 기본적으로 [System Allocator]를 통해 할당됩니다. 그리고 [Allocator API]를 이용해서 커스텀 메모리 할당자를 만들 수도 있습니다."
 
 #: 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` 코드로 메모리 레이아웃을 살펴볼 수 있습니다. 물론 이 코드가 안전하지 않다는 점을 알려주세요."
+msgstr "* `unsafe` 코드로 메모리 레이아웃을 살펴볼 수 있습니다. 물론 이 코드가 안전하지 않다는 점을 알려주세요!"
 
 #: src/memory-management/stack.md:34
 msgid ""
@@ -3560,7 +3426,7 @@ msgstr "## C 언어 예제"
 
 #: src/memory-management/manual.md:9
 msgid "You must call `free` on every pointer you allocate with `malloc`:"
-msgstr "`malloc`으로 할당하는 포인터마다 `free`를 호출해야 합니다: "
+msgstr "`malloc`으로 할당하는 포인터마다 `free`를 호출해야 합니다:"
 
 #: src/memory-management/manual.md:11
 msgid ""
@@ -3579,9 +3445,7 @@ msgstr ""
 msgid ""
 "Memory is leaked if the function returns early between `malloc` and `free`: the\n"
 "pointer is lost and we cannot deallocate the memory."
-msgstr ""
-"만약`malloc` 과 `free` 사이에서 함수가 일찍 반환되면 메모리 누출이 일어납니다:\n"
-" 포인터를 잃어버리게 되어 메모리를 반환할 수 없게 됩니다."
+msgstr "만약`malloc` 과 `free` 사이에서 함수가 일찍 반환되면 메모리 누출이 일어납니다: 포인터를 잃어버리게 되어 메모리를 반환할 수 없게 됩니다."
 
 #: src/memory-management/scope-based.md:1
 msgid "# Scope-Based Memory Management"
@@ -3596,10 +3460,7 @@ msgid ""
 "By wrapping a pointer in an object, you can free memory when the object is\n"
 "destroyed. The compiler guarantees that this happens, even if an exception is\n"
 "raised."
-msgstr ""
-"포인터를 객체로 감싸도록 하면, 그 객체가 소멸될 때 그 포인터가 가리키는 메모리가 \n"
-"해제되도록 할 수 있습니다. 컴파일러는 객체가 소멸될 때 반드시 소멸자가 호출되는 것을 \n"
-"보장합니다. 심지어는 예외(exception)가 발생(_역주_: 함수의 리턴이나 스코프의 종료 뿐만이 아니라) 하더라도요."
+msgstr "포인터를 객체로 감싸도록 하면, 그 객체가 소멸될 때 그 포인터가 가리키는 메모리가 해제되도록 할 수 있습니다. 컴파일러는 객체가 소멸될 때 반드시 소멸자가 호출되는 것을 보장합니다. 심지어는 예외(exception)가 발생(_역주_: 함수의 리턴이나 스코프의 종료 뿐만이 아니라) 하더라도요."
 
 #: src/memory-management/scope-based.md:9
 msgid ""
@@ -3633,7 +3494,7 @@ msgstr ""
 
 #: src/memory-management/scope-based.md:25
 msgid "Special move constructors are used when passing ownership to a function:"
-msgstr "이동 생성자는 함수 호출 시 소유권을 전달할때 사용됩니다."
+msgstr "이동 생성자는 함수 호출 시 소유권을 전달할때 사용됩니다:"
 
 #: src/memory-management/scope-based.md:27
 msgid ""
@@ -3693,8 +3554,8 @@ msgid ""
 "* 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."
 msgstr ""
-"* 자바처럼 안전하고 정확합니다. 하지만 GC는 없습니다. \n"
-"* 다양한 추상화를 제공합니다: 단일 포인터, 참조 카운트, 아토믹(atomic) 참조 카운트\n"
+"* 자바처럼 안전하고 정확합니다. 하지만 GC는 없습니다.\n"
+"* 다양한 추상화를 제공합니다: 단일 포인터, 참조 카운트, 아토믹(atomic) 참조 카운트.\n"
 "* C++ 처럼 범위(스코프) 기반입니다. 하지만 컴파일러가 훨씬 더 엄격합니다.\n"
 "* 사용자는 상황에 따라 적합한 추상화를 선택할 수 있습니다. 그 중에는 C 언어 처럼 런타임 오버헤드가 없는 것도 있습니다."
 
@@ -3708,7 +3569,7 @@ msgstr "* 이 시점에서 그게 어떻게 가능하냐는 질문이 있으면,
 
 #: src/memory-management/rust.md:16
 msgid "* You may be asked about destructors here, the [Drop] trait is the Rust equivalent."
-msgstr "* 소멸자에 대한 질문도 있을 수 있습니다. [Drop] 트레이트가 답입니다."
+msgstr "* 소멸자에 대한 질문도 있을 수 있습니다. [Drop] 트레잇이 답입니다."
 
 #: src/memory-management/rust.md:20
 msgid ""
@@ -3757,7 +3618,7 @@ msgstr ""
 "* 러스트와 같은 컴파일러 수행 범위 기반 관리: \n"
 "  * 컴파일러에 의해 수행됩니다.\n"
 "  * 런타임 오버헤드가 없습니다. \n"
-"  * 안전하고 정확합니다. "
+"  * 안전하고 정확합니다."
 
 #: src/memory-management/comparison.md:20
 msgid "## Cons of Different Memory Management Techniques"
@@ -3779,19 +3640,19 @@ msgid ""
 "  * Some upfront complexity.\n"
 "  * Can reject valid programs."
 msgstr ""
-"* C와 같은 수동 관리: \n"
-"  * 사용 후 해제 문제\n"
-"  * 이중 해제 문제\n"
-"  * 메모리 누출 문제\n"
-"* JAVA와 같은 자동화 관리: \n"
-"  * GC동작으로 인한 멈춤\n"
+"* C와 같은 수동 관리:\n"
+"  * 사용 후 해제 문제.\n"
+"  * 이중 해제 문제.\n"
+"  * 메모리 누출 문제.\n"
+"* JAVA와 같은 자동화 관리:\n"
+"  * GC동작으로 인한 멈춤.\n"
 "  * 소멸자 지연 (_역주_: 특정 메모리를 더이상 사용하지 않더라도 곧바로 해제 되지 않고 GC가 동작할 때 까지 기다려야 한다는 점)\n"
-"* C++ 와 같은 범위 기반 관리: \n"
-"  * 복잡하며, 개발자의 선택사항임\n"
-"  * 사용 후 해제 문제 가능성 있음\n"
-"* 러스트와 같은 컴파일러가 강제하는 수행 범위 기반 관리: \n"
-"  * 약간의 초기 복잡성\n"
-"  * 올바른 프로그램이지만 컴파일러가 거부할 수 있음"
+"* C++ 와 같은 범위 기반 관리:\n"
+"  * 복잡하며, 개발자의 선택사항임.\n"
+"  * 사용 후 해제 문제 가능성 있음.\n"
+"* 러스트와 같은 컴파일러가 강제하는 수행 범위 기반 관리:\n"
+"  * 약간의 초기 복잡성.\n"
+"  * 올바른 프로그램이지만 컴파일러가 거부할 수 있음."
 
 #: src/ownership.md:1
 msgid "# Ownership"
@@ -3801,7 +3662,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 ""
@@ -3892,7 +3753,7 @@ msgid ""
 "* The heap data from `s1` is reused for `s2`.\n"
 "* When `s1` goes out of scope, nothing happens (it has been moved from)."
 msgstr ""
-"* `s1`의 힙 데이터는 `s2`에서 재사용 됩니다. \n"
+"* `s1`의 힙 데이터는 `s2`에서 재사용 됩니다.\n"
 "* `s1`의 스코프가 종료되면 아무일도 일어나지 않습니다.(이미 이동되었습니다.)"
 
 #: src/ownership/moved-strings-rust.md:13
@@ -3971,7 +3832,7 @@ msgstr ""
 
 #: src/ownership/double-free-modern-cpp.md:13
 msgid "Before copy-assignment:"
-msgstr "복사 전"
+msgstr "복사 전:"
 
 #: src/ownership/double-free-modern-cpp.md:16
 msgid ""
@@ -3992,7 +3853,7 @@ msgstr ""
 
 #: src/ownership/double-free-modern-cpp.md:30
 msgid "After copy-assignment:"
-msgstr "복사 후"
+msgstr "복사 후:"
 
 #: src/ownership/double-free-modern-cpp.md:32
 msgid ""
@@ -4054,12 +3915,11 @@ msgid ""
 "* 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."
 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++에서보다 어렵습니다."
 
 #: src/ownership/copy-clone.md:1
 msgid "# Copying and Cloning"
@@ -4083,11 +3943,11 @@ msgstr ""
 
 #: src/ownership/copy-clone.md:14
 msgid "These types implement the `Copy` trait."
-msgstr "이러한 타입들은 `Copy` 트레이트를 구현합니다. "
+msgstr "이러한 타입들은 `Copy` 트레잇을 구현합니다."
 
 #: src/ownership/copy-clone.md:16
 msgid "You can opt-in your own types to use copy semantics:"
-msgstr "직접 만든 타입들도 `Copy`트레이트를 구현하여 복사를 할 수 있습니다:"
+msgstr "직접 만든 타입들도 `Copy`트레잇을 구현하여 복사를 할 수 있습니다:"
 
 #: src/ownership/copy-clone.md:18
 msgid ""
@@ -4117,7 +3977,7 @@ msgstr ""
 
 #: src/ownership/copy-clone.md:35
 msgid "Copying and cloning are not the same thing:"
-msgstr "복사(copying)와 복제(cloning)는 같지 않습니다: "
+msgstr "복사(copying)와 복제(cloning)는 같지 않습니다:"
 
 #: src/ownership/copy-clone.md:37
 msgid ""
@@ -4126,10 +3986,10 @@ msgid ""
 "* 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"
+"* 복사는 메모리의 내용을 그대로 한 벌 더 만드는 것을 의미하며, 아무 객체에서나 다 지원하지는 않습니다.\n"
 "* 복사는 커스터마이즈 할 수 없습니다. (C++에서 복사 생성자를 통해 복사 동작을 임의로 구현할 수 있는 것과 비교가 됩니다.)\n"
-"* 복제는 보다 일반적인 작업이며, `Clone`트레이트를 구현하여 복제시 동작을 커스터마이즈 할 수 있습니다.\n"
-"* `Drop` 트레이트를 구현한 타입은 복사되지 않습니다."
+"* 복제는 보다 일반적인 작업이며, `Clone`트레잇을 구현하여 복제시 동작을 커스터마이즈 할 수 있습니다.\n"
+"* `Drop` 트레잇을 구현한 타입은 복사되지 않습니다."
 
 #: src/ownership/copy-clone.md:42 src/ownership/lifetimes-function-calls.md:29
 msgid "In the above example, try the following:"
@@ -4141,7 +4001,7 @@ msgid ""
 "* 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"
+"* `Point`구조체에 `String`필드를 추가하세요. 컴파일 되지 않을 것입니다. 왜냐하면 `String`은 `Copy`트레잇을 구현하고 있지 않기 때문입니다.\n"
 "* `derive` 속성에서 `Copy`를 제거해 보세요. `p1`을 `println!` 할 때 컴파일 에러가 발생할 것입니다.\n"
 "* `p1`을 복제하면 잘 동작함을 확인해 보세요."
 
@@ -4152,9 +4012,7 @@ msgid ""
 "    \n"
 "</details>"
 msgstr ""
-"만약 학생들이 `derive`에 대해 묻는다면, 컴파일 시 러스트에서 코드를 생성하는방법이라고 말하는 것으로 충분합니다.\n"
-"위 경우 `Copy`와 `Clone` 트레이트에 대한 기본 구현이 생성됩니다.\n"
-"    \n"
+"만약 학생들이 `derive`에 대해 묻는다면, 컴파일 시 러스트에서 코드를 생성하는방법이라고 말하는 것으로 충분합니다. 위 경우 `Copy`와 `Clone` 트레잇에 대한 기본 구현이 생성됩니다.\n"
 "</details>"
 
 #: src/ownership/borrowing.md:1
@@ -4206,7 +4064,7 @@ msgid ""
 "* 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 ""
@@ -4360,7 +4218,7 @@ msgid ""
 "  lifetime `a`\".\n"
 "  * The _at least_ part is important when parameters are in different scopes."
 msgstr ""
-"* `'a`는 제너릭 매개변수로 컴파일러로에 의해 추론됩니다.\n"
+"* `'a`는 제네릭 매개변수로 컴파일러로에 의해 추론됩니다.\n"
 "* 수명의 이름은 `'` 로 시작하며 보통 `'a`를 많이 씁니다.\n"
 "* `&'a Point` 는 `Point`의 수명이 `'a` 수명과 최소한 같거나 더 길다는 것을 의미합니다.\n"
 "  * 매개변수들이 서로 다른 스코프에 있을 경우 _최소한_이라는 조건이 중요합니다."
@@ -4421,7 +4279,7 @@ msgid ""
 "    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"
-"* 이 에러를 설명하는 또 다른 방법은 다음과 같습니다:  \n"
+"* 이 에러를 설명하는 또 다른 방법은 다음과 같습니다:\n"
 "  * 이 함수는 두 값을 빌려서, 새로운 참조를 반환합니다.\n"
 "  * 이 반환된 참조는 두 입력 중 하나로 부터 와야 합니다. (아니면 전역 변수로 부터)\n"
 "  * 두 입력 중 어떤 것일까요? 컴파일러는 이를 알아야 합니다. 그래야만 함수 호출부에서 봤을 때, 반환된 참조의 수명이 원래 값을 수명보다 길지 않음을 확인할 수 있기 때문입니다."
@@ -4470,15 +4328,11 @@ msgid ""
 "* 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"
-"  그 내부의 `&str`가 가리키는 데이터 역시 살아있어야 한다는 것을 의미합니다.\n"
-"* 만약 `text`가 `fox` (혹은 `dog`)의 수명이 다하기 전에 `erase`함수 호출 등으로 사라지게 된다면\n"
-"  빌림 검사기가 에러를 발생합니다.\n"
-"* 빌린 데이터를 가지고 있는 타입은 사용자로 하여금 원본 데이터를 유지하도록 강제합니다. 이런 타입은 경량 뷰(lightweight view)를\n"
-"  만드는데 유용하지만, 이 제약 조건 때문에 이런 타입을 사용하는 것이 쉽지만은 않습니다.\n"
+"* 위의 예제에서 `Highlight`의 어노테이션(`<'doc>`)은 적어도 `Highlight` 인스턴스가 살아있는 동안에는 그 내부의 `&str`가 가리키는 데이터 역시 살아있어야 한다는 것을 의미합니다.\n"
+"* 만약 `text`가 `fox` (혹은 `dog`)의 수명이 다하기 전에 `erase`함수 호출 등으로 사라지게 된다면 빌림 검사기가 에러를 발생합니다.\n"
+"* 빌린 데이터를 가지고 있는 타입은 사용자로 하여금 원본 데이터를 유지하도록 강제합니다. 이런 타입은 경량 뷰(lightweight view)를 만드는데 유용하지만, 이 제약 조건 때문에 이런 타입을 사용하는 것이 쉽지만은 않습니다.\n"
 "* 따라서, 가능하다면, 구조체가 자신의 데이터를 직접 소유하도록 하는 것이 좋습니다.\n"
-"* 한 구조체안에 여러 참조가 있으면서, 이 참조들의 수명이 서로 다르게 지정되는 경우도 있습니다. 이는 참조와 그 구조체 간의 관계 뿐만이 아니라,\n"
-"  그 참조들 사이의 수명 관계를 설명해야 할 경우에 필요합니다. 매우 고급 기술입니다.\n"
+"* 한 구조체안에 여러 참조가 있으면서, 이 참조들의 수명이 서로 다르게 지정되는 경우도 있습니다. 이는 참조와 그 구조체 간의 관계 뿐만이 아니라, 그 참조들 사이의 수명 관계를 설명해야 할 경우에 필요합니다. 매우 고급 기술입니다.\n"
 "</details>"
 
 #: src/exercises/day-1/afternoon.md:1
@@ -4491,7 +4345,7 @@ msgstr "이번 연습문제는 아래 두가지입니다:"
 
 #: src/exercises/day-1/afternoon.md:5
 msgid "* A small book library,"
-msgstr "* 작은 도서관"
+msgstr "* 작은 도서관,"
 
 #: src/exercises/day-1/afternoon.md:7
 msgid "* Iterators and ownership (hard)."
@@ -4509,9 +4363,7 @@ msgstr "# 도서관 설계"
 msgid ""
 "We will learn much more about structs and the `Vec<T>` type tomorrow. For now,\n"
 "you just need to know part of its API:"
-msgstr ""
-"우리는 내일 구조체와 `Vec<T>`에 대해 더 많은 것을 배울 것입니다.  \n"
-"일단 오늘은 API의 일부만 알면 됩니다:"
+msgstr "우리는 내일 구조체와 `Vec<T>`에 대해 더 많은 것을 배울 것입니다. 일단 오늘은 API의 일부만 알면 됩니다:"
 
 #: src/exercises/day-1/book-library.md:6
 msgid ""
@@ -4531,7 +4383,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 ""
@@ -4682,9 +4534,7 @@ msgid ""
 "[`Iterator`](https://doc.rust-lang.org/std/iter/trait.Iterator.html) and\n"
 "[`IntoIterator`](https://doc.rust-lang.org/std/iter/trait.IntoIterator.html)\n"
 "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) 같은 트레이트가 있습니다."
+msgstr "러스트의 소유권 모델은 많은 API에 반영이 되어 있습니다. 예를들어 [`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`"
@@ -4694,7 +4544,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 ""
@@ -4708,7 +4558,7 @@ msgstr ""
 
 #: src/exercises/day-1/iterators-and-ownership.md:20
 msgid "You use this trait like this:"
-msgstr "`Iterator` 트레이트는 이렇게 사용합니다:"
+msgstr "`Iterator` 트레잇은 이렇게 사용합니다:"
 
 #: src/exercises/day-1/iterators-and-ownership.md:22
 msgid ""
@@ -4761,7 +4611,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 ""
@@ -4819,9 +4669,7 @@ msgid ""
 "Now that we know both `Iterator` and `IntoIterator`, we can build `for` loops.\n"
 "They call `into_iter()` on an expression and iterates over the resulting\n"
 "iterator:"
-msgstr ""
-"자, 이제 우리는 `Iterator`와 `IntoIterator`를 알았으므로 `for` 루프를 만들 수 있습니다. \n"
-"`for` 루프는 `into_iter()`를 호출하여 반복자를 만든 다음 그 반복자를 이용하여 요소들을 반복해서 접근합니다:"
+msgstr "자, 이제 우리는 `Iterator`와 `IntoIterator`를 알았으므로 `for` 루프를 만들 수 있습니다. `for` 루프는 `into_iter()`를 호출하여 반복자를 만든 다음 그 반복자를 이용하여 요소들을 반복해서 접근합니다:"
 
 #: src/exercises/day-1/iterators-and-ownership.md:89
 msgid ""
@@ -4848,7 +4696,7 @@ msgstr ""
 
 #: src/exercises/day-1/iterators-and-ownership.md:103
 msgid "What is the type of `word` in each loop?"
-msgstr "매 루프에서 `word`의 타입은 무엇입니까? "
+msgstr "매 루프에서 `word`의 타입은 무엇입니까?"
 
 #: src/exercises/day-1/iterators-and-ownership.md:105
 msgid ""
@@ -4873,11 +4721,11 @@ msgstr "상당한 분량의 러스트에 대해 보았고, 이어서 오늘 강
 
 #: src/welcome-day-2.md:5
 msgid "* Structs, enums, methods."
-msgstr "* 구조체, 열거형, 메서드"
+msgstr "* 구조체, 열거형, 메서드."
 
 #: src/welcome-day-2.md:7
 msgid "* Pattern matching: destructuring enums, structs, and arrays."
-msgstr "* 패턴 매칭: 열거형, 구조체 그리고 배열 분해"
+msgstr "* 패턴 매칭: 열거형, 구조체 그리고 배열 분해."
 
 #: src/welcome-day-2.md:9
 msgid ""
@@ -4889,7 +4737,7 @@ msgstr "* 흐름 제어: `if`, `if let`, `while`, `while let`, `break`, 그리
 msgid ""
 "* The Standard Library: `String`, `Option` and `Result`, `Vec`, `HashMap`, `Rc`\n"
 "  and `Arc`."
-msgstr "* 표준 라이브러리:: `String`, `Option` 과 `Result`, `Vec`, `HashMap`, `Rc`  그리고 `Arc`."
+msgstr "* 표준 라이브러리:: `String`, `Option` 과 `Result`, `Vec`, `HashMap`, `Rc` 그리고 `Arc`."
 
 #: src/welcome-day-2.md:15
 msgid "* Modules: visibility, paths, and filesystem hierarchy."
@@ -4957,7 +4805,7 @@ msgstr ""
 "  * C++ 와 달리 구조체 간 상속은 없습니다.\n"
 "* 메서드는 `impl`블록에 정의 합니다. 다음 슬라이드에서 확인 할 수 있습니다.\n"
 "* 사람들에게 다른 종류의 구조체가 있음을 알게 하기에 좋은 시간일 것입니다.\n"
-"  * 0 크기 구조체(예: `struct Foo;`)는 데이터를 가지고 있지 않지만 특정 타입의 트레이트를 구현할 때 유용합니다.\n"
+"  * 0 크기 구조체(예: `struct Foo;`)는 데이터를 가지고 있지 않지만 특정 타입의 트레잇을 구현할 때 유용합니다.\n"
 "  * 다음 슬라이드에서는 필드 이름이 덜 중요할 때 사용할 수 있는 튜플 구조체를 소개합니다.\n"
 "* `..peter` 문법은 한 구조체에서 다른 구조체로 대부분의 값을 복사하려고 하는 경우에 하나하나 타이핑하는\n"
 "  수고를 덜어줍니다. 반드시 맨 마지막에 와야 합니다."
@@ -4987,7 +4835,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 ""
@@ -5040,7 +4888,7 @@ msgstr ""
 "* `Newtons` 타입의 값에 `f64` 값을 더하는 방법을 보여주세요.\n"
 "  * 러스트는 대체로 분명하지 않은 것을 싫어합니다. 예를 들면 자동으로 unwrap하거나 불리언 값을 정수 값으로\n"
 "    사용하는 것들이 그렇습니다.\n"
-"  * 연산자 재정의는 3일차 제너릭 부분에서 다룹니다.\n"
+"  * 연산자 재정의는 3일차 제네릭 부분에서 다룹니다.\n"
 "</details>"
 
 #: src/structs/field-shorthand.md:1
@@ -5082,8 +4930,8 @@ 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"
-msgstr "`new`함수를 다음처럼 구조체 이름 대신 `Self`를 사용하여 작성해도 됩니다."
+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
 msgid ""
@@ -5093,9 +4941,14 @@ msgid ""
 "        Self { name, age }\n"
 "    }\n"
 "}\n"
-"```\n"
-"    \n"
-"</details>"
+"```"
+msgstr ""
+
+#: src/structs/field-shorthand.md:37
+msgid ""
+"* Methods are defined in the `impl` block.\n"
+"* Use struct update syntax to define a new structure using `peter`. Note that the variable `peter` will no longer be accessible afterwards.\n"
+"* Use `{:#?}` when printing structs to request the `Debug` representation."
 msgstr ""
 
 #: src/enums.md:1
@@ -5181,7 +5034,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 ""
@@ -5224,17 +5077,27 @@ 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"
-"* `match` and `if let` inspect a hidden discriminant field in the `enum`.\n"
+"* The values in the enum variants can only be accessed after being pattern matched. The pattern binds references to the fields in the \"match arm\" after the `=>`.\n"
+"  * The expressions is matched against the patterns from top to bottom. There is no fall-through like in C or C++.\n"
+"  * The match expression has a value. The value is the last expression in the match arm which was executed.\n"
+"  * Starting from the top we look for what pattern matches the value then run the code following the arrow. Once we find a match, we stop. \n"
+"* Demonstrate what happens when the search is inexhaustive. Note the advantage the Rust compiler provides by confirming when all cases are handled. \n"
+"* `match` inspects 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."
+"* `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.  \n"
+"  \n"
+"</details>"
 msgstr ""
-"* 위의 예제에서 `KeyPress`의 `char`, `Cilck`의 `x`와 `y`의 접근은 `match`나 `if let` 안에서만 동작 합니다.\n"
+"* 열거형 안의 값은 패턴 매칭이 되고 난 이후에만 접근 가능합니다. 그 값에 대한 레퍼런스는 `=>` 이후에 사용가능합니다.\n"
+"  * 매치 패턴들은 위에서 아래로 순서에 따라 검사합니다. C나 C++에서와 같은 fall-through는 없습니다.\n"
+"  * 매치 표현식 자체는 값을 가집니다. 그 값은 매칭이 된 패턴에서 가장 마지막에 수행된 표현식이 됩니다.\n"
+"  * 가장 위에서 부터 어떤 패턴이 주어진 값과 매칭하는지 검사한 다음, 매칭된 것이 발견되면 화살표를 따라 코드를 수행합니다. 한 번 매칭이 되고 코드가 수행이 되면, 더이상의 매칭은 없습니다.\n"
+"* 매칭 패턴들이 불충분 하다면 어떤 일이 일어나는지 설명하세요. 러스트 컴파일러는 모든 가능한 케이스들이 핸들링 되는지 체크한다는 점을 상기시키세요.\n"
 "* `match`는 주어진 열거형 값이 실제로 어떤 variant인지 판단하기 위해, 그 variant의 종류가 기록된, 숨겨진 필드(식별자)의 값을 검사합니다.\n"
 "* `std::mem::discriminant()`를 이용하여 식별자를 얻을 수도 있습니다.\n"
-"  * 이는 각 필드 값을 굳이 비교할 필요 없는 구조체에 대해 `PartialEq` 트레이트를 구현할 때 유용합니다.\n"
-"* `WebEvent::Click { ... }`은 최상위 레벨 구조체 `struct Click {...}`를 따로 정의하고 `WebEvent::Click(Click)`처럼 튜플 형태로 정의한 것과 정확히 같진 않습니다. 예를 들어 `WebEvent::Click { ... }` 로 정의한 경우, 구조체 형태와 유사하지만 트레이트를 구현 할 수 없습니다."
+"  * 이는 각 필드 값을 굳이 비교할 필요 없는 구조체에 대해 `PartialEq` 트레잇을 구현할 때 유용합니다.\n"
+"* `WebEvent::Click { ... }`은 최상위 레벨 구조체 `struct Click {...}`를 따로 정의하고 `WebEvent::Click(Click)`처럼 튜플 형태로 정의한 것과 정확히 같진 않습니다. 예를 들어 `WebEvent::Click { ... }` 로 정의한 경우, 구조체 형태와 유사하지만 트레잇을 구현 할 수 없습니다."
 
 #: src/enums/sizes.md:1
 msgid "# Enum Sizes"
@@ -5242,7 +5105,7 @@ msgstr "# 열거형 타입의 크기"
 
 #: src/enums/sizes.md:3
 msgid "Rust enums are packed tightly, taking constraints due to alignment into account:"
-msgstr "러스트의 열거형은 정렬(alignment)로 인한 제약을 고려하여 크기를 빽빽하게 잡습니다."
+msgstr "러스트의 열거형은 정렬(alignment)로 인한 제약을 고려하여 크기를 빽빽하게 잡습니다:"
 
 #: src/enums/sizes.md:5
 msgid ""
@@ -5321,9 +5184,7 @@ msgstr ""
 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."
-msgstr ""
-"비트 수준에서 어떤식으로 표현되는지 보여주고 싶다면 다음 예제 코드를 사용해보세요.\n"
-"컴파일러가 비트 표현까지 보장하지 않기 때문에 여기에 의존하는 것은 안전하지 않다는 점을 꼭 알려주세요."
+msgstr "비트 수준에서 어떤식으로 표현되는지 보여주고 싶다면 다음 예제 코드를 사용해보세요. 컴파일러가 비트 표현까지 보장하지 않기 때문에 여기에 의존하는 것은 안전하지 않다는 점을 꼭 알려주세요."
 
 #: src/enums/sizes.md:52
 msgid ""
@@ -5505,7 +5366,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 ""
@@ -5648,8 +5509,8 @@ msgstr ""
 "* 4가지 유형의 메서드 receiver에 대해 설명합니다.\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"
@@ -5663,7 +5524,7 @@ msgstr "`match`키워드는 값을 여러 형태의 _패턴_과 매치시킬 수
 
 #: src/pattern-matching.md:6
 msgid "The patterns can be simple values, similarly to `switch` in C and C++:"
-msgstr "C/C++의 `switch`와 비슷하게 값을 패턴으로 사용할 수도 있습니다."
+msgstr "C/C++의 `switch`와 비슷하게 값을 패턴으로 사용할 수도 있습니다:"
 
 #: src/pattern-matching.md:8
 msgid ""
@@ -5726,7 +5587,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 ""
@@ -5785,10 +5646,7 @@ msgid ""
 "Here we have used the arms to _destructure_ the `Result` value. In the first\n"
 "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"
-"첫번째 팔에서 `half`는 `Ok` variant에 담긴 값으로 바인딩됩니다.\n"
-"두번째 팔에서 `msg`는 오류 메시지 문자열에 바인딩됩니다."
+msgstr "`match`구문에서 `divide_in_two`함수에서 반환되는 `Result` 값을 두 개의 팔(혹은 가지)로 _분해(destructure)_ 하였습니다. 첫번째 팔에서 `half`는 `Ok` variant에 담긴 값으로 바인딩됩니다. 두번째 팔에서 `msg`는 오류 메시지 문자열에 바인딩됩니다."
 
 #: src/pattern-matching/destructuring-enums.md:35
 msgid ""
@@ -5864,7 +5722,7 @@ msgstr "# 배열 분해(역구조화)"
 
 #: src/pattern-matching/destructuring-arrays.md:3
 msgid "You can destructure arrays, tuples, and slices by matching on their elements:"
-msgstr "배열이나 튜플, 슬라이스도 그 요소들에 대해 패턴 매칭으로 분해할 수 있습니다."
+msgstr "배열이나 튜플, 슬라이스도 그 요소들에 대해 패턴 매칭으로 분해할 수 있습니다:"
 
 #: src/pattern-matching/destructuring-arrays.md:5
 msgid ""
@@ -5894,11 +5752,11 @@ msgstr ""
 "}\n"
 "```"
 
-#: src/pattern-matching/destructuring-arrays.md:20
+#: src/pattern-matching/destructuring-arrays.md:21
 msgid "* Destructuring of slices of unknown length also works with patterns of fixed length."
 msgstr "* 길이를 알 수 없는 슬라이스에 대해서도 고정 길이 패턴으로 분해할 수 있습니다."
 
-#: src/pattern-matching/destructuring-arrays.md:22
+#: src/pattern-matching/destructuring-arrays.md:24
 msgid ""
 "```rust,editable\n"
 "fn main() {\n"
@@ -5912,7 +5770,7 @@ msgstr ""
 "    inspect(&[0, -2, 3, 4]);\n"
 "}"
 
-#: src/pattern-matching/destructuring-arrays.md:28
+#: src/pattern-matching/destructuring-arrays.md:30
 msgid ""
 "#[rustfmt::skip]\n"
 "fn inspect(slice: &[i32]) {\n"
@@ -5924,8 +5782,11 @@ msgid ""
 "    }\n"
 "}\n"
 "```\n"
-"* Show matching against the tail with patterns `[.., b]` and `[a@..,b]`\n"
-"</details>"
+"  \n"
+"* Create a new pattern using `_` to represent an element. \n"
+"* Add more values to the array.\n"
+"* Point out that how `..` will expand to account for different number of elements.\n"
+"* Show matching against the tail with patterns `[.., b]` and `[a@..,b]`"
 msgstr ""
 "#[rustfmt::skip]\n"
 "fn inspect(slice: &[i32]) {\n"
@@ -5937,6 +5798,9 @@ msgstr ""
 "    }\n"
 "}\n"
 "```\n"
+"* 엘리먼트를 매칭할 때 `_`를 사용하는 패턴을 추가해 보세요.\n"
+"* 배열에 값을 더 추가해 보세요.\n"
+"* `..`가 서로 다른 개수의 엘리먼트들에 대해 어떻게 확장되는지 설명하세요.\n "
 "* `[.., b]`나 `[a@.., b]`와 같은 패턴으로 꼬리 부분을 매칭하는 것을 보여주세요.\n"
 "</details>"
 
@@ -5948,7 +5812,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 ""
@@ -6022,9 +5886,7 @@ msgstr "# 건강상태 모니터링 시스템"
 msgid ""
 "You're working on implementing a health-monitoring system. As part of that, you\n"
 "need to keep track of users' health statistics."
-msgstr ""
-"당신은 건강 상태를 모니터링하는 시스템을 구현하는 일을 하고 있습니다.\n"
-"그 일환으로 당신은 사용자의 건강 상태 통계를 추적해야합니다."
+msgstr "당신은 건강 상태를 모니터링하는 시스템을 구현하는 일을 하고 있습니다. 그 일환으로 당신은 사용자의 건강 상태 통계를 추적해야합니다."
 
 #: src/exercises/day-2/health-statistics.md:6
 msgid ""
@@ -6037,7 +5899,7 @@ msgstr "당신의 목표는 `User` 구조체의 `impl` 블록의 빈 함수를 
 msgid ""
 "Copy the code below to <https://play.rust-lang.org/> and fill in the missing\n"
 "methods:"
-msgstr "아래 코드를 <https://play.rust-lang.org/>에 복사해서 빠진 메서드를 구현하면 됩니다: "
+msgstr "아래 코드를 <https://play.rust-lang.org/>에 복사해서 빠진 메서드를 구현하면 됩니다:"
 
 #: src/exercises/day-2/health-statistics.md:17
 msgid ""
@@ -6130,9 +5992,7 @@ msgid ""
 "We will create a `Polygon` struct which contain some points. Copy the code below\n"
 "to <https://play.rust-lang.org/> and fill in the missing methods to make the\n"
 "tests pass:"
-msgstr ""
-"우리는 몇개의 꼭지점을 가진 다각형을 표현하는 `Polygon` 구조체를 만들 것입니다.  \n"
-"아래 코드를 <https://play.rust-lang.org/>에 복사해서 테스트가 통과하도록 빠진 메서드를 구현하시면 됩니다: "
+msgstr "우리는 몇개의 꼭지점을 가진 다각형을 표현하는 `Polygon` 구조체를 만들 것입니다. 아래 코드를 <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
@@ -6327,9 +6187,8 @@ msgid ""
 msgstr ""
 "연습문제의 다른 흥미로운 부분:\n"
 "    \n"
-"* 테스트 코드를 보면 어떤 메서드들은 인자를 borrow하는 대신 `Copy` 트레이트를 사용하기도 합니다.\n"
-"  구조체가 `Copy` 트레이트를 상속(derive)하도록 하면 됩니다.\n"
-"* \"+\"를 사용하여 두 객체를 서로 더하려면 `Add` 트레이트를 구현해야 합니다. 이는 3일차에 다룰 내용입니다."
+"* 테스트 코드를 보면 어떤 메서드들은 인자를 borrow하는 대신 `Copy` 트레잇을 사용하기도 합니다. 구조체가 `Copy` 트레잇을 상속(derive)하도록 하면 됩니다.\n"
+"* \"+\"를 사용하여 두 객체를 서로 더하려면 `Add` 트레잇을 구현해야 합니다. 이는 3일차에 다룰 내용입니다."
 
 #: src/control-flow.md:1
 msgid "# Control Flow"
@@ -6341,7 +6200,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"
@@ -6351,7 +6210,7 @@ msgstr "# 블록"
 msgid ""
 "A block in Rust has a value and a type: the value is the last expression of the\n"
 "block:"
-msgstr "러스트에서 블록은 값과 타입을 갖습니다. 블록의 마지막 표현식이 블록의 값이 됩니다."
+msgstr "러스트에서 블록은 값과 타입을 갖습니다. 블록의 마지막 표현식이 블록의 값이 됩니다:"
 
 #: src/control-flow/blocks.md:6
 msgid ""
@@ -6379,7 +6238,7 @@ msgstr ""
 msgid ""
 "The same rule is used for functions: the value of the function body is the\n"
 "return value:"
-msgstr "함수에도 동일한 규칙이 적용됩니다. 함수 바디를 이루는 블록의 값이 반환값이 됩니다."
+msgstr "함수에도 동일한 규칙이 적용됩니다. 함수 바디를 이루는 블록의 값이 반환값이 됩니다:"
 
 #: src/control-flow/blocks.md:28
 msgid ""
@@ -6421,7 +6280,7 @@ msgstr "# `if` 표현식"
 
 #: src/control-flow/if-expressions.md:3
 msgid "You use `if` very similarly to how you would in other languages:"
-msgstr "`if`는 다른 언어와 매우 유사합니다."
+msgstr "`if`는 다른 언어와 매우 유사합니다:"
 
 #: src/control-flow/if-expressions.md:5
 msgid ""
@@ -6439,9 +6298,7 @@ msgstr ""
 
 #: src/control-flow/if-expressions.md:16
 msgid "In addition, you can use it as an expression. This does the same as above:"
-msgstr ""
-"게다가 `if`는 표현식으로 사용할 수도 있습니다.\n"
-"아래 코드는 위와 동일합니다."
+msgstr "게다가 `if`는 표현식으로 사용할 수도 있습니다. 아래 코드는 위와 동일합니다:"
 
 #: src/control-flow/if-expressions.md:18
 msgid ""
@@ -6463,7 +6320,7 @@ msgid ""
 "    \n"
 "</details>"
 msgstr ""
-"`if`는 표현식이고 타입을 가져야 하므로 분기 블록은 모두 같은 타입을 가져야 합니다. 두번째 예시의 `x / 2` 뒤에 `;`를 추가하여 어떻게 되는지 확인해 보시기 바랍니다.    \n"
+"`if`는 표현식이고 타입을 가져야 하므로 분기 블록은 모두 같은 타입을 가져야 합니다. 두번째 예시의 `x / 2` 뒤에 `;`를 추가하여 어떻게 되는지 확인해 보시기 바랍니다.\n"
 "</details>"
 
 #: src/control-flow/if-let-expressions.md:1
@@ -6472,7 +6329,7 @@ msgstr "# `if let` 표현식"
 
 #: src/control-flow/if-let-expressions.md:3
 msgid "If you want to match a value against a pattern, you can use `if let`:"
-msgstr "어떤 값이 패턴에 매치되는지 검사하려면 `if let` 표현식을 사용하면 됩니다."
+msgstr "어떤 값이 패턴에 매치되는지 검사하려면 `if let` 표현식을 사용하면 됩니다:"
 
 #: src/control-flow/if-let-expressions.md:5
 msgid ""
@@ -6514,7 +6371,7 @@ msgstr "# `while` 표현식"
 
 #: src/control-flow/while-expressions.md:3
 msgid "The `while` keyword works very similar to other languages:"
-msgstr "`while` 역시 다른 언어과 매우 비슷합니다."
+msgstr "`while` 역시 다른 언어과 매우 비슷합니다:"
 
 #: src/control-flow/while-expressions.md:5
 msgid ""
@@ -6541,7 +6398,7 @@ msgstr "# `while let` 표현식"
 msgid ""
 "Like with `if`, there is a `while let` variant which repeatedly tests a value\n"
 "against a pattern:"
-msgstr "`if`와 동일하게 `while let`구문 역시 패턴매칭에 사용 할 수 있습니다."
+msgstr "`if`와 동일하게 `while let`구문 역시 패턴매칭에 사용 할 수 있습니다:"
 
 #: src/control-flow/while-let-expressions.md:6
 msgid ""
@@ -6565,9 +6422,7 @@ msgid ""
 "Here the iterator returned by `v.iter()` will return a `Option<i32>` on every\n"
 "call to `next()`. It returns `Some(x)` until it is done, after which it will\n"
 "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`을 통해 반복자의 모든 아이템을 확인할 수 있습니다."
+msgstr "`v.into_iter()`가 반환한 반복자는 `next()`가 호출될 때마다 `Option<i32>`를 반환합니다. 반복자가 완료될 때까지는 `Some(x)`를 반환하고 마지막엔 `None`을 반환합니다. `while let`을 통해 반복자의 모든 아이템을 확인할 수 있습니다."
 
 #: src/control-flow/while-let-expressions.md:27
 msgid ""
@@ -6585,7 +6440,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 ""
@@ -6623,7 +6478,7 @@ msgstr ""
 "<details>\n"
 "    \n"
 "* 러스트는 인덱스 반복을 위해 별도의 문법을 사용하지 않습니다. \n"
-"* `(0..10)`은 `Iterator` 트레이트를 구현하는 범위(range) 값입니다. \n"
+"* `(0..10)`은 `Iterator` 트레잇을 구현하는 범위(range) 값입니다. \n"
 "* `step_by`는 반복자의 요소들을 건너뛰는 또다른 `Iterator`를 반환하는 메서드입니다.\n"
 "* 벡터 요소들을 수정하려고 하면 나오는 컴파일러 에러를 같이 살펴보세요. `v` 벡터를 가변 변수로 변경하고 루프는 `for x in v.iter_mut()`로 수정하세요."
 
@@ -6635,7 +6490,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 ""
@@ -6672,7 +6527,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 ""
@@ -6715,7 +6570,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 ""
@@ -6775,7 +6630,7 @@ msgstr "* [`Vec`](std/vec.md): 가변 크기의 표준 벡터 타입입니다."
 msgid ""
 "* [`HashMap`](std/hashmap.md): a hash map type with a configurable hashing\n"
 "  algorithm."
-msgstr "* [`HashMap`](std/hashmap.md): 해시 알고리즘을 따로 지정할 수도 있는 해시맵 타입입니다"
+msgstr "* [`HashMap`](std/hashmap.md): 해시 알고리즘을 따로 지정할 수도 있는 해시맵 타입입니다."
 
 #: src/std.md:19
 msgid "* [`Box`](std/box.md): an owned pointer for heap-allocated data."
@@ -6797,8 +6652,8 @@ msgid ""
 msgstr ""
 "<details>\n"
 "  \n"
-"  * 사실, 러스트의 표준 라이브러리는 `core`, `alloc`, `std`와 같이 계층(layer)으로 나눠집니다. \n"
-"  * `core`는 `libc`나 할당자(allocator), 심지어 OS에도 의존하지 않는 가장  기본적인 함수와 타입을 포함합니다.\n"
+"  * 사실, 러스트의 표준 라이브러리는 `core`, `alloc`, `std`와 같이 계층(layer)으로 나눠집니다.\n"
+"  * `core`는 `libc`나 할당자(allocator), 심지어 OS에도 의존하지 않는 가장 기본적인 함수와 타입을 포함합니다.\n"
 "  * `alloc`은 `Vec`, `Box`, `Arc`와 같이 전역 힙 할당이 필요한 타입을 포함합니다.\n"
 "  * 임베디드 러스트 응용프로그램은 주로 `core`만 사용하거나 가끔 `alloc`을 함께 사용합니다."
 
@@ -6808,7 +6663,7 @@ msgstr "# `Option`과 `Result`"
 
 #: src/std/option-result.md:3
 msgid "The types represent optional data:"
-msgstr "이 타입은 선택적 데이터를 나타냅니다."
+msgstr "이 타입은 선택적 데이터를 나타냅니다:"
 
 #: src/std/option-result.md:5
 msgid ""
@@ -6849,7 +6704,7 @@ msgstr "# `String` 문자열"
 
 #: src/std/string.md:3
 msgid "[`String`][1] is the standard heap-allocated growable UTF-8 string buffer:"
-msgstr "[`String`][1]은 힙에 할당되고 가변 길이의 표준 UTF-8 문자열 버퍼입니다."
+msgstr "[`String`][1]은 힙에 할당되고 가변 길이의 표준 UTF-8 문자열 버퍼입니다:"
 
 #: src/std/string.md:5
 msgid ""
@@ -6881,9 +6736,7 @@ msgstr ""
 msgid ""
 "`String` implements [`Deref<Target = str>`][2], which means that you can call all\n"
 "`str` methods on a `String`."
-msgstr ""
-"`String`은 [`Deref<Target = str>`][2]을 구현합니다.\n"
-"이는 , `String` 값에 대해서도 `str`의 모든 메서드를 호출 할 수 있다는 의미 입니다."
+msgstr "`String`은 [`Deref<Target = str>`][2]을 구현합니다. 이는 , `String` 값에 대해서도 `str`의 모든 메서드를 호출 할 수 있다는 의미 입니다."
 
 #: src/std/string.md:25
 msgid ""
@@ -6893,11 +6746,16 @@ msgstr ""
 
 #: src/std/string.md:30
 msgid ""
-"* `len()` returns the size of the `String` in bytes, not its length in characters.\n"
-"* `chars()` returns an iterator over the actual characters."
+"* `String::new` returns a new empty string, use `String::with capacity` when you know how much data you want to push to the string.\n"
+"* `String::len` returns the size of the `String` in bytes (which can be different from its length in characters).\n"
+"* `String::chars` returns an iterator over the actual characters. Note that a `char` can be different from what a human will consider a \"character\" due to [grapheme clusters](https://docs.rs/unicode-segmentation/latest/unicode_segmentation/struct.Graphemes.html).\n"
+"*  When people refer to strings they could either be talking about `&str` or `String`.  \n"
+"* When a type implements `Deref<Target = T>`, the compiler will let you transparently call methods from `T`.\n"
+"    * `String` implements `Deref<Target = str>` which transparently gives it access to `str`'s methods.\n"
+"    * Write and compare `let s3 = s1.deref();` and  `let s3 = &*s1`;.\n"
+"* `String` is implemented as a wrapper around a vector of bytes, many of the operations you see supported on vectors are also supported on `String`, but with some extra guarantees.\n"
+"* Compare the different ways to inde a Strings by using `s3[i]` and `s3.chars.nth(i).unwrap()` where `i` is in-bound, out-of-bounds, and \"on\" the flag unicode character."
 msgstr ""
-"* `len()`은 `String`의 글자 길이가 아닌 바이트 사이즈를 반환합니다.\n"
-"* `chars()`은 실제 문자들에 대한 반복자를 반환합니다."
 
 #: src/std/vec.md:1
 msgid "# `Vec`"
@@ -6905,7 +6763,7 @@ msgstr "# `Vec`"
 
 #: src/std/vec.md:3
 msgid "[`Vec`][1] is the standard resizable heap-allocated buffer:"
-msgstr "[`Vec`][1] 는 힙에 할당된 표준 가변 크기 버퍼입니다."
+msgstr "[`Vec`][1] 는 힙에 할당된 표준 가변 크기 버퍼입니다:"
 
 #: src/std/vec.md:5
 msgid ""
@@ -6950,9 +6808,7 @@ msgstr ""
 msgid ""
 "`Vec` implements [`Deref<Target = [T]>`][2], which means that you can call slice\n"
 "methods on a `Vec`."
-msgstr ""
-"`Vec`은 [`Deref<Target = [T]>`][2]를 구현합니다. \n"
-"이는 `Vec`에서 슬라이스 메서드를 호출 할 수 있다는 의미입니다."
+msgstr "`Vec`은 [`Deref<Target = [T]>`][2]를 구현합니다. 이는 `Vec`에서 슬라이스 메서드를 호출 할 수 있다는 의미입니다."
 
 #: src/std/vec.md:32
 msgid ""
@@ -6981,7 +6837,7 @@ msgstr "# `HashMap`"
 
 #: src/std/hashmap.md:3
 msgid "Standard hash map with protection against HashDoS attacks:"
-msgstr "HashDoS 공격으로부터 보호되는 표준 해시 맵입니다."
+msgstr "HashDoS 공격으로부터 보호되는 표준 해시 맵입니다:"
 
 #: src/std/hashmap.md:5
 msgid ""
@@ -7112,9 +6968,7 @@ msgstr ""
 msgid ""
 "`Box<T>` implements `Deref<Target = T>`, which means that you can [call methods\n"
 "from `T` directly on a `Box<T>`][2]."
-msgstr ""
-"`Box<T>`은 [`Deref<Target = T>`][2]를 구현합니다. \n"
-"이는 [`Box<T>`에서 `T` 메서드를 직접 호출][2] 할 수 있다는 의미입니다."
+msgstr "`Box<T>`은 [`Deref<Target = T>`][2]를 구현합니다. 이는 [`Box<T>`에서 `T` 메서드를 직접 호출][2] 할 수 있다는 의미입니다."
 
 #: src/std/box.md:29
 msgid ""
@@ -7124,7 +6978,7 @@ msgstr ""
 
 #: src/std/box.md:34
 msgid ""
-"* `Box` is like `std::unique_ptr` in C++. \n"
+"* `Box` is like `std::unique_ptr` in C++, except that it's guaranteed to be not null. \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"
@@ -7138,7 +6992,7 @@ msgstr "# 재귀자료 구조에서의 `Box`"
 
 #: src/std/box-recursive.md:3
 msgid "Recursive data types or data types with dynamic sizes need to use a `Box`:"
-msgstr "재귀 데이터나 동적크기의 데이터 타입은 `Box`타입을 사용해야 합니다."
+msgstr "재귀 데이터나 동적크기의 데이터 타입은 `Box`타입을 사용해야 합니다:"
 
 #: src/std/box-recursive.md:5 src/std/box-niche.md:3
 msgid ""
@@ -7205,7 +7059,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 ""
@@ -7231,9 +7085,7 @@ msgstr "# `Rc`"
 msgid ""
 "[`Rc`][1] is a reference-counted shared pointer. Use this when you need to refer\n"
 "to the same data from multiple places:"
-msgstr ""
-"[`Rc`][1]는 참조 카운팅 공유 포인터입니다. \n"
-"여러 위치에서 동일한 데이터를 참조해야할 경우 사용합니다:"
+msgstr "[`Rc`][1]는 참조 카운팅 공유 포인터입니다. 여러 위치에서 동일한 데이터를 참조해야할 경우 사용합니다:"
 
 #: src/std/rc.md:6
 msgid ""
@@ -7339,7 +7191,7 @@ msgstr "`impl`블록은 해당 타입의 함수들에 대한 네임스페이스
 
 #: src/modules.md:5
 msgid "Similarly, `mod` lets us namespace types and functions:"
-msgstr "마찬가지로, `mod`는 타입과 함수들에 대해 네임스페이스를 제공합니다: "
+msgstr "마찬가지로, `mod`는 타입과 함수들에 대해 네임스페이스를 제공합니다:"
 
 #: src/modules.md:7
 msgid ""
@@ -7382,7 +7234,7 @@ msgstr "# 가시성"
 
 #: src/modules/visibility.md:3
 msgid "Modules are a privacy boundary:"
-msgstr "모듈의 타입이나 함수는 기본적으로 비깥에 노출되지 않습니다."
+msgstr "모듈의 타입이나 함수는 기본적으로 비깥에 노출되지 않습니다:"
 
 #: src/modules/visibility.md:5
 msgid ""
@@ -7487,7 +7339,7 @@ msgstr "# 파일시스템 계층"
 
 #: src/modules/filesystem.md:3
 msgid "The module content can be omitted:"
-msgstr "모듈의 내용은 생략될 수 있습니다."
+msgstr "모듈의 내용은 생략될 수 있습니다:"
 
 #: src/modules/filesystem.md:5
 msgid ""
@@ -7498,7 +7350,7 @@ msgstr ""
 
 #: src/modules/filesystem.md:9
 msgid "The `garden` module content is found at:"
-msgstr "`garden` 모듈의 내용은 아래 위치에서 확인 할 수 있습니다."
+msgstr "`garden` 모듈의 내용은 아래 위치에서 확인 할 수 있습니다:"
 
 #: src/modules/filesystem.md:11
 msgid ""
@@ -7508,7 +7360,7 @@ msgstr ""
 
 #: src/modules/filesystem.md:14
 msgid "Similarly, a `garden::vegetables` module can be found at:"
-msgstr "유사하게 `garden::vegetables` 모듈은 아래 위치에서 확인할 수 있습니다."
+msgstr "유사하게 `garden::vegetables` 모듈은 아래 위치에서 확인할 수 있습니다:"
 
 #: src/modules/filesystem.md:16
 msgid ""
@@ -7590,9 +7442,7 @@ msgid ""
 "The [Luhn algorithm](https://en.wikipedia.org/wiki/Luhn_algorithm) is used to\n"
 "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"
-"이 알고리즘은 신용카드 번호를 `문자열`로 입력받고, 아래의 순서에 따라 신용카드 번호의 유효성을 확인합니다:"
+msgstr "[룬(Luhn) 알고리즘](https://ko.wikipedia.org/wiki/%EB%A3%AC_%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98)은 신용카드 번호 검증에 사용되는 알고리즘 입니다. 이 알고리즘은 신용카드 번호를 `문자열`로 입력받고, 아래의 순서에 따라 신용카드 번호의 유효성을 확인합니다:"
 
 #: src/exercises/day-2/luhn.md:7
 msgid "* Ignore all spaces. Reject number with less than two digits."
@@ -7622,7 +7472,7 @@ msgstr "* 합계의 끝자리가 `0`인 경우 유효한 신용카드 번호 입
 msgid ""
 "Copy the following code to <https://play.rust-lang.org/> and implement the\n"
 "function:"
-msgstr "아래 코드를 <https://play.rust-lang.org/>에 복사하고 함수를 구현해 보시기 바랍니다."
+msgstr "아래 코드를 <https://play.rust-lang.org/>에 복사하고 함수를 구현해 보시기 바랍니다:"
 
 #: src/exercises/day-2/luhn.md:27
 msgid ""
@@ -7696,15 +7546,13 @@ msgid ""
 "server is configured with a number of _path prefixes_ which are matched against\n"
 "_request paths_. The path prefixes can contain a wildcard character which\n"
 "matches a full segment. See the unit tests below."
-msgstr ""
-"이번 훈련은 웹 서버의 라우팅 컴포넌트를 구현합니다. \n"
-"서버는 _요청 경로(request path)_ 를 처리할 수 있는 여러 개의 _경로 접두사(path prefix)_ 로 구성됩니다. 경로 접두사는 와일드카드문자를 포함할 수 있습니다.  아래 단위 테스트 코드를 참조하세요."
+msgstr "이번 훈련은 웹 서버의 라우팅 컴포넌트를 구현합니다. 서버는 _요청 경로(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 ""
@@ -7773,35 +7621,35 @@ msgstr "오늘은 몇 가지 고급 주제를 다룹니다:"
 msgid ""
 "* Traits: deriving traits, default methods, and important standard library\n"
 "  traits."
-msgstr "* 트레이트: 트레이트 상속(derive), 디폴트 메서드, 표준 라이브러에 있는 중요한 트레이트 들"
+msgstr "* 트레잇: 트레잇 상속(derive), 디폴트 메서드, 표준 라이브러에 있는 중요한 트레잇들."
 
 #: src/welcome-day-3.md:8
 msgid ""
 "* Generics: generic data types, generic methods, monomorphization, and trait\n"
 "  objects."
-msgstr "* 제너릭: 제너릭 데이터 타입, 제너릭 메서드, 단형화(monomorphization), 트레이트 객체"
+msgstr "* 제네릭: 제네릭 데이터 타입, 제네릭 메서드, 단형화(monomorphization), 트레잇 객체."
 
 #: src/welcome-day-3.md:11
 msgid "* Error handling: panics, `Result`, and the try operator `?`."
-msgstr "* 오류처리(에러 핸들링): 패닉, `Result`, `?` 연산자"
+msgstr "* 오류처리(에러 핸들링): 패닉, `Result`, `?` 연산자."
 
 #: src/welcome-day-3.md:13
 msgid "* Testing: unit tests, documentation tests, and integration tests."
-msgstr "* 테스트: 단위 테스트, 문서 테스트 및 통합 테스트"
+msgstr "* 테스트: 단위 테스트, 문서 테스트 및 통합 테스트."
 
 #: src/welcome-day-3.md:15
 msgid ""
 "* Unsafe Rust: raw pointers, static variables, unsafe functions, and extern\n"
 "  functions."
-msgstr "* 안전하지 않은 러스트: 원시(raw) 포인터, 정적 변수, 안전하지 않은 함수, 외부 함수"
+msgstr "* 안전하지 않은 러스트: 원시(raw) 포인터, 정적 변수, 안전하지 않은 함수, 외부 함수."
 
 #: src/traits.md:1
 msgid "# Traits"
-msgstr "# 트레이트(Trait)"
+msgstr "# 트레잇(Trait)"
 
 #: src/traits.md:3
 msgid "Rust lets you abstract over types with traits. They're similar to interfaces:"
-msgstr "트레이트는 타입을 추상화 하는데 사용됩니다. 인터페이스와 비슷합니다:"
+msgstr "트레잇은 타입을 추상화 하는데 사용됩니다. 인터페이스와 비슷합니다:"
 
 #: src/traits.md:5
 msgid ""
@@ -7861,8 +7709,8 @@ msgid ""
 "* `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
@@ -7885,11 +7733,11 @@ msgstr ""
 
 #: src/traits/deriving-traits.md:1
 msgid "# Deriving Traits"
-msgstr "# 트레이트 상속하기(Deriving Traits)"
+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 ""
@@ -7919,7 +7767,7 @@ msgstr "# 디폴트 메서드"
 
 #: src/traits/default-methods.md:3
 msgid "Traits can implement behavior in terms of other trait methods:"
-msgstr "트레이트의 디폴트 메서드에서 다른(구현되지 않은) 메소드를 이용할 수 있습니다:"
+msgstr "트레잇의 디폴트 메서드에서 다른(구현되지 않은) 메소드를 이용할 수 있습니다:"
 
 #: src/traits/default-methods.md:5
 msgid ""
@@ -7960,11 +7808,11 @@ msgstr ""
 
 #: src/traits/important-traits.md:1
 msgid "# Important Traits"
-msgstr "# 중요한 트레이트들"
+msgstr "# 중요한 트레잇들"
 
 #: src/traits/important-traits.md:3
 msgid "We will now look at some of the most common traits of the Rust standard library:"
-msgstr "러스트 표준 라이브러리에는 다음과 같은 범용 트레이트들이 정의되어 있습니다:"
+msgstr "러스트 표준 라이브러리에는 다음과 같은 범용 트레잇들이 정의되어 있습니다:"
 
 #: src/traits/important-traits.md:5
 msgid ""
@@ -7975,12 +7823,12 @@ msgid ""
 "* [`Drop`][9] used for defining destructors.\n"
 "* [`Default`][10] used to construct a default instance of a type."
 msgstr ""
-"* [`Iterator`][1]와 [`IntoIterator`][2] 트레이트는 `for` 루프에서 사용됩니다.\n"
-"* [`From`][3]과 [`Into`][4] 트레이트는 값을 변환할 때 사용됩니다.\n"
-"* [`Read`][5]와 [`Write`][6] 트레이트는 I/O에 사용됩니다.\n"
-"* [`Add`][7], [`Mul`][8] 등의 트레이트들은 연산자 오버로딩(overloading)에 사용됩니다.\n"
-"* [`Drop`][9] 트레이트는 소멸자 정의에 사용됩니다.\n"
-"* [`Default`][10] 트레이트는 어떤 타입의 기본값 인스턴스를 만들때 사용됩니다."
+"* [`Iterator`][1]와 [`IntoIterator`][2] 트레잇은 `for` 루프에서 사용됩니다.\n"
+"* [`From`][3]과 [`Into`][4] 트레잇은 값을 변환할 때 사용됩니다.\n"
+"* [`Read`][5]와 [`Write`][6] 트레잇은 I/O에 사용됩니다.\n"
+"* [`Add`][7], [`Mul`][8] 등의 트레잇들은 연산자 오버로딩(overloading)에 사용됩니다.\n"
+"* [`Drop`][9] 트레잇은 소멸자 정의에 사용됩니다.\n"
+"* [`Default`][10] 트레잇은 어떤 타입의 기본값 인스턴스를 만들때 사용됩니다."
 
 #: src/traits/important-traits.md:12
 msgid ""
@@ -8002,7 +7850,7 @@ msgstr "# Iterators"
 
 #: src/traits/iterator.md:3
 msgid "You can implement the [`Iterator`][1] trait on your own types:"
-msgstr "`Iterator`트레이트를 여러분이 정의한 타입에서 구현해 보겠습니다: "
+msgstr "`Iterator`트레잇을 여러분이 정의한 타입에서 구현해 보겠습니다:"
 
 #: src/traits/iterator.md:5
 msgid ""
@@ -8052,11 +7900,8 @@ msgid ""
 "    \n"
 "</details>"
 msgstr ""
-"* `IntoIterator`는 루프가 작동하도록 만드는 트레이트입니다.\n"
-"  `Vec<T>`와 같은 컬렉션 타입과 그에 대한 참조 타입(`&Vec<T>`, `&[T]`)들 모두 이 트레이트를 구현합니다. Range 역시 이를 구현합니다.\n"
-"* `Iterator` 트레이트는 컬렉션에 대해 다양한 함수형 프로그래밍 연산 (`map`, `filter`, `reduce` 등)을 구현합니다. \n"
-"이 연산들에 대한 자세한 설명은 `Iterator` 트레이트의 API 레퍼런스에서 찾을 수 있습니다.\n"
-"러스트에서 이러한 함수형 연산들은 절차형으로 구현된 코드와 동일한 성능을 보여줍니다.\n"
+"* `IntoIterator`는 루프가 작동하도록 만드는 트레잇입니다. `Vec<T>`와 같은 컬렉션 타입과 그에 대한 참조 타입(`&Vec<T>`, `&[T]`)들 모두 이 트레잇을 구현합니다. Range 역시 이를 구현합니다.\n"
+"* `Iterator` 트레잇은 컬렉션에 대해 다양한 함수형 프로그래밍 연산 (`map`, `filter`, `reduce` 등)을 구현합니다. 이 연산들에 대한 자세한 설명은 `Iterator` 트레잇의 API 레퍼런스에서 찾을 수 있습니다. 러스트에서 이러한 함수형 연산들은 절차형으로 구현된 코드와 동일한 성능을 보여줍니다.\n"
 "    \n"
 "</details>"
 
@@ -8121,7 +7966,7 @@ msgstr "# `From`과 `Into`"
 
 #: src/traits/from-into.md:3
 msgid "Types implement [`From`][1] and [`Into`][2] to facilitate type conversions:"
-msgstr "타입은 용이한 형변환을 위해 [`From`][1]과 [`Into`][2]를 구현합니다."
+msgstr "타입은 용이한 형변환을 위해 [`From`][1]과 [`Into`][2]를 구현합니다:"
 
 #: src/traits/from-into.md:5
 msgid ""
@@ -8138,7 +7983,7 @@ msgstr ""
 
 #: src/traits/from-into.md:15
 msgid "[`Into`][2] is automatically implemented when [`From`][1] is implemented:"
-msgstr "[`From`][1]이 구현되면 [`Into`][2] 역시 자동으로 구현됩니다."
+msgstr "[`From`][1]이 구현되면 [`Into`][2] 역시 자동으로 구현됩니다:"
 
 #: src/traits/from-into.md:17
 msgid ""
@@ -8262,7 +8107,7 @@ msgstr "# `Add`, `Mul`, ..."
 
 #: src/traits/operators.md:3
 msgid "Operator overloading is implemented via traits in [`std::ops`][1]:"
-msgstr "연산자 오버로드는 `std::ops`에 있는 다양한 트레이트들을 통해 구현됩니다:"
+msgstr "연산자 오버로드는 `std::ops`에 있는 다양한 트레잇들을 통해 구현됩니다:"
 
 #: src/traits/operators.md:5
 msgid ""
@@ -8312,9 +8157,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"
@@ -8322,11 +8167,11 @@ msgstr ""
 
 #: src/traits/drop.md:1
 msgid "# The `Drop` Trait"
-msgstr "# `Drop` 트레이트"
+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 ""
@@ -8382,11 +8227,11 @@ msgstr ""
 
 #: src/traits/default.md:1
 msgid "# The `Default` Trait"
-msgstr "# `Default` 트레이트"
+msgstr "# `Default` 트레잇"
 
 #: src/traits/default.md:3
 msgid "[`Default`][1] trait provides a default implementation of a trait."
-msgstr "[`Default`][1] 트레이트는 기본 구현을 제공합니다."
+msgstr "[`Default`][1] 트레잇은 기본 구현을 제공합니다."
 
 #: src/traits/default.md:5
 msgid ""
@@ -8471,7 +8316,7 @@ msgid ""
 "  * 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."
 msgstr ""
-"  * 트레이트를 직접 구현하거나 `#[derive(Default)]`를 붙여서 컴파일러에게 구현을 맡길 수 있습니다.\n"
+"  * 트레잇을 직접 구현하거나 `#[derive(Default)]`를 붙여서 컴파일러에게 구현을 맡길 수 있습니다.\n"
 "  * 컴파일러가 제공하는 자동 구현의 경우 모든 필드에 대해 기본 값을 설정한 새 인스턴스를 반환합니다.\n"
 "    * 구조체의 각 필드 타입들이 모두 `Default`를 구현해야 함을 의미합니다.\n"
 "  * 러스트 표준 타입들은 대부분 `Default`를 구현하고 있으며, 기본 값은 `0`이나 `\"\"`처럼 예상 가능한 값들입니다.\n"
@@ -8484,21 +8329,21 @@ msgstr "[1]: https://doc.rust-lang.org/std/default/trait.Default.html"
 
 #: src/generics.md:1
 msgid "# Generics"
-msgstr "# 제너릭"
+msgstr "# 제네릭"
 
 #: src/generics.md:3
 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"
-msgstr "# 제너릭 데이터 타입"
+msgstr "# 제네릭 데이터 타입"
 
 #: src/generics/data-types.md:3
 msgid "You can use generics to abstract over the concrete field type:"
-msgstr "제너릭을 사용하여 필드의 타입을 추상화 할 수 있습니다:"
+msgstr "제네릭을 사용하여 필드의 타입을 추상화 할 수 있습니다:"
 
 #: src/generics/data-types.md:5
 msgid ""
@@ -8522,11 +8367,11 @@ msgstr ""
 
 #: src/generics/methods.md:1
 msgid "# Generic Methods"
-msgstr "# 제너릭 메서드"
+msgstr "# 제네릭 메서드"
 
 #: src/generics/methods.md:3
 msgid "You can declare a generic type on your `impl` block:"
-msgstr "`impl` 블록에서도 제너릭 타입을 선언할 수 있습니다:"
+msgstr "`impl` 블록에서도 제네릭 타입을 선언할 수 있습니다:"
 
 #: src/generics/methods.md:5
 msgid ""
@@ -8567,24 +8412,24 @@ msgid ""
 "      * `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"
+"  * 제네릭 타입에 대한 제네릭 구현 이기 때문입니다. 이 두 제네릭은 서로 독립적입니다.\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"
-msgstr "# 제너릭 타입 제한(트레이트 경계, Trait Bounds)"
+msgstr "# 제네릭 타입 제한(트레잇 경계, Trait Bounds)"
 
 #: src/generics/trait-bounds.md:3
 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`:"
-msgstr "`T: Trait` 혹은 `impl Trait`를 사용하면 됩니다."
+msgstr "`T: Trait` 혹은 `impl Trait`를 사용하면 됩니다:"
 
 #: src/generics/trait-bounds.md:8
 msgid ""
@@ -8639,7 +8484,6 @@ msgid ""
 "```"
 msgstr ""
 "`where` 문법을 사용할 수도 있습니다. 수강생들도 코드를 읽다가 그 문법을 마주할 수 있습니다.\n"
-"    \n"
 "```rust,ignore\n"
 "fn duplicate<T>(a: T) -> (T, T)\n"
 "where\n"
@@ -8665,13 +8509,13 @@ msgstr ""
 
 #: src/generics/impl-trait.md:1
 msgid "# `impl Trait`"
-msgstr "# 트레이트 구현하기(`impl Trait`)"
+msgstr "# 트레잇 구현하기(`impl Trait`)"
 
 #: src/generics/impl-trait.md:3
 msgid ""
 "Similar to trait bounds, an `impl Trait` syntax can be used in function\n"
 "arguments and return values:"
-msgstr "트레이트 바운드와 유사하게 `impl Trait` 문법은 함수의 인자와 반환값에도 적용 가능합니다:"
+msgstr "트레잇 바운드와 유사하게 `impl Trait` 문법은 함수의 인자와 반환값에도 적용 가능합니다:"
 
 #: src/generics/impl-trait.md:6 src/generics/trait-objects.md:5
 #: src/generics/trait-objects.md:28
@@ -8715,8 +8559,8 @@ msgid ""
 "  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 ""
@@ -8729,7 +8573,7 @@ msgid ""
 "    \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>"
 
@@ -8743,7 +8587,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 ""
@@ -8800,7 +8644,7 @@ msgstr "# 단형화(Monomorphization)"
 
 #: src/generics/monomorphization.md:3
 msgid "Generic code is turned into non-generic code based on the call sites:"
-msgstr "제너릭 코드는 호출부에서 비 제너릭 코드로 전환됩니다:"
+msgstr "제네릭 코드는 호출부에서 비 제네릭 코드로 전환됩니다:"
 
 #: src/generics/monomorphization.md:5
 msgid ""
@@ -8814,7 +8658,7 @@ msgstr ""
 
 #: src/generics/monomorphization.md:12
 msgid "behaves as if you wrote"
-msgstr "위 코드는 아래와 같이 동작합니다."
+msgstr "위 코드는 아래와 같이 동작합니다"
 
 #: src/generics/monomorphization.md:14
 msgid ""
@@ -8846,15 +8690,15 @@ 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"
-msgstr "# 트레이트 객체"
+msgstr "# 트레잇 객체"
 
 #: src/generics/trait-objects.md:3
 msgid "We've seen how a function can take arguments which implement a trait:"
-msgstr "함수가 특정 트레이트를 구현하는 인자를 입력으로 받도록 하는 방법에 대해 설명했었습니다:"
+msgstr "함수가 특정 트레잇을 구현하는 인자를 입력으로 받도록 하는 방법에 대해 설명했었습니다:"
 
 #: src/generics/trait-objects.md:8
 msgid ""
@@ -8887,7 +8731,7 @@ msgstr ""
 
 #: src/generics/trait-objects.md:26
 msgid "For this, we need _trait objects_:"
-msgstr "이를 위해서는 _트레이트 객체_가 필요합니다:"
+msgstr "이를 위해서는 _트레잇 객체_가 필요합니다:"
 
 #: src/generics/trait-objects.md:31
 msgid ""
@@ -8939,7 +8783,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 ""
@@ -8967,7 +8811,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"
@@ -8977,7 +8821,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:"
@@ -8996,13 +8840,13 @@ msgstr ""
 
 #: src/exercises/day-3/simple-gui.md:13
 msgid "The widgets will implement a `Widget` trait, see below."
-msgstr "위젯들은 모두 `Widget` 트레이트를 구현합니다. 아래 코드를 참조하세요"
+msgstr "위젯들은 모두 `Widget` 트레잇을 구현합니다. 아래 코드를 참조하세요."
 
 #: src/exercises/day-3/simple-gui.md:15
 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
@@ -9185,9 +9029,7 @@ msgid ""
 "[fill/alignment](https://doc.rust-lang.org/std/fmt/index.html#fillalignment)\n"
 "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"
-"특수 문자(여기서는 '/')로 패딩을 주는 방법과 정렬을 제어하는 방법을 확인하시기 바랍니다."
+msgstr "텍스트를 줄맞춤 해서 그리려면 [fill/alignment](https://doc.rust-lang.org/std/fmt/index.html#fillalignment)를 참조하시기 바랍니다. 특수 문자(여기서는 '/')로 패딩을 주는 방법과 정렬을 제어하는 방법을 확인하시기 바랍니다:"
 
 #: src/exercises/day-3/simple-gui.md:140
 msgid ""
@@ -9203,7 +9045,7 @@ msgstr ""
 
 #: src/exercises/day-3/simple-gui.md:149
 msgid "Using such alignment tricks, you can for example produce output like this:"
-msgstr "위의 정렬 트릭을 사용하여 다음과 같은 출력을 생성할 수 있습니다."
+msgstr "위의 정렬 트릭을 사용하여 다음과 같은 출력을 생성할 수 있습니다:"
 
 #: src/exercises/day-3/simple-gui.md:151
 msgid ""
@@ -9232,7 +9074,7 @@ msgid ""
 "* Functions that can have errors list this in their return type,\n"
 "* There are no exceptions."
 msgstr ""
-"* 오류를 발생할 수 있는 함수는 반환 타입에 이를 명시해야 합니다. \n"
+"* 오류를 발생할 수 있는 함수는 반환 타입에 이를 명시해야 합니다.\n"
 "* 예외(exception) 기능은 없습니다."
 
 #: src/error-handling/panics.md:1
@@ -9375,7 +9217,7 @@ msgstr ""
 
 #: src/error-handling/try-operator.md:13
 msgid "into the much simpler"
-msgstr "이렇게 짧게 쓸 수 있습니다."
+msgstr "이렇게 짧게 쓸 수 있습니다"
 
 #: src/error-handling/try-operator.md:15
 msgid ""
@@ -9459,7 +9301,7 @@ msgstr ""
 
 #: src/error-handling/converting-error-types.md:9
 msgid "works the same as"
-msgstr "위 표현은 아래와 같습니다."
+msgstr "위 표현은 아래와 같습니다"
 
 #: src/error-handling/converting-error-types.md:11
 msgid ""
@@ -9475,7 +9317,7 @@ msgstr ""
 msgid ""
 "The `From::from` call here means we attempt to convert the error type to the\n"
 "type returned by the function:"
-msgstr "`From::from`을 통해 원래의 에러 타입을 이 함수가 반환하는 에러 타입으로 변환하고 있습니다."
+msgstr "`From::from`을 통해 원래의 에러 타입을 이 함수가 반환하는 에러 타입으로 변환하고 있습니다:"
 
 #: src/error-handling/converting-error-types-example.md:3
 msgid ""
@@ -9548,7 +9390,7 @@ msgid ""
 "`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"
@@ -9558,7 +9400,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 ""
@@ -9609,7 +9451,7 @@ 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"
 "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."
@@ -9933,7 +9775,7 @@ msgstr ""
 "* 정적 가변변수 접근 및 수정\n"
 "* `union` 필드 접근\n"
 "* `extern` 함수를 포함한 `unsafe` 함수 호출\n"
-"* `unsafe` 트레이트 구현."
+"* `unsafe` 트레잇 구현."
 
 #: src/unsafe.md:22
 msgid ""
@@ -10017,11 +9859,11 @@ msgid ""
 " * If the pointer was obtained by casting a reference, the underlying object must be live and no\n"
 "   reference may be used to access the memory."
 msgstr ""
-"* 포인터는 null이면 안됩니다.\n"
-"* 포인터는 따라가기가 가능해야 합니다 (객체의 어느 한 부분을 가리키고 있어야 합니다).\n"
-"* 이미 반환된 객체를 가리키면 안됩니다.\n"
-"* 같은 위치에 대해 동시적인 접근이 있으면 안됩니다.\n"
-"* 참조를 캐스팅 해서 포인터를 만들었다면, 그 참조가 가리키는 객체는 살아 있어야 하며, 그 객체의 메모리를 접근하는 참조가 하나도 없어햐 합니다."
+" * 포인터는 null이면 안됩니다.\n"
+" * 포인터는 따라가기가 가능해야 합니다 (객체의 어느 한 부분을 가리키고 있어야 합니다).\n"
+" * 이미 반환된 객체를 가리키면 안됩니다.\n"
+" * 같은 위치에 대해 동시적인 접근이 있으면 안됩니다.\n"
+" * 참조를 캐스팅 해서 포인터를 만들었다면, 그 참조가 가리키는 객체는 살아 있어야 하며, 그 객체의 메모리를 접근하는 참조가 하나도 없어햐 합니다."
 
 #: src/unsafe/raw-pointers.md:40
 msgid "In most cases the pointer must also be properly aligned."
@@ -10093,7 +9935,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 ""
@@ -10284,19 +10126,19 @@ msgstr "위 예제 코드에서 `\"C\"`는 ABI를 의미합니다. [다른 ABI
 
 #: src/unsafe/unsafe-traits.md:1
 msgid "# Implementing Unsafe Traits"
-msgstr "# 안전하지 않은 트레이트 구현하기"
+msgstr "# 안전하지 않은 트레잇 구현하기"
 
 #: src/unsafe/unsafe-traits.md:3
 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 ""
@@ -10330,7 +10172,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."
@@ -10338,7 +10180,7 @@ msgstr "`AsBytes`에서 지켜야 할 안전성에 대한 실제 설명은 좀 
 
 #: src/unsafe/unsafe-traits.md:35
 msgid "The built-in `Send` and `Sync` traits are unsafe."
-msgstr "빌트인 트레이트인 `Send`와 `Sync`는 안전하지 않은 트레이트 입니다."
+msgstr "빌트인 트레잇인 `Send`와 `Sync`는 안전하지 않은 트레잇 입니다."
 
 #: src/exercises/day-3/afternoon.md:1
 msgid "# Day 3: Afternoon Exercises"
@@ -10516,13 +10358,13 @@ msgstr "오늘 강의는 두 가지 주제를 다룹니다:"
 
 #: src/welcome-day-4.md:5
 msgid "* Concurrency: threads, channels, shared state, `Send` and `Sync`."
-msgstr "* 동시성: 쓰레드, 채널, 상태 공유, `Send`와 `Sync`"
+msgstr "* 동시성: 쓰레드, 채널, 상태 공유, `Send`와 `Sync`."
 
 #: src/welcome-day-4.md:7
 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 ""
@@ -10530,10 +10372,7 @@ msgid ""
 "> find a little corner of your code base where we can move some lines of code to\n"
 "> Rust. The fewer dependencies and \"exotic\" types the better. Something that\n"
 "> parses some raw bytes would be ideal."
-msgstr ""
-"> 우리는 오늘 여러분의 프로젝트에서 러스트 코드를 호출해볼 것입니다. 그 프로젝트에서 \n"
-"> 러스트로 옮길만 한 작은 부분을 정하세요. 의존성이 적고 \"특이한\" 타입이 적을 수록 \n"
-"> 좋습니다. 바이트 몇 개를 파싱하는 코드라면 완벽합니다."
+msgstr "> 우리는 오늘 여러분의 프로젝트에서 러스트 코드를 호출해볼 것입니다. 그 프로젝트에서 러스트로 옮길만 한 작은 부분을 정하세요. 의존성이 적고 \"특이한\" 타입이 적을 수록 좋습니다. 바이트 몇 개를 파싱하는 코드라면 완벽합니다."
 
 #: src/concurrency.md:1
 msgid "# Fearless Concurrency"
@@ -10630,7 +10469,7 @@ msgstr "# 범위 스레드(Scoped Threads)"
 
 #: src/concurrency/scoped-threads.md:3
 msgid "Normal threads cannot borrow from their environment:"
-msgstr "보통, 스레드는 스레드 밖에서 데이터를 빌릴 수 없습니다."
+msgstr "보통, 스레드는 스레드 밖에서 데이터를 빌릴 수 없습니다:"
 
 #: src/concurrency/scoped-threads.md:5
 msgid ""
@@ -10702,9 +10541,7 @@ msgstr "# 채널"
 msgid ""
 "Rust channels have two parts: a `Sender<T>` and a `Receiver<T>`. The two parts\n"
 "are connected via the channel, but you only see the end-points."
-msgstr ""
-"러스트의 채널은 `Sender<T>` 와 `Receiver<T>` 두 부분으로 구성됩니다.\n"
-"이 둘은 채널을 통해 서로 연결되어 있지만, 우리는 채널을 볼 수는 없고 이 양 끝단만을 사용하게 됩니다."
+msgstr "러스트의 채널은 `Sender<T>` 와 `Receiver<T>` 두 부분으로 구성됩니다. 이 둘은 채널을 통해 서로 연결되어 있지만, 우리는 채널을 볼 수는 없고 이 양 끝단만을 사용하게 됩니다."
 
 #: src/concurrency/channels.md:6
 msgid ""
@@ -10747,8 +10584,7 @@ msgid ""
 "* `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"
-"  `Receiver`는 `Clone`을 구현하지 않습니다.\n"
+"* `mpsc`는 “Multi-Produce, Single-Consumer”를 의미합니다. `Sender`와 `SyncSender`는 `Clone`을 구현하지만 (즉, 여러개의 producer를 만들수 있습니다) `Receiver`는 `Clone`을 구현하지 않습니다.\n"
 "* `send()`와 `recv()`는 `Result`를 반환합니다. 만일 `Err`가 반환된다면, 상대방의 `Sender`또는 `Receiver`가 삭제되었고 채널이 닫혔다는 뜻입니다."
 
 #: src/concurrency/channels/unbounded.md:1
@@ -10757,7 +10593,7 @@ msgstr "# 무경계 채널(Unbounded Channels)"
 
 #: src/concurrency/channels/unbounded.md:3
 msgid "You get an unbounded and asynchronous channel with `mpsc::channel()`:"
-msgstr "`mpsc::channel()` 함수는 경계가 없는 비동기 채널을 생성합니다: "
+msgstr "`mpsc::channel()` 함수는 경계가 없는 비동기 채널을 생성합니다:"
 
 #: src/concurrency/channels/unbounded.md:5
 #: src/concurrency/channels/bounded.md:5
@@ -10822,7 +10658,7 @@ msgstr "# 상태 공유(Shared State)"
 msgid ""
 "Rust uses the type system to enforce synchronization of shared data. This is\n"
 "primarily done via two types:"
-msgstr "러스트는 주로 아래 두 가지 타입을 이용해서 공유 데이터 동기화를 수행합니다: "
+msgstr "러스트는 주로 아래 두 가지 타입을 이용해서 공유 데이터 동기화를 수행합니다:"
 
 #: src/concurrency/shared_state.md:6
 msgid ""
@@ -10978,8 +10814,7 @@ msgstr ""
 "* `Mutex<T>`는 오직 `T`가 `Send`를 구현하는 경우에만 `Send`와 `Sync`를 구현합니다.\n"
 "* 읽기-쓰기 lock은 `RwLock`을 사용합니다.\n"
 "* 왜 `lock()`이 `Result`를 반환할까요?\n"
-"  * `Mutex`를 획득한 스레드에서 패닉이 발생하면, 데이터가 올바르지 않은 상황이 될 수 있습니다. 이를 `Mutex`가 \"중독(poisoned)\" 되었다고 표현하며,\n"
-"    중독된 뮤텍스에서 `lock()`을 호출하면 실패하고 [`PoisonError`]가 발생합니다. 이러한 오류로부터 데이터를 복구하기 위해 `into_inner()`를 호출할 수 있습니다."
+"  * `Mutex`를 획득한 스레드에서 패닉이 발생하면, 데이터가 올바르지 않은 상황이 될 수 있습니다. 이를 `Mutex`가 \"중독(poisoned)\" 되었다고 표현하며, 중독된 뮤텍스에서 `lock()`을 호출하면 실패하고 [`PoisonError`]가 발생합니다. 이러한 오류로부터 데이터를 복구하기 위해 `into_inner()`를 호출할 수 있습니다."
 
 #: src/concurrency/shared_state/mutex.md:43
 msgid ""
@@ -11098,7 +10933,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 ""
@@ -11115,9 +10950,7 @@ 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"
 "know it is valid."
-msgstr ""
-"`Send`와 `Sync` 트레이트는 [안전하지 않은 트레이트][3]입니다. 컴파일러는 타입의 요소들이 모두 `Send`와 `Sync` 타입이면\n"
-"자동으로 이 트레이트들을 적용시켜 줍니다. 물론 여러분 스스로 맞다고 알고 있다면 직접 구현해도 됩니다."
+msgstr "`Send`와 `Sync` 트레잇은 [안전하지 않은 트레잇][3]입니다. 컴파일러는 타입의 요소들이 모두 `Send`와 `Sync` 타입이면 자동으로 이 트레잇들을 적용시켜 줍니다. 물론 여러분 스스로 맞다고 알고 있다면 직접 구현해도 됩니다."
 
 #: src/concurrency/send-sync.md:14
 msgid ""
@@ -11137,7 +10970,7 @@ msgid ""
 "</details>"
 msgstr ""
 "* `Sync`와 `Send`는 어떤 타입이 특정한 스레드-안전 속성을 가짐을 나타내는 마커로 생각할 수 있습니다.\n"
-"* 이 두 트레이트는 제너릭에서 제약 조건을 나타내는 트레이트로 사용될 수도 있습니다.\n"
+"* 이 두 트레잇은 제네릭에서 제약 조건을 나타내는 트레잇로 사용될 수도 있습니다.\n"
 "\n"
 "</details>"
 
@@ -11154,9 +10987,7 @@ msgid ""
 "The effect of moving ownership to another thread is that _destructors_ will run\n"
 "in that thread. So the question is when you can allocate a value in one thread\n"
 "and deallocate it in another."
-msgstr ""
-"소유권을 다른 스레드로 이동하면 소멸자가 해당 스레드에서 실행됩니다.  \n"
-"여기서 의문은 \"언제 한 스레드에서 값을 할당하고 다른 스레드에서 값을 할당 해제할 수 있는가\" 입니다. "
+msgstr "소유권을 다른 스레드로 이동하면 소멸자가 해당 스레드에서 실행됩니다. 여기서 의문은 \"언제 한 스레드에서 값을 할당하고 다른 스레드에서 값을 할당 해제할 수 있는가\" 입니다."
 
 #: src/concurrency/send-sync/send.md:9
 msgid "[1]: https://doc.rust-lang.org/std/marker/trait.Send.html"
@@ -11178,7 +11009,7 @@ msgstr "좀 더 정확한 정의는 다음과 같습니다:"
 
 #: src/concurrency/send-sync/sync.md:8
 msgid "> `T` is `Sync` if and only if `&T` is `Send`"
-msgstr "`&T`가 `Send`인 경우에만 `T`의 타입이 `Sync`가 됩니다."
+msgstr "`&T`가 `Send`인 경우에만 `T`의 타입이 `Sync`가 됩니다"
 
 #: src/concurrency/send-sync/sync.md:10
 msgid "[1]: https://doc.rust-lang.org/std/marker/trait.Sync.html"
@@ -11224,7 +11055,7 @@ msgstr ""
 msgid ""
 "The generic types are typically `Send + Sync` when the type parameters are\n"
 "`Send + Sync`."
-msgstr "제너릭 타입은 일반적으로 타입 파라메터가 `Send + Sync`이면 `Send + Sync` 입니다."
+msgstr "제네릭 타입은 일반적으로 타입 파라메터가 `Send + Sync`이면 `Send + Sync` 입니다."
 
 #: src/concurrency/send-sync/examples.md:17
 msgid "## `Send + !Sync`"
@@ -11234,7 +11065,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 ""
@@ -11282,7 +11113,7 @@ msgstr "# 연습문제"
 
 #: src/exercises/day-4/morning.md:3
 msgid "Let us practice our new concurrency skills with"
-msgstr "동시성 기법들을 연습해 봅시다:"
+msgstr "동시성 기법들을 연습해 봅시다"
 
 #: src/exercises/day-4/morning.md:5
 msgid "* Dining philosophers: a classic problem in concurrency."
@@ -11326,9 +11157,7 @@ msgid ""
 "You will need a local [Cargo installation](../../cargo/running-locally.md) for\n"
 "this exercise. Copy the code below to `src/main.rs` file, fill out the blanks,\n"
 "and test that `cargo run` does not deadlock:"
-msgstr ""
-"이번 훈련에서는 [카고 설치하기](../../cargo/running-locally.md)가 필요합니다.\n"
-"아래 코드를 복사해서 `src/main.rs`에 붙여놓고 빈 부분을 채우고, `cargo run` 커맨드로 테스트 해서 교착상태(데드락)가 발생하지 않는지 확인합니다:"
+msgstr "이번 훈련에서는 [카고 설치하기](../../cargo/running-locally.md)가 필요합니다. 아래 코드를 복사해서 `src/main.rs`에 붙여놓고 빈 부분을 채우고, `cargo run` 커맨드로 테스트 해서 교착상태(데드락)가 발생하지 않는지 확인합니다:"
 
 #: src/exercises/day-4/dining-philosophers.md:17
 msgid ""
@@ -11412,16 +11241,13 @@ msgid ""
 "start at a webpage and check that links on the page are valid. It should\n"
 "recursively check other pages on the same domain and keep doing this until all\n"
 "pages have been validated."
-msgstr ""
-"새로 배운것들을 활용해서 멀티 스레드 링크 검사기를 만듭니다. \n"
-"이 검사기는 웹페이지 안에 있는 링크들이 유효한지 확인합니다. \n"
-"그리고 재귀적으로 동일 도메인의 다른 모든 페이지가 유효한지 확인합니다."
+msgstr "새로 배운것들을 활용해서 멀티 스레드 링크 검사기를 만듭니다. 이 검사기는 웹페이지 안에 있는 링크들이 유효한지 확인합니다. 그리고 재귀적으로 동일 도메인의 다른 모든 페이지가 유효한지 확인합니다."
 
 #: src/exercises/day-4/link-checker.md:8
 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 ""
@@ -11436,9 +11262,7 @@ msgstr ""
 msgid ""
 "> If `cargo add` fails with `error: no such subcommand`, then please edit the\n"
 "> `Cargo.toml` file by hand. Add the dependencies listed below."
-msgstr ""
-"> 만일 `cargo add` 커맨드가 `error: no such subcommand` 로 실패한다면 \n"
-"> `Cargo.toml` 파일을 직접 수정해도 됩니다. 아래에 전체 의존성 내용이 있습니다."
+msgstr "> 만일 `cargo add` 커맨드가 `error: no such subcommand` 로 실패한다면 `Cargo.toml` 파일을 직접 수정해도 됩니다. 아래에 전체 의존성 내용이 있습니다."
 
 #: src/exercises/day-4/link-checker.md:20
 msgid "You will also need a way to find links. We can use [`scraper`][2] for that:"
@@ -11455,7 +11279,7 @@ msgstr ""
 msgid ""
 "Finally, we'll need some way of handling errors. We use [`thiserror`][3] for\n"
 "that:"
-msgstr "마지막으로 오류 처리하는 방법으로 [`thiserror`][3]도 추가합니다."
+msgstr "마지막으로 오류 처리하는 방법으로 [`thiserror`][3]도 추가합니다:"
 
 #: src/exercises/day-4/link-checker.md:29
 msgid ""
@@ -11482,7 +11306,7 @@ msgstr ""
 msgid ""
 "You can now download the start page. Try with a small site such as\n"
 "`https://www.google.org/`."
-msgstr "이제 `https://www.google.org/` 같은 웹 페이지를 탐색할 수 있습니다. "
+msgstr "이제 `https://www.google.org/` 같은 웹 페이지를 탐색할 수 있습니다."
 
 #: src/exercises/day-4/link-checker.md:45
 msgid "Your `src/main.rs` file should look something like this:"
@@ -11551,7 +11375,7 @@ msgstr ""
 
 #: src/exercises/day-4/link-checker.md:90
 msgid "Run the code in `src/main.rs` with"
-msgstr "아래 커맨드로 소스를 실행합니다: "
+msgstr "아래 커맨드로 소스를 실행합니다"
 
 #: src/exercises/day-4/link-checker.md:92
 msgid ""
@@ -11601,7 +11425,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 ""
@@ -11616,9 +11440,7 @@ msgstr ""
 msgid ""
 "Please see the [Android Developer\n"
 "Codelab](https://source.android.com/docs/setup/start) for details."
-msgstr ""
-"자세한 내용은  [Android Developer\n"
-"Codelab](https://source.android.com/docs/setup/start)을 참조하십시오."
+msgstr "자세한 내용은 [Android Developer Codelab](https://source.android.com/docs/setup/start)을 참조하십시오."
 
 #: src/android/build-rules.md:1
 msgid "# Build Rules"
@@ -11724,7 +11546,7 @@ msgstr "`rust_library`를 사용하여 안드로이드용 새 러스트 라이
 
 #: src/android/build-rules/library.md:5
 msgid "Here we declare a dependency on two libraries:"
-msgstr "여기서 두 개의 라이브러리에 대한 의존성을 선언합니다."
+msgstr "여기서 두 개의 라이브러리에 대한 의존성을 선언합니다:"
 
 #: src/android/build-rules/library.md:7
 msgid ""
@@ -11843,7 +11665,7 @@ msgstr "# AIDL 인터페이스"
 
 #: src/android/aidl/interface.md:3
 msgid "You declare the API of your service using an AIDL interface:"
-msgstr "AIDL 인터페이스를 이용해서 서비스의 API를 선언합니다: "
+msgstr "AIDL 인터페이스를 이용해서 서비스의 API를 선언합니다:"
 
 #: src/android/aidl/interface.md:5
 msgid "*birthday_service/aidl/com/example/birthdayservice/IBirthdayService.aidl*:"
@@ -12130,11 +11952,11 @@ msgstr ""
 
 #: src/android/aidl/client.md:52
 msgid "Notice that the client does not depend on `libbirthdayservice`."
-msgstr "클라이언트는 `libbirthdayservice`에 의존하지 않음에 주목하세요. "
+msgstr "클라이언트는 `libbirthdayservice`에 의존하지 않음에 주목하세요."
 
 #: src/android/aidl/client.md:54
 msgid "Build, push, and run the client on your device:"
-msgstr "빌드하고, 가상 디바이스로 넣고, 실행합니다: "
+msgstr "빌드하고, 가상 디바이스로 넣고, 실행합니다:"
 
 #: src/android/aidl/client.md:56
 msgid ""
@@ -12174,7 +11996,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_:"
@@ -12270,7 +12092,7 @@ msgid ""
 "* Call Rust functions from other languages.\n"
 "* Call functions written in other languages from Rust."
 msgstr ""
-"* 타 언어에서 러스트 함수를 호출합니다. \n"
+"* 타 언어에서 러스트 함수를 호출합니다.\n"
 "* 타 언어의 함수를 러스트에서 호출합니다."
 
 #: src/android/interoperability.md:9
@@ -12287,9 +12109,7 @@ msgstr "# C와의 상호운용성"
 msgid ""
 "Rust has full support for linking object files with a C calling convention.\n"
 "Similarly, you can export Rust functions and call them from C."
-msgstr ""
-"러스트는 C 호출규약을 따르는 오브젝트 파일과 링킹할 수 있습니다.\n"
-"또한, 반대로 러스트 함수를 내보내서 C에서 호출 할 수 도 있습니다. "
+msgstr "러스트는 C 호출규약을 따르는 오브젝트 파일과 링킹할 수 있습니다. 또한, 반대로 러스트 함수를 내보내서 C에서 호출 할 수 도 있습니다."
 
 #: src/android/interoperability/with-c.md:6
 msgid "You can do it by hand if you want:"
@@ -12317,15 +12137,13 @@ 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 ""
 "> This assumes full knowledge of the target platform. Not recommended for\n"
 "> production."
-msgstr ""
-"> 이러한 방법은 타겟 플랫폼의 모든 부분을 사전에 알고 있다는 전제를 깔고 있습니다.\n"
-"> 상용 프로젝트에서는 권장하지 않습니다."
+msgstr "> 이러한 방법은 타겟 플랫폼의 모든 부분을 사전에 알고 있다는 전제를 깔고 있습니다. 상용 프로젝트에서는 권장하지 않습니다."
 
 #: src/android/interoperability/with-c.md:26
 msgid "We will look at better options next."
@@ -12649,9 +12467,7 @@ msgstr ""
 msgid ""
 "`#[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"
-"심볼 이름을 바꾸고 싶다면 `#[export_name = \"some_name\"]`을 사용합니다."
+msgstr "`#[no_mangle]`은 러스트의 네임 맹글링(name mangling)을 비활성화하므로 외부로 노출되는 심볼의 이름은 함수의 이름 그대로가 됩니다. 심볼 이름을 바꾸고 싶다면 `#[export_name = \"some_name\"]`을 사용합니다."
 
 #: src/android/interoperability/cpp.md:1
 msgid "# With C++"
@@ -12665,7 +12481,7 @@ msgstr "[CXX 크레이트][1]는 러스트와 C++ 사이의 안전한 상호운
 
 #: src/android/interoperability/cpp.md:6
 msgid "The overall approach looks like this:"
-msgstr "전체적인 접근 방법은 다음과 같습니다. "
+msgstr "전체적인 접근 방법은 다음과 같습니다:"
 
 #: src/android/interoperability/cpp.md:8
 msgid "<img src=\"cpp/overview.svg\">"
@@ -12793,7 +12609,7 @@ msgstr ""
 
 #: src/android/interoperability/java.md:73
 msgid "Finally, you can build, sync, and run the binary:"
-msgstr "마지막으로 바이너리를 빌드, 싱크, 실행합니다: "
+msgstr "마지막으로 바이너리를 빌드, 싱크, 실행합니다:"
 
 #: src/android/interoperability/java.md:75
 msgid ""
@@ -12808,7 +12624,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."
@@ -12841,7 +12657,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"
@@ -12941,8 +12757,7 @@ msgstr ""
 "* [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 With Entirely Too Many Linked Lists](https://rust-unofficial.github.io/too-many-lists/): 몇가지 유형의 리스트 자료구조를 구현해보면서 러스트의 메모리 관리 규칙들을 깊이있게 탐색합니다."
 
 #: src/other-resources.md:63
 msgid ""
@@ -12959,9 +12774,7 @@ msgid ""
 "The material here builds on top of the many great sources of Rust documentation.\n"
 "See the page on [other resources](other-resources.md) for a full list of useful\n"
 "resources."
-msgstr ""
-"이 자료는 많은 훌륭한 러스트 문서들의 도움을 받아 작성되었습니다. \n"
-"유용한 자료의 전체 목록은 [other resources](other-resources.md)에서 살펴보시기 바랍니다."
+msgstr "이 자료는 많은 훌륭한 러스트 문서들의 도움을 받아 작성되었습니다. 유용한 자료의 전체 목록은 [other resources](other-resources.md)에서 살펴보시기 바랍니다."
 
 #: src/credits.md:7
 msgid ""
@@ -12991,9 +12804,7 @@ msgid ""
 "Exercism](https://exercism.org/tracks/rust). Please see the\n"
 "`third_party/rust-on-exercism/` directory for details, including the license\n"
 "terms."
-msgstr ""
-"일부 연습문제는 [Rust on Exercism](https://exercism.org/tracks/rust)을 참조하였습니다.\n"
-"라이선스 조항을 포함하여 저장소의 `third_party/rust-on-exercism/`폴더를 참조하시기 바랍니다."
+msgstr "일부 연습문제는 [Rust on Exercism](https://exercism.org/tracks/rust)을 참조하였습니다. 라이선스 조항을 포함하여 저장소의 `third_party/rust-on-exercism/`폴더를 참조하시기 바랍니다."
 
 #: src/credits.md:24
 msgid "## CXX"
@@ -13004,9 +12815,7 @@ msgid ""
 "The [Interoperability with C++](android/interoperability/cpp.md) section uses an\n"
 "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"
-"라이선스 조항을 포함하여 저장소의 `third_party/cxx/`폴더를 참조하시기 바랍니다."
+msgstr "4일차 오후 강의 중 [Interoperability with C++](android/interoperability/cpp.md)에서는 [CXX](https://cxx.rs/)의 이미지를 사용하였습니다. 라이선스 조항을 포함하여 저장소의 `third_party/cxx/`폴더를 참조하시기 바랍니다."
 
 #: src/exercises/solutions.md:1
 msgid "# Solutions"
@@ -13028,7 +12837,7 @@ 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"
@@ -13146,9 +12955,7 @@ 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."
-msgstr ""
-"사실 이 문제는 고급 개념이 필요합니다. 슬라이스의 슬라이스(slice-of-slices, `&[&[i32]]`)를 입력 타입으로 사용하면 모든 크기의 행렬을 처리할 수 있을것 같습니다.\n"
-"하지만 실제로 해보면 금방 안된다는 걸 알 수 있습니다. 반환값을 소유해야 하기때문에 `&[&[i32]]` 반환 타입으로 사용할 수 없습니다. "
+msgstr "사실 이 문제는 고급 개념이 필요합니다. 슬라이스의 슬라이스(slice-of-slices, `&[&[i32]]`)를 입력 타입으로 사용하면 모든 크기의 행렬을 처리할 수 있을것 같습니다. 하지만 실제로 해보면 금방 안된다는 걸 알 수 있습니다. 반환값을 소유해야 하기때문에 `&[&[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."
@@ -13156,7 +12963,7 @@ msgstr "`Vec<Vec<i32>>`와 같은 타입을 사용하려고 시도할 수도 있
 
 #: 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] 트레이트를 사용하여 슬라이스처럼 사용될 수 있는 타입을 추상화할 수 있습니다."
+msgstr "트레잇나 제네릭을 다루고 나면 [`std::convert::AsRef`][1] 트레잇을 사용하여 슬라이스처럼 사용될 수 있는 타입을 추상화할 수 있습니다."
 
 #: src/exercises/day-1/solutions-morning.md:86
 msgid ""
@@ -14169,6 +13976,13 @@ msgid ""
 "```"
 msgstr ""
 
+#~ msgid ""
+#~ "* `len()` returns the size of the `String` in bytes, not its length in characters.\n"
+#~ "* `chars()` returns an iterator over the actual characters."
+#~ msgstr ""
+#~ "* `len()`은 `String`의 글자 길이가 아닌 바이트 사이즈를 반환합니다.\n"
+#~ "* `chars()`은 실제 문자들에 대한 반복자를 반환합니다."
+
 #~ msgid ""
 #~ "<details>\n"
 #~ "    \n"
@@ -14177,7 +13991,7 @@ 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"
@@ -14194,4 +14008,4 @@ msgstr ""
 #~ msgid ""
 #~ "Both traits are not to be implemented. They are implemented automatically when \n"
 #~ "the compiler determines it’s appropriate."
-#~ msgstr "이 트레이트는 프로그래머가 수동으로 구현을 해야 하는 트레이트가 아닙니다. 컴파일러는 적당하다고 판단되면 이 두 트레이트를 자동으로 구현합니다."
+#~ msgstr "이 트레잇은 프로그래머가 수동으로 구현을 해야 하는 트레잇이 아닙니다. 컴파일러는 적당하다고 판단되면 이 두 트레잇을 자동으로 구현합니다."