rust/comprehensive-rust
1
0
Fork 0
mirror of https://github.com/google/comprehensive-rust.git synced 2025-04-01 09:32:10 +02:00
Code Issues Releases Activity

Cosmetic refinement in Korean translation (#455)

Browse Source 
* Add missing translation in Korean

* Cosmetic refinement of Korean translation

* typo
* spacing
* newlines
* `_text_` into `*text*` or `*text*`
* removed a few "translation note"(역주)

* Fix typo in Korean

---------

Co-authored-by: Jooyung Han <jooyung@google.com>
This commit is contained in:
Jooyung Han 2023-02-24 16:34:27 +00:00 committed by GitHub
parent 261bcfce3e
commit 98ec5c65af
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 69 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

132
po/ko.po
View File

@ -2,7 +2,7 @@ msgid ""
msgstr ""
"Project-Id-Version: [한국어]Comprehensive Rust 🦀\n"
"POT-Creation-Date: \n"
"PO-Revision-Date: 2023-02-23 16:38+0900\n"
"PO-Revision-Date: 2023-02-25 01:10+0900\n"
"Last-Translator: keispace <keispace.kyj@google.com>\n"
"Language-Team: \n"
"Language: ko\n"
@ -1250,7 +1250,7 @@ msgstr "이렇게 하면 [rust-analyzer][1]를 이용해서 특정 심볼이 정
#: src/cargo.md:29
msgid "Some folks also like to use the [JetBrains][4] family of IDEs, which do their own analysis but have their own tradeoffs. If you prefer them, you can install the [Rust Plugin][5]. Please take note that as of January 2023 debugging only works on the CLion version of the JetBrains IDEA suite."
msgstr "어떤 사람들은 [Jetbrains][4] 제품군을 선호하기도 합니다. 이 제품들은 rust-analyzer 를 활용하지 않고 IDE 자체적으로 구분분석을 합니다. 만약 이 IDE를 설치하셨다면 [Rust Plugin][5]를 설치하시기 바랍니다. 다만 2023년 1월 기준, 디버깅은 Jetbrains IDEA suite의 CLion 버전에서만 작동한다는 점에 유의하시기 바랍니다."
msgstr "어떤 사람들은 [JetBrains][4] 제품군을 선호하기도 합니다. 이 제품들은 rust-analyzer 를 활용하지 않고 IDE 자체적으로 구문분석을 합니다. 만약 이 IDE를 설치하셨다면 [Rust Plugin][5]를 설치하시기 바랍니다. 다만 2023년 1월 기준, 디버깅은 JetBrains IDEA suite의 CLion 버전에서만 작동한다는 점에 유의하시기 바랍니다."
#: src/cargo.md:31
msgid ""
@ -1438,7 +1438,7 @@ msgstr ""
msgid ""
"You can use <kbd>Ctrl + Enter</kbd> to execute the code when focus is in the\n"
"text box."
msgstr "코드 블록에 포커스를 두고 <kbd>Ctrl-Enter</kbd>를 눌러 실행해 볼 수 있습니다."
msgstr "코드 블록에 포커스를 두고 <kbd>Ctrl + Enter</kbd>를 눌러 실행해 볼 수 있습니다."
#: src/cargo/code-samples.md:24
msgid ""
@ -1676,7 +1676,7 @@ msgid ""
" * servers."
msgstr ""
"* 러스트는 C++와 유사한 정적 컴파일 언어입니다.\n"
" * 'rustc'는 LLVM을 백엔드로 사용합니다.\n"
" * `rustc`는 LLVM을 백엔드로 사용합니다.\n"
"* 러스트는 다양한 플랫폼과 아키텍쳐를 지원합니다.\n"
" * x86, ARM, WebAssembly, ...\n"
" * Linux, Mac, Windows, ...\n"
@ -1685,7 +1685,7 @@ msgstr ""
" * 스마트 디스플레이\n"
" * 스마트폰\n"
" * 데스크탑\n"
" * 서버."
" * 서버"
#: src/welcome-day-1/what-is-rust.md:21
msgid "Rust fits in the same area as C++:"
@ -1816,13 +1816,13 @@ msgid ""
"The code implements the Collatz conjecture: it is believed that the loop will\n"
"always end, but this is not yet proved. Edit the code and play with different\n"
"inputs."
msgstr "이 코드는 콜라츠 추측(Collatz conjecture)으로 구현됩니다:반복문이 언제나 종료될 것이라고 믿지만 증명된 것은 아닙니다. 코드를 수정하고 실행해 보시기 바랍니다."
msgstr "이 코드는 콜라츠 추측(Collatz conjecture)으로 구현됩니다: 반복문이 언제나 종료될 것이라고 믿지만 증명된 것은 아닙니다. 코드를 수정하고 실행해 보시기 바랍니다."
#: src/hello-world/small-example.md:29
msgid ""
"* Explain that all variables are statically typed. Try removing `i32` to trigger\n"
" type inference. Try with `i8` instead and trigger a runtime integer overflow."
msgstr "* 모든 변수가 컴파일 시 정해진 타입을 가짐을 설명합니다. i32를 삭제하여 컴파일러가 타입 추론을 하도록 해 봅니다. i32을 i8로 변경하여 런타임 오버플로를 유발해 볼 수 있습니다."
msgstr "* 모든 변수가 컴파일 시 정해진 타입을 가짐을 설명합니다. `i32`를 삭제하여 컴파일러가 타입 추론을 하도록 해 봅니다. `i32`을 `i8`로 변경하여 런타임 오버플로를 유발해 볼 수 있습니다."
#: src/hello-world/small-example.md:32
msgid "* Change `let mut x` to `let x`, discuss the compiler error."
@ -1845,7 +1845,7 @@ msgid ""
"* Show the students the standard library, show them how to search for `std::fmt`\n"
" which has the rules of the formatting mini-language. It's important that the\n"
" students become familiar with searching in the standard library."
msgstr "학생들에게 표준 라이브러리가 어디 있는지 알려 주고는, `print!`가 지원하는 포맷팅 언어의 문법을 알기 위해 `std::fmt`를 검색해야 한다는 것을 가르치세요.학생들이 표준 라이브러리의 검색 기능에 익숙해 지도록 하는 것이 중요합니다."
msgstr "* 학생들에게 표준 라이브러리가 어디 있는지 알려 주고는, `print!`가 지원하는 포맷팅 언어의 문법을 알기 위해 `std::fmt`를 검색해야 한다는 것을 가르치세요.학생들이 표준 라이브러리의 검색 기능에 익숙해 지도록 하는 것이 중요합니다."
#: src/why-rust.md:1
msgid "# Why Rust?"
@ -1934,7 +1934,7 @@ msgid ""
msgstr ""
"* [`Box::leak`]을 이용하여 포인터를 의도적으로 누출시킬 수 있습니다. 이를 이용해서 런타임이 생성하고 런타임이 크기를 정한 정적 변수를 가져올 수 있습니다.\n"
"* [`std::mem::forget`]을 사용하여 컴파일러가 값에 대해 \"잊도록\" 만들 수 있습니다(소멸자가 실행되지 않음을 의미합니다).\n"
"* `Rc` 또는 `Arc`를 사용하여 실수로 [순환참조][reference cycle]을 생성할 수도 있습니다.\n"
"* `Rc` 또는 `Arc`를 사용하여 실수로 [순환참조][reference cycle]를 생성할 수도 있습니다.\n"
"* 컬렉션을 무한정 채우는 것을 메모리 누출로 간주할 수도 있지만, 러스트는 이를 보호하진 못합니다."
#: src/why-rust/compile-time.md:28
@ -2036,7 +2036,7 @@ msgid ""
"* It may be worth mentioning that Rust enums are 'Algebraic Data Types', also\n"
" known as 'sum types', which allow the type system to express things like\n"
" `Option<T>` and `Result<T, E>`."
msgstr "* 러스트의 열거형(enum)은 합계 타입(`sum types`)으로 알려진 대수학적 데이터형('Algebraic Data Types')으로, 타입 시스템이 `Option<T>`와 `Result<T, E>`등을 표현할 수 있게 해줍니다."
msgstr "* 러스트의 열거형(enum)은 합계 타입(sum type)으로 알려진 대수학적 데이터형(Algebraic Data Type)으로, 타입 시스템이 `Option<T>`와 `Result<T, E>`등을 표현할 수 있게 해줍니다."
#: src/why-rust/modern.md:32
msgid ""
@ -2177,16 +2177,14 @@ msgid ""
"| Arrays | `[T; N]` | `[20, 30, 40]`, `[0; 3]` |\n"
"| Tuples | `()`, `(T,)`, `(T1, T2)`, ... | `()`, `('x',)`, `('x', 1.2)`, ... |"
msgstr ""
"| | Types | Literals |\n"
"|--------------|-------------------------------|-----------------------------------|\n"
"| 배열(Arrays) | `[T; N]` | `[20, 30, 40]`, `[0; 3]` |\n"
"| 튜플(Tuples) | `()`, `(T,)`, `(T1, T2)`, ... | `()`, `('x',)`, `('x', 1.2)`, ... |"
"| | 타입 | 리터럴 |\n"
"|------|-------------------------------|-----------------------------------|\n"
"| 배열 | `[T; N]` | `[20, 30, 40]`, `[0; 3]` |\n"
"| 튜플 | `()`, `(T,)`, `(T1, T2)`, ... | `()`, `('x',)`, `('x', 1.2)`, ... |"
#: src/basic-syntax/compound-types.md:8
msgid "Array assignment and access:"
msgstr ""
"* _역주: js기준으로 설명하면 튜플은 ‘순서가 중요해서 사이즈 N으로 고정된 불변(immutable) 배열’ 이라고 보면 됨. 정확히는 서수(순서가 의미가 있는 내용)의 묶음(모음). 갯수N개에 대해서 N-tuple이라고 부르며 2-tuple을 흔히 쓰긴 함.(cf. 열거형)_\n"
"배열 선언과 접근:"
msgstr "배열 선언과 접근:"
#: src/basic-syntax/compound-types.md:10
msgid ""
@ -2239,7 +2237,7 @@ msgstr "* 포매팅 문자열에서 `?`는 디버깅 출력을 의미합니다.
#: src/basic-syntax/compound-types.md:45
msgid "* Adding `#`, eg `{a:#?}`, invokes a \"pretty printing\" format, which can be easier to read."
msgstr "* `#`을 추가하면(`{a:#}`) 좀 더 읽기 쉬운 \"이쁜\" 형태로 출력이 됩니다."
msgstr "* `#`을 추가하면(`{a:#?}`) 좀 더 읽기 쉬운 \"이쁜\" 형태로 출력이 됩니다."
#: src/basic-syntax/compound-types.md:47
msgid "Tuples:"
@ -2317,7 +2315,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`의 차이점에 주의 하시기 바랍니다. 첫번째 값은 다른 값에 바인딩 될 수 있는 가변 참조이고, 두번째 값은 가변 값에 대한 참조입니다."
msgstr "* `let mut ref_x: &i32`와 `let ref_x: &mut i32`의 차이점에 주의 하시기 바랍니다. 첫번째 값은 다른 값에 바인딩 될 수 있는 가변 참조이고, 두번째 값은 가변 값에 대한 참조입니다."
#: src/basic-syntax/references-dangling.md:1
msgid "# Dangling References"
@ -2417,11 +2415,11 @@ msgstr ""
#: src/basic-syntax/string-slices.md:1
msgid "# `String` vs `str`"
msgstr "# String과 str"
msgstr "# `String`과 `str`"
#: src/basic-syntax/string-slices.md:3
msgid "We can now understand the two string types in Rust:"
msgstr "이제 러스트의 두 가지 문자열 타입에 대해서 이해해 보겠습니다.:"
msgstr "이제 러스트의 두 가지 문자열 타입에 대해서 이해해 보겠습니다:"
#: src/basic-syntax/string-slices.md:5
msgid ""
@ -2460,7 +2458,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로 인코딩된 데이터를 의미합니다. 문자열 리터럴(`”Hello”`)은 프로그램 바이너리에 저장됩니다."
msgstr "* `&str`은 문자열 슬라이스의 불변 참조입니다. 러스트에서 문자열은 UTF-8로 인코딩된 데이터를 의미합니다. 문자열 리터럴(`\"Hello\"`)은 프로그램 바이너리에 저장됩니다."
#: src/basic-syntax/string-slices.md:30
msgid ""
@ -2575,7 +2573,8 @@ msgstr ""
"* `main` 함수에서 그 다음에 오는 함수들을 사용할 수 있습니다. 상단에 선언이나 헤더 같은건 필요 없습니다.\n"
"* 매개변수를 선언할 때에는 이름을 먼저 쓰고, 타입을 나중에 씁니다. 이름과 타입은 `:` 로 구분합니다. 이는 일부 언어(예를 들어 C)와 반대임에 유의하시기 바랍니다. 마찬가지로, 리턴 타입도 함수의 시작이 아닌 가장 뒷부분에 선언합니다.\n"
"* 함수 본문의 마지막 표현식은 반환 값이 됩니다. 간단히, 식 끝에 있는 `;`를 생략하면 됩니다.\n"
"* 반환값이 없는 함수의 경우, `유닛 타입 ()`을 반환합니다. `-> ()`가 생략된 경우 컴파일러는 이를 추론합니다.* `fizzbuzz_to()`함수 내 `for` 반목문의 rage 표현식 중 `=n`은 해당 범위까지 포함한다는 의미입니다.\n"
"* 반환값이 없는 함수의 경우, 유닛 타입 `()`을 반환합니다. `-> ()`가 생략된 경우 컴파일러는 이를 추론합니다.\n"
"* `fizzbuzz_to()`함수 내 `for` 반목문의 범위 표현식 중 `=n`은 n까지 포함한다는 의미입니다.\n"
"* `fizzbuzz()`함수의 `match` 표현식은 많은 일을 합니다. 무슨 일이 일어나는지 조금 더 이해하기 쉽도록 아래 코드를 확인하시기 바랍니다."
#: src/basic-syntax/functions.md:42
@ -2743,7 +2742,7 @@ msgstr "페이지 밖으로 이동할 경우 작성한 내용이 소실되기
#: src/exercises/day-2/morning.md:11 src/exercises/day-2/afternoon.md:7
#: src/exercises/day-3/morning.md:7 src/exercises/day-4/morning.md:12
msgid "After looking at the exercises, you can look at the [solutions] provided."
msgstr "연습문제를 살펴 본 후, 제공된 [solutions]을 살펴볼 수 있습니다."
msgstr "연습문제를 살펴 본 후, 제공된 [해답][solutions]을 살펴볼 수 있습니다."
#: src/exercises/day-1/morning.md:24 src/exercises/day-2/morning.md:13
#: src/exercises/day-3/morning.md:9 src/exercises/day-4/morning.md:14
@ -2762,7 +2761,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] 타입 간 _묵시적 변환_을 자동으로 적용하지 않습니다. 아래 예시를 확인해 보세요:"
msgstr "러스트는 [C++ 와 다르게][3] 타입 간 *묵시적 변환*을 자동으로 적용하지 않습니다. 아래 예시를 확인해 보세요:"
#: src/exercises/day-1/implicit-conversions.md:6
msgid ""
@ -2824,7 +2823,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' 등으로 바꿔서 해당 타입들로 변환이 되는지 확인해보세요. 작은 사이즈 타입에서 큰 사이즈로 변경해보시고 그 반대로도 해보세요. [표준 라이브러리 문서][1]에서 시도해 본 케이스가 구현되어 있는지 확인해 보세요."
msgstr "3. `x`와 `y`를 `f32`이나 `bool`, `i128` 등으로 바꿔서 해당 타입들로 변환이 되는지 확인해보세요. 작은 사이즈 타입에서 큰 사이즈로 변경해보시고 그 반대로도 해보세요. [표준 라이브러리 문서][1]에서 시도해 본 케이스가 구현되어 있는지 확인해 보세요."
#: src/exercises/day-1/implicit-conversions.md:43
msgid ""
@ -2988,7 +2987,7 @@ msgstr "상용 품질의 구현에 대해서는 [`ndarray` 크레이트](https:/
msgid ""
"The solution and the answer to the bonus section are available in the \n"
"[Solution](solutions-morning.md#arrays-and-for-loops) section."
msgstr "보너스 문제에 대한 답변 역시 [Solution](solutions-morning.md#arrays-and-for-loops)에서 확인할 수 있습니다."
msgstr "보너스 문제에 대한 답변 역시 [해답](solutions-morning.md#arrays-and-for-loops)에서 확인할 수 있습니다."
#: src/basic-syntax/variables.md:1
msgid "# Variables"
@ -3177,7 +3176,7 @@ msgstr "[Rust RFC Book][1]에서 언급한 바와 같이, 정적 변수는 별
#: src/basic-syntax/static-and-const.md:44
msgid "We will look at mutating static data in the [chapter on Unsafe Rust](../unsafe.md)."
msgstr "가변 정적 데이터에 대해서는 안전하지 않은 [러스트 파트](../unsafe.md)에서 살펴봅니다."
msgstr "가변 정적 데이터에 대해서는 [안전하지 않은 러스트](../unsafe.md)에서 살펴봅니다."
#: src/basic-syntax/static-and-const.md:48
msgid ""
@ -3195,7 +3194,7 @@ msgstr ""
#: src/basic-syntax/scopes-shadowing.md:1
msgid "# Scopes and Shadowing"
msgstr "# 범위(Scopes)와 쉐도잉(Shadowing)"
msgstr "# 범위(Scope)와 쉐도잉(Shadowing)"
#: src/basic-syntax/scopes-shadowing.md:3
msgid ""
@ -3269,8 +3268,8 @@ msgid ""
"* Full control via manual memory management: C, C++, Pascal, ...\n"
"* Full safety via automatic memory management at runtime: Java, Python, Go, Haskell, ..."
msgstr ""
"* 메모리 관리가 프로그래머의 완전한 통제하에 있지만 수동(_역주_: 그래서 안전하지 않을 수 있는)이 언어: C, C++, Pascal, ...\n"
"* 메모리 관리가 런타임에 의해 되므로 안전하지만 자동(_역주_: 그래서 프로그래머가 개입할 여지가 적거나 없는)인 언어: Java, Python, Go, Haskell, ..."
"* 메모리 관리가 프로그래머의 완전한 통제하에 있지만 수동(그래서 안전하지 않을 수 있는)인 언어: C, C++, Pascal, ...\n"
"* 메모리 관리가 런타임에 의해 되므로 안전하지만 자동(그래서 프로그래머가 개입할 여지가 적거나 없는)인 언어: Java, Python, Go, Haskell, ..."
#: src/memory-management.md:8
msgid "Rust offers a new mix:"
@ -3280,7 +3279,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."
@ -3445,7 +3444,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` 사이에서 함수가 일찍 반환되면 메모리 누출이 일어납니다: 포인터를 잃어버리게 되어 메모리를 반환할 수 없게 됩니다."
msgstr "만약 `malloc` 과 `free` 사이에서 함수가 일찍 반환되면 메모리 누출이 일어납니다: 포인터를 잃어버리게 되어 메모리를 반환할 수 없게 됩니다."
#: src/memory-management/scope-based.md:1
msgid "# Scope-Based Memory Management"
@ -3519,7 +3518,7 @@ msgid ""
"* The programmer never allocates or deallocates memory explicitly.\n"
"* A garbage collector finds unused memory and deallocates it for the programmer."
msgstr ""
"* 개발자는 메모리를 명시적으로 할당/해제 하지 않습니다. \n"
"* 개발자는 메모리를 명시적으로 할당/해제 하지 않습니다.\n"
"* 가비지 컬렉터(GC)는 사용되지 않는 메모리를 찾아 해제합니다."
#: src/memory-management/garbage-collection.md:9
@ -3561,7 +3560,7 @@ msgstr ""
#: src/memory-management/rust.md:10
msgid "It achieves this by modeling _ownership_ explicitly."
msgstr "러스트는 _소유권_을 언어 차원에서 명시적으로 모델링 함으로써 이를 이룹니다."
msgstr "러스트는 *소유권*을 언어 차원에서 명시적으로 모델링 함으로써 이를 이룹니다."
#: src/memory-management/rust.md:14
msgid "* If asked how at this point, you can mention that in Rust this is usually handled by RAII wrapper types such as [Box], [Vec], [Rc], or [Arc]. These encapsulate ownership and memory allocation via various means, and prevent the potential errors in C."
@ -3662,7 +3661,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 ""
@ -3688,9 +3687,9 @@ msgid ""
"* A destructor can run here to free up resources.\n"
"* We say that the variable _owns_ the value."
msgstr ""
"* 스코프가 종료되면 변수는 _삭제(drop)_되었다고 하며 그 변수의 데이터는 메모리에서 해제됩니다.\n"
"* 스코프가 종료되면 변수는 *삭제(drop)*되었다고 하며 그 변수의 데이터는 메모리에서 해제됩니다.\n"
"* 스코프가 종료될 때 다른 리소스를 해제하기 위해 소멸자가 호출되도록 할 수 있습니다.\n"
"* 이것을 두고 변수가 값을 _소유_한다고 표현합니다."
"* 이것을 두고 변수가 값을 *소유*한다고 표현합니다."
#: src/ownership/move-semantics.md:1
msgid "# Move Semantics"
@ -3698,7 +3697,7 @@ msgstr "# Move 문법(Move Semantics)"
#: src/ownership/move-semantics.md:3
msgid "An assignment will transfer ownership between variables:"
msgstr "(변수의)할당은 소유권을 변수 간에 이동시킵니다:"
msgstr "(변수의) 할당은 소유권을 변수 간에 이동시킵니다:"
#: src/ownership/move-semantics.md:5
msgid ""
@ -3724,7 +3723,7 @@ msgstr ""
"* 데이터는 `s1`에서 _이동_됩니다. 따라서 프로그래머는 `s1`은 더 이상 접근 할 수 없습니다.\n"
"* `s1`의 스코프가 종료되면 아무 일도 없습니다: 왜냐하면 `s1`은 아무런 소유권이 없기 때문입니다.\n"
"* `s2`의 스코프가 종료되면 문자열 데이터는 해제됩니다.\n"
"* 값(데이터)의 소유권을 갖는 변수는 항상 _단_ 하나 입니다."
"* 값(데이터)의 소유권을 갖는 변수는 항상 *단* 하나 입니다."
#: src/ownership/move-semantics.md:22
msgid "* Mention that this is the opposite of the defaults in C++, which copies by value unless you use `std::move` (and the move constructor is defined!)."
@ -3923,7 +3922,7 @@ msgstr ""
#: src/ownership/copy-clone.md:1
msgid "# Copying and Cloning"
msgstr "# 복사와 복제"
msgstr "# 복사(copy)와 복제(clone)"
#: src/ownership/copy-clone.md:3
msgid "While move semantics are the default, certain types are copied by default:"
@ -3977,7 +3976,7 @@ msgstr ""
#: src/ownership/copy-clone.md:35
msgid "Copying and cloning are not the same thing:"
msgstr "복사(copying)와 복제(cloning)는 같지 않습니다:"
msgstr "복사(copy)와 복제(clone)는 같지 않습니다:"
#: src/ownership/copy-clone.md:37
msgid ""
@ -4023,7 +4022,7 @@ msgstr "# 빌림(Borrowing)"
msgid ""
"Instead of transferring ownership when calling a function, you can let a\n"
"function _borrow_ the value:"
msgstr "함수 호출시 값의 소유권을 이동하는 대신의 함수가 값을 _빌려올 수_ 있습니다:"
msgstr "함수 호출시 값의 소유권을 이동하는 대신의 함수가 값을 *빌려올 수* 있습니다:"
#: src/ownership/borrowing.md:6 src/ownership/lifetimes-function-calls.md:5
msgid ""
@ -4104,7 +4103,7 @@ msgstr ""
" }\n"
" ```\n"
"* 러스트 컴파일러는 반환값 최적화(RVO)를 수행할 수 있습니다.\n"
"* C++에서 copy elision은 생성자의 부수효과 가능성이 있어 언어레벨의 정의가 필요하지만 러스트에서는 문제가 되지 않습니다. 만약 RVO가 발생하지 않으면 러스트는 항상 간단하고 효율적인 `memcpy`복사를 수행할 것입니다."
"* C++에서 copy elision은 생성자의 부수효과 가능성이 있어 언어레벨의 정의가 필요하지만 러스트에서는 문제가 되지 않습니다. 만약 RVO가 발생하지 않으면 러스트는 항상 간단하고 효율적인 `memcpy`복사를 수행할 것입니다."
#: src/ownership/borrowing.md:53
msgid "[Playground]: https://play.rust-lang.org/"
@ -4157,7 +4156,9 @@ msgid ""
"* After that change, the compiler realizes that `b` is only ever used before the new mutable borrow of `a` through `c`. This is a feature of the borrow checker called \"non-lexical lifetimes\"."
msgstr ""
"* 위 코드 컴파일 되지 않습니다. 왜냐하면 `c`는 `a`를 가변 변수로 빌렸고, 이와 동시에 `b`는 `a`를 불변 변수로 빌렸기 때문입니다.\n"
"* `b`에 대한 `println!` 구분을 `c`가 있는 스코프 앞으로 이동하면 컴파일이 됩니다.* 이렇게 바꾸면, 컴파일러는 `c`가 `a`를 가변 변수로 빌리기 전에만 `b`가 사용된다는 것을 확인할 수 있습니다. 빌림 검사기의 이러한 기능을 \"non-lexical lifetime\" 이라고 합니다. (_역주_: 단순히 스코프만 보면 `b`의 수명은 `main`함수의 전체라고 생각할 수 있습니다. 때문에 `c`의 블럭 안에서는 `a`에 대한 가변 빌림과 불변 빌림이 동시에 존재하는 것 처럼 보이며, 이는 위 제약 조건을 위반하는 것으로 생각할 수 있습니다. 그러나 컴파일러는 `b`가 `c`블럭이 시작되기 전에만 사용된다는 점을 적극 활용해서 `b`의 수명을 `c`블럭의 시작 전 까지로 줄입니다. 그러면 `b`와 `c`의 수명은 겹치지 않고, 따라서 제약 조건을 위반하지 않습니다.)"
"* `b`에 대한 `println!` 구분을 `c`가 있는 스코프 앞으로 이동하면 컴파일이 됩니다.\n"
"* 이렇게 바꾸면, 컴파일러는 `c`가 `a`를 가변 변수로 빌리기 전에만 `b`가 사용된다는 것을 확인할 수 있습니다. 빌림 검사기의 이러한 기능을 \"non-lexical lifetime\" 이라고 합니다.\n"
" * 단순히 스코프만 보면 `b`의 수명은 `main`함수의 전체라고 생각할 수 있습니다. 때문에 `c`의 블럭 안에서는 `a`에 대한 가변 빌림과 불변 빌림이 동시에 존재하는 것 처럼 보이며, 이는 위 제약 조건을 위반하는 것으로 생각할 수 있습니다. 그러나 컴파일러는 `b`가 `c`블럭이 시작되기 전에만 사용된다는 점을 적극 활용해서 `b`의 수명을 `c`블럭의 시작 전 까지로 줄입니다. 그러면 `b`와 `c`의 수명은 겹치지 않고, 따라서 제약 조건을 위반하지 않습니다."
#: src/ownership/lifetimes.md:1
msgid "# Lifetimes"
@ -4165,7 +4166,7 @@ msgstr "# 수명"
#: src/ownership/lifetimes.md:3
msgid "A borrowed value has a _lifetime_:"
msgstr "빌려온 값은 _수명_을 갖습니다:"
msgstr "빌려온 값은 *수명*을 갖습니다:"
#: src/ownership/lifetimes.md:5
msgid ""
@ -4221,7 +4222,7 @@ msgstr ""
"* `'a`는 제네릭 매개변수로 컴파일러로에 의해 추론됩니다.\n"
"* 수명의 이름은 `'` 로 시작하며 보통 `'a`를 많이 씁니다.\n"
"* `&'a Point` 는 `Point`의 수명이 `'a` 수명과 최소한 같거나 더 길다는 것을 의미합니다.\n"
" * 매개변수들이 서로 다른 스코프에 있을 경우 _최소한_이라는 조건이 중요합니다."
" * 매개변수들이 서로 다른 스코프에 있을 경우 \"최소한\"이라는 조건이 중요합니다."
#: src/ownership/lifetimes-function-calls.md:31
msgid ""
@ -4266,7 +4267,7 @@ msgstr ""
" println!(\"left-most point: {:?}\", p3);\n"
" }\n"
" ```\n"
" `p3`의 수명이 `p2` 보다 길기 때문에 이 예제는 컴파일되지 않음을 확인하시기 바랍니다."
" `p3`의 수명이 `p2` 보다 길기 때문에 이 예제는 컴파일되지 않음을 확인하시기 바랍니다."
#: src/ownership/lifetimes-function-calls.md:52
msgid ""
@ -4345,7 +4346,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)."
@ -4523,6 +4524,9 @@ msgid ""
" \n"
"[Solution](solutions-afternoon.md#designing-a-library)"
msgstr ""
"<details>\n"
" \n"
"[해답](solutions-afternoon.md#designing-a-library)"
#: src/exercises/day-1/iterators-and-ownership.md:1
msgid "# Iterators and Ownership"
@ -4611,7 +4615,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 ""
@ -4640,13 +4644,13 @@ msgid ""
"* `IntoIter`: the `Iterator` type returned by the `into_iter` method."
msgstr ""
"* `Item`: `i8`과 같이 반복되는 값의 타입\n"
"* `IntoIter`: `into_iter` 메서드에서 반환되는 `Iterator`타입."
"* `IntoIter`: `into_iter` 메서드에서 반환되는 `Iterator`타입."
#: src/exercises/day-1/iterators-and-ownership.md:68
msgid ""
"Note that `IntoIter` and `Item` are linked: the iterator must have the same\n"
"`Item` type, which means that it returns `Option<Item>`"
msgstr "`IntoIter`에서 `Item`가 연결되어 있음을 주목하세요. `IntoIter` 반복자는 `Item` 타입의 데이터를 가리켜야 합니다. 즉, 반복자는 `Option<Item>`을 리턴합니다."
msgstr "`IntoIter`에는 `Item`이 연결되어 있음을 주목하세요. `IntoIter` 반복자는 `Item` 타입의 데이터를 가리켜야 합니다. 즉, 반복자는 `Option<Item>`을 리턴합니다."
#: src/exercises/day-1/iterators-and-ownership.md:71
msgid "Like before, what is the type returned by the iterator?"
@ -4737,7 +4741,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."
@ -4807,8 +4811,7 @@ msgstr ""
"* 사람들에게 다른 종류의 구조체가 있음을 알게 하기에 좋은 시간일 것입니다.\n"
" * 0 크기 구조체(예: `struct Foo;`)는 데이터를 가지고 있지 않지만 특정 타입의 트레잇을 구현할 때 유용합니다.\n"
" * 다음 슬라이드에서는 필드 이름이 덜 중요할 때 사용할 수 있는 튜플 구조체를 소개합니다.\n"
"* `..peter` 문법은 한 구조체에서 다른 구조체로 대부분의 값을 복사하려고 하는 경우에 하나하나 타이핑하는\n"
" 수고를 덜어줍니다. 반드시 맨 마지막에 와야 합니다."
"* `..peter` 문법은 한 구조체에서 다른 구조체로 대부분의 값을 복사하려고 하는 경우에 하나하나 타이핑하는 수고를 덜어줍니다. 반드시 맨 마지막에 와야 합니다."
#: src/structs/tuple-structs.md:1
msgid "# Tuple Structs"
@ -4883,11 +4886,9 @@ msgid ""
msgstr ""
"* 뉴타입은 다음과 같은 원시타입 값에 특별한 의미를 부여하는 데 유용합니다.\n"
" * 단위 표시를 위한 숫자: 위 예제에서는 뉴턴 단위 표기를 위해 사용합니다.\n"
" * 값이 생성될 때 이미 유효성 검사를 통과 했으므로 추가적인 검사가 필요없는 경우:\n"
" `PhoneNumber(String)`또는 `OddNumber(u32)`\n"
" * 값이 생성될 때 이미 유효성 검사를 통과 했으므로 추가적인 검사가 필요없는 경우: `PhoneNumber(String)`또는 `OddNumber(u32)`\n"
"* `Newtons` 타입의 값에 `f64` 값을 더하는 방법을 보여주세요.\n"
" * 러스트는 대체로 분명하지 않은 것을 싫어합니다. 예를 들면 자동으로 unwrap하거나 불리언 값을 정수 값으로\n"
" 사용하는 것들이 그렇습니다.\n"
" * 러스트는 대체로 분명하지 않은 것을 싫어합니다. 예를 들면 자동으로 unwrap하거나 불리언 값을 정수 값으로 사용하는 것들이 그렇습니다.\n"
" * 연산자 재정의는 3일차 제네릭 부분에서 다룹니다.\n"
"</details>"
@ -4899,7 +4900,7 @@ msgstr "# 필드 할당 단축 문법(Field Shorthand Syntax)"
msgid ""
"If you already have variables with the right names, then you can create the\n"
"struct using a shorthand:"
msgstr "구조체 필드와 동일한 이름의 변수가 있다면 아래와 같이 _짧은 문법_ 으로 구조체를 생성할 수 있습니다:"
msgstr "구조체 필드와 동일한 이름의 변수가 있다면 아래와 같이 \"짧은 문법\"으로 구조체를 생성할 수 있습니다:"
#: src/structs/field-shorthand.md:6 src/methods.md:6
msgid ""
@ -4950,6 +4951,9 @@ msgid ""
"* 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 ""
"* 메서드는 `impl` 블록에 정의됩니다.\n"
"* `peter`와 구조체 업데이트 문법을 사용하여 새로운 구조체 인스턴스를 만들어보세요. 이때, `peter`는 더이상 사용할 수 없게 됩니다.\n"
"* 구조체를 `Debug` 형태로 출력하려면 `{:#?}`를 사용하세요."
#: src/enums.md:1
msgid "# Enums"
@ -5019,7 +5023,7 @@ msgid ""
"</details>"
msgstr ""
"* 열거형은 값들의 집합을 하나의 타입으로 표현할 수 있게 합니다.\n"
"* 위의 `CoinFlip` 열거형 타입은 `Heads`와 `Tail` 두가지 variant를 가집니다. 열거형 타입의 variant는 네임스페이스를 붙여서 사용합니다.\n"
"* 위의 `CoinFlip` 열거형 타입은 `Heads`와 `Tail` 두가지 variant를 가집니다. 열거형 타입의 variant는 네임스페이스를 붙여서 사용합니다.\n"
"* 구조체와 열거형을 비교해 볼까요?\n"
" * 구조체나 열거형 모두, 필드가 하나도 없는 단순한 형태도 가능 하고, 여러 타입의 필드를 가질 수도 있습니다.\n"
" * 둘 다 연관함수를 `impl`블록으로 정의 할 수 있습니다.\n"
@ -5097,7 +5101,9 @@ msgstr ""
"* `match`는 주어진 열거형 값이 실제로 어떤 variant인지 판단하기 위해, 그 variant의 종류가 기록된, 숨겨진 필드(식별자)의 값을 검사합니다.\n"
"* `std::mem::discriminant()`를 이용하여 식별자를 얻을 수도 있습니다.\n"
" * 이는 각 필드 값을 굳이 비교할 필요 없는 구조체에 대해 `PartialEq` 트레잇을 구현할 때 유용합니다.\n"
"* `WebEvent::Click { ... }`은 최상위 레벨 구조체 `struct Click {...}`를 따로 정의하고 `WebEvent::Click(Click)`처럼 튜플 형태로 정의한 것과 정확히 같진 않습니다. 예를 들어 `WebEvent::Click { ... }` 로 정의한 경우, 구조체 형태와 유사하지만 트레잇을 구현 할 수 없습니다."
"* `WebEvent::Click { ... }`은 최상위 레벨 구조체 `struct Click {...}`를 따로 정의하고 `WebEvent::Click(Click)`처럼 튜플 형태로 정의한 것과 정확히 같진 않습니다. 예를 들어 `WebEvent::Click { ... }` 로 정의한 경우, 구조체 형태와 유사하지만 트레잇을 구현 할 수 없습니다.\n"
" \n"
"</details>"
#: src/enums/sizes.md:1
msgid "# Enum Sizes"
@ -5800,7 +5806,7 @@ msgstr ""
"```\n"
"* 엘리먼트를 매칭할 때 `_`를 사용하는 패턴을 추가해 보세요.\n"
"* 배열에 값을 더 추가해 보세요.\n"
"* `..`가 서로 다른 개수의 엘리먼트들에 대해 어떻게 확장되는지 설명하세요.\n "
"* `..`가 서로 다른 개수의 엘리먼트들에 대해 어떻게 확장되는지 설명하세요.\n"
"* `[.., b]`나 `[a@.., b]`와 같은 패턴으로 꼬리 부분을 매칭하는 것을 보여주세요.\n"
"</details>"