diff --git a/po/ko.po b/po/ko.po index 5b97056f..03524088 100644 --- a/po/ko.po +++ b/po/ko.po @@ -727,7 +727,7 @@ msgstr "C에서 러스트 호출" #: src/SUMMARY.md:223 msgid "With C++" -msgstr "C++ 와의 상호운용성" +msgstr "C++와의 상호운용성" #: src/SUMMARY.md:224 msgid "With Java" @@ -787,18 +787,28 @@ msgstr "# Welcome to Comprehensive Rust 🦀" #: src/welcome.md:3 msgid "" +"[![Build workflow](https://img.shields.io/github/actions/workflow/status/google/comprehensive-rust/build.yml?style=flat-square)](https://github.com/google/comprehensive-rust/actions/workflows/build.yml)\n" +"[![GitHub contributors](https://img.shields.io/github/contributors/google/comprehensive-rust?style=flat-square)](https://github.com/google/comprehensive-rust/graphs/contributors)\n" +"[![GitHub stars](https://img.shields.io/github/stars/google/comprehensive-rust?style=flat-square)](https://github.com/google/comprehensive-rust/stargazers)" +msgstr "" +"[![Build workflow](https://img.shields.io/github/actions/workflow/status/google/comprehensive-rust/build.yml?style=flat-square)](https://github.com/google/comprehensive-rust/actions/workflows/build.yml)\n" +"[![GitHub contributors](https://img.shields.io/github/contributors/google/comprehensive-rust?style=flat-square)](https://github.com/google/comprehensive-rust/graphs/contributors)\n" +"[![GitHub stars](https://img.shields.io/github/stars/google/comprehensive-rust?style=flat-square)](https://github.com/google/comprehensive-rust/stargazers)" + +#: src/welcome.md:7 +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일짜리 러스트 강의는 안드로이드 팀이 만들었습니다. 기본 문법부터 제네릭, 에러 핸들링과 같은 고급주제까지 러스트의 모든 것을 포함합니다. 마지막 날에는 안드로이드에 대한 것 까지 다룹니다." -#: src/welcome.md:7 +#: src/welcome.md:11 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 "강의는 당신이 러스트에 대해서 아무것도 모른다고 가정하고 아래의 목표를 가지고 있습니다:" -#: src/welcome.md:10 +#: src/welcome.md:14 msgid "" "* Give you a comprehensive understanding of the Rust syntax and language.\n" "* Enable you to modify existing programs and write new programs in Rust.\n" @@ -808,11 +818,11 @@ msgstr "" "* 기존 프로그램을 수정하고 러스트에서 새 프로그램을 작성할 수 있습니다.\n" "* 일반적인 러스트 관용구를 보여줍니다." -#: src/welcome.md:14 +#: src/welcome.md:18 msgid "On Day 4, we will cover Android-specific things such as:" msgstr "4일차 강의에 우리는 아래와 같은 안드로이드 특화된 내용들도 설명합니다:" -#: src/welcome.md:16 +#: src/welcome.md:20 msgid "" "* Building Android components in Rust.\n" "* AIDL servers and clients.\n" @@ -822,24 +832,24 @@ msgstr "" "* AIDL 서버 및 클라이언트.\n" "* C, C++ 및 Java와의 상호 운용성." -#: src/welcome.md:20 +#: src/welcome.md:24 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 "이 강의에서는 러스트로 안드로이드 **애플리케이션**을 개발하는 것은 다루지 않습니다. 이 강의에서 다루는 안드로이드 특화된 내용은 안드로이드 OS의 일부를 러스트로 개발하는 것에 대한 것입니다. " -#: src/welcome.md:24 +#: src/welcome.md:28 msgid "## Non-Goals" msgstr "## 제외사항" -#: src/welcome.md:26 +#: src/welcome.md:30 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 "러스트는 며칠만에 모든 것을 다루기에는 너무 큰 언어입니다. 그래서 아래와 같은것을 목표로 하지 않습니다:" -#: src/welcome.md:29 +#: src/welcome.md:33 msgid "" "* Learn how to use async Rust --- we'll only mention async Rust when\n" " covering traditional concurrency primitives. Please see [Asynchronous\n" @@ -852,24 +862,24 @@ msgstr "" "* 비동기적 러스트 사용법. 간단하게 언급정도는 하겠지만 좀 더 자세한 내용은 [Asynchronous Programming in Rust](https://rust-lang.github.io/async-book/)를 참조해주세요.\n" "* 매크로를 개발하는 방법. [Chapter 19.5 in the Rust Book](https://doc.rust-lang.org/book/ch19-06-macros.html)와 [Rust by Example](https://doc.rust-lang.org/rust-by-example/macros.html)를 참조하세요." -#: src/welcome.md:37 +#: src/welcome.md:41 msgid "## Assumptions" msgstr "## 독자 수준에 대한 가정" -#: src/welcome.md:39 +#: src/welcome.md:43 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 "본 강의는 여러분이 프로그래밍 자체에 대해서는 알고 있다고 가정합니다. 러스트는 정적타입 언어이며, 강좌에서는 C/C++ 와의 비교, 대조를 통해 러스트를 설명할 것입니다." -#: src/welcome.md:43 +#: src/welcome.md:47 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 등) 프로그래밍 경험이 있다면 따라오는데 큰 문제는 없을 것입니다." -#: src/welcome.md:46 src/cargo/rust-ecosystem.md:19 +#: src/welcome.md:50 src/cargo/rust-ecosystem.md:19 #: src/cargo/code-samples.md:22 src/cargo/running-locally.md:68 #: src/welcome-day-1.md:14 src/welcome-day-1/what-is-rust.md:19 #: src/hello-world.md:20 src/hello-world/small-example.md:21 src/why-rust.md:9 @@ -922,13 +932,61 @@ msgstr "C/C++을 모르더라도 동적 타입 언어(Python이나 JavaScript msgid "
" msgstr "
" -#: src/welcome.md:48 +#: src/welcome.md:52 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 "이것은 \"발표자 노트\"의 예제입니다. 이 부분을 이용해서 추가 정보를 제공합니다. 주로 강의실에서 제기되는 일반적인 질문에 대한 답변과 강사가 다루어야 할 키 포인트일 수 있습니다." +#: src/welcome.md:56 src/cargo/rust-ecosystem.md:67 +#: src/cargo/code-samples.md:35 src/cargo/running-locally.md:74 +#: src/welcome-day-1.md:42 src/welcome-day-1/what-is-rust.md:29 +#: src/hello-world.md:40 src/hello-world/small-example.md:44 src/why-rust.md:24 +#: src/why-rust/compile-time.md:35 src/why-rust/runtime.md:22 +#: src/why-rust/modern.md:66 src/basic-syntax/compound-types.md:62 +#: src/basic-syntax/references.md:28 src/basic-syntax/slices.md:36 +#: src/basic-syntax/functions.md:54 src/exercises/day-1/morning.md:28 +#: src/exercises/day-1/for-loops.md:95 src/basic-syntax/variables.md:20 +#: src/basic-syntax/type-inference.md:48 +#: src/basic-syntax/static-and-const.md:52 +#: src/basic-syntax/scopes-shadowing.md:39 src/memory-management/stack.md:49 +#: src/memory-management/rust.md:18 src/ownership/move-semantics.md:26 +#: src/ownership/moves-function-calls.md:26 src/ownership/borrowing.md:51 +#: src/ownership/shared-unique-borrows.md:29 +#: src/ownership/lifetimes-function-calls.md:60 +#: src/exercises/day-1/afternoon.md:15 src/exercises/day-1/book-library.md:106 +#: src/structs.md:41 src/structs/field-shorthand.md:72 src/enums/sizes.md:155 +#: 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:40 src/std/vec.md:49 +#: src/std/hashmap.md:66 src/std/rc.md:69 src/modules.md:32 +#: src/modules/visibility.md:48 src/modules/filesystem.md:53 +#: src/exercises/day-2/afternoon.md:11 src/traits.md:54 +#: src/traits/from-iterator.md:26 src/traits/operators.md:38 +#: src/traits/drop.md:42 src/traits/default.md:47 src/generics/methods.md:31 +#: src/generics/closures.md:38 src/exercises/day-3/morning.md:11 +#: src/error-handling/try-operator.md:55 +#: src/error-handling/converting-error-types-example.md:60 +#: src/error-handling/deriving-error-enums.md:45 +#: src/error-handling/dynamic-errors.md:41 +#: src/error-handling/error-contexts.md:42 src/unsafe.md:32 +#: src/unsafe/raw-pointers.md:42 src/unsafe/mutable-static-variables.md:35 +#: src/unsafe/unions.md:28 src/unsafe/writing-unsafe-functions.md:38 +#: src/unsafe/extern-functions.md:28 src/unsafe/unsafe-traits.md:37 +#: src/exercises/day-3/afternoon.md:11 src/concurrency/threads.md:45 +#: src/concurrency/channels.md:32 src/concurrency/shared_state/arc.md:38 +#: src/concurrency/shared_state/example.md:60 +#: src/concurrency/send-sync/sync.md:18 src/exercises/day-4/morning.md:16 +#: src/android/interoperability/with-c/rust.md:86 +#: src/exercises/day-4/afternoon.md:15 +msgid "
" +msgstr "
" + #: src/running-the-course.md:1 msgid "# Running the Course" msgstr "# 강의 진행 방식" @@ -950,11 +1008,11 @@ msgstr "강의를 실행하기 위한 준비:" #: src/running-the-course.md:10 msgid "" "1. Make yourself familiar with the course material. We've included speaker notes\n" -" on some of the pages to help highlight the key points (please help us by\n" +" to help highlight the key points (please help us by\n" " contributing more speaker notes!). You should make sure to open the speaker\n" " notes in a popup (click the link with a little arrow next to \"Speaker\n" " Notes\"). This way you have a clean screen to present to the class." -msgstr "1. 강의 자료를 숙지합니다. 주요 요점을 강조하기 위해 일부 페이지에 강의 참조노트를 포함하였습니다. (추가적인 노트를 작성하여 제공해 주시면 감사하겠습니다.) 강의 참조 노트의 링크를 누르면 강의노트가 별도의 팝업으로 분리가 되며, 메인 화면에서는 사라집니다." +msgstr "1. 강의 자료를 숙지합니다. 주요 요점을 강조하기 위해 강의 참조 노트를 포함하였습니다. (추가적인 노트를 작성하여 제공해 주시면 감사하겠습니다.) 강의 참조 노트의 링크를 누르면 별도의 팝업으로 분리가 되며, 메인 화면에서는 사라집니다. 깔끔한 화면으로 강의를 진행할 수 있습니다." #: src/running-the-course.md:16 msgid "" @@ -969,10 +1027,13 @@ msgid "" "3. Find a room large enough for your in-person participants. We recommend a\n" " class size of 15-20 people. That's small enough that people are comfortable\n" " asking questions --- it's also small enough that one instructor will have\n" -" time to answer the questions." -msgstr "3. 충분한 공간을 확보합니다. 수강생과 강사가 질의를 하기에 충분한 시간과 공간이어야 합니다. 15에서 20명 규모의 공간을 추천합니다." +" time to answer the questions. Make sure the room has _desks_ for yourself and for the\n" +" students: you will all need to be able to sit and work with your laptops.\n" +" In particular, you will be doing a lot of live-coding as an instructor, so a lectern won't\n" +" be very helpful for you." +msgstr "3. 충분한 공간을 확보합니다. 15에서 20명 규모의 공간을 추천합니다. 수강생과 강사가 질의를 하기에 충분한 시간과 공간이어야 합니다. 강사나 수강생 모두 책상을 사용할 수 있는 강의실이면 좋습니다. 강의 중에 강사가 라이브 코딩을 하게 될 경우가 많으며, 이때 자리에 앉아 노트북을 사용하는 것이 도움이 됩니다." -#: src/running-the-course.md:26 +#: src/running-the-course.md:29 msgid "" "4. On the day of your course, show up to the room a little early to set things\n" " up. We recommend presenting directly using `mdbook serve` running on your\n" @@ -981,7 +1042,7 @@ msgid "" " participants spot them." msgstr "4. 강의 당일 조금 일찍 와서 준비합니다. 강사 노트북에서 `mdbook serve -d book/ko`를 이용해 직접 프레젠테이션 하면 페이지 이동 시의 지연이 없습니다.([설치 방법][5]을 참조하세요.) 또한, 그렇게 하면 강의 도중 오타를 발견했을 때 그 자리에서 바로 수정 가능하다는 장점도 있습니다." -#: src/running-the-course.md:32 +#: src/running-the-course.md:35 msgid "" "5. Let people solve the exercises by themselves or in small groups. Make sure to\n" " ask people if they're stuck or if there is anything you can help with. When\n" @@ -990,7 +1051,7 @@ msgid "" " information in the standard library." msgstr "5. 수강생들이 직접 (개별 혹은 그룹으로) 연습문제를 풀도록 합니다. 진행이 막혀 도움을 필요로 하는 수강생이 없는지 수시로 확인합니다. 만약 같은 문제를 여러 사람이 겪고 있다면, 그 문제를 강의실 전체 인원에게 알리고 해결책을 제시합니다. 예를 들어 표준 라이브러리 어디에 가면 그 문제에 대한 해답을 찾을 수 있는지 알려 줍니다." -#: src/running-the-course.md:38 +#: src/running-the-course.md:41 msgid "" "6. If you don't skip the Android specific parts on Day 4, you will need an [AOSP\n" " checkout][1]. Make a checkout of the [course repository][2] on the same\n" @@ -999,27 +1060,27 @@ msgid "" " `Android.bp` files in `src/android/`." msgstr "6. 4일차에 있을 안드로이드 부분을 건너띄지 않는다면 [AOSP 코드][1]를 체크아웃해야 합니다. 그런 다음, 같은 컴퓨터에서 [과정 저장소][2]를 체크아웃하고 `src/android/` 디렉터리를 AOSP 코드의 루트로 이동합니다. 이렇게 하면 안드로이드 빌드 시스템에서 과제용으로 추가된 `Android.bp`파일을 인식할 수 있습니다." -#: src/running-the-course.md:44 +#: src/running-the-course.md:47 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` 명렁어가 에뮬레이터 혹은 실제 장치와 작동하는지 확인합니다. 그리고 `src/android/build_all.sh`를 수행해서 모든 안드로이드 예제를 미리 빌드해 보세요. 그 쉘 스크립트를 읽고, 그 안에서 수행되는 명령어들을 확인한 후 각 명령어들을 수동으로 실행해도 잘 되는지 확인하세요." -#: src/running-the-course.md:48 +#: src/running-the-course.md:51 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 "이제 준비는 끝났습니다. 우리가 그랬듯이 여러분들도 이 강의를 즐기시길 바랍니다!" -#: src/running-the-course.md:51 +#: src/running-the-course.md:54 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]을 제공해 주십시오. 우리는 무엇이 좋았고, 무엇이 모자랐는지 듣고 싶습니다. 수강생들로 부터의 [피드백][4]도 환영합니다!" -#: src/running-the-course.md:55 +#: src/running-the-course.md:58 msgid "" "[1]: https://source.android.com/docs/setup/download/downloading\n" "[2]: https://github.com/google/comprehensive-rust\n" @@ -1721,6 +1782,13 @@ msgid "" " arguments (no function [overloading](basic-syntax/functions-interlude.md))." msgstr "* 러스트는 인자의 개수를 사전에 지정할 수 없는 상황에서 함수 [오버로딩](basic-syntax/functions-interlude.md)대신 매크로를 사용합니다." +#: src/hello-world.md:36 +msgid "" +"* Macros being 'hygienic' means they don't accidentally capture identifiers from\n" +" the scope they are used in. Rust macros are actually only\n" +" [partially hygenic](https://veykril.github.io/tlborm/decl-macros/minutiae/hygiene.html)." +msgstr "* 똑똑한 매크로(hygienic macro)는 매크로가 사용되는 스코프에서 의도치 않게 변수를 가로채지 않습니다. 사실 러스트 매크로는 완전히 hygenic하지는 않습니다. [링크](https://veykril.github.io/tlborm/decl-macros/minutiae/hygiene.html)를 참고하세요." + #: src/hello-world/small-example.md:1 msgid "# Small Example" msgstr "# 작은 예제" @@ -2432,11 +2500,14 @@ msgid "" "* For C++ programmers: think of `&str` as `const char*` from C++, but the one that always points \n" " to a valid string in memory. Rust `String` is a rough equivalent of `std::string` from C++ \n" " (main difference: it can only contain UTF-8 encoded bytes and will never use a small-string optimization).\n" +" \n" +"" msgstr "" "* `format!()` 매크로는 변수의 값을 문자열로 변환하는 편리한 방법입니다. 이 매크로는 `println!()` 매크로와 동일한 포맷팅 형식을 지원합니다.\n" "* `&`와 범위 연산자를 이용하여 `String`에서 `&str`슬라이스를 빌려올 수 있습니다.\n" "* 당신이 C++ 프로그래머 라면: `&str`는 C++의 `const char*`와 유사하지만 항상 유효한 문자열을 가리킨다는 점이 다릅니다. 러스트의 `String`은 C++의 `std::string` 과 대략 거의 동일합니다. (주요 차이점: 러스트의 `String`은 UTF-8 인코딩 바이트만 포함할 수 있으며 작은 문자열 최적화(small-string optimization)는 사용하지 않습니다.\n" " \n" +"" #: src/basic-syntax/functions.md:1 msgid "# Functions" @@ -3019,15 +3090,13 @@ msgstr "" msgid "" "This slide demonstrates how the Rust compiler infers types based on constraints given by variable declarations and usages.\n" " \n" -msgstr "" -"이 슬라이드는, 러스트 컴파일러가 변수가 어떻게 선언되어 있고, 어떻게 사용되는지를 제약 조건으로 삼아서 변수의 타입을 추론하는 모습을 보여줍니다.\n" -" \n" - -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 "이 슬라이드는, 러스트 컴파일러가 변수가 어떻게 선언되어 있고, 어떻게 사용되는지를 제약 조건으로 삼아서 변수의 타입을 추론하는 모습을 보여줍니다. 여기서 중요한 것은, 이렇게 명시적인 타입을 생략하고 선언되었다고 해서 \"어떤 타입\"이라도 다 담을 수 있는 타입이 되는 것은 아니라는 점입니다. 명시적인 타입 선언이 있던 없던, 컴파일러가 생성한 머신코드는 동일합니다. 컴파일러는 단지 타입 선언을 생략할 수 있도록 해서 프로그래머가 더 간결한 코드를 쓸 수 있도록 도와줄 뿐입니다." +msgstr "" +"이 슬라이드는, 러스트 컴파일러가 변수가 어떻게 선언되어 있고, 어떻게 사용되는지를 제약 조건으로 삼아서 변수의 타입을 추론하는 모습을 보여줍니다.\n" +" \n" +"여기서 중요한 것은, 이렇게 명시적인 타입을 생략하고 선언되었다고 해서 \"어떤 타입\"이라도 다 담을 수 있는 타입이 되는 것은 아니라는 점입니다. 명시적인 타입 선언이 있던 없던, 컴파일러가 생성한 머신코드는 동일합니다. 컴파일러는 단지 타입 선언을 생략할 수 있도록 해서 프로그래머가 더 간결한 코드를 쓸 수 있도록 도와줄 뿐입니다." #: src/basic-syntax/type-inference.md:32 msgid "The following code tells the compiler to copy into a certain generic container without the code ever explicitly specifying the contained type, using `_` as a placeholder:" @@ -4014,12 +4083,9 @@ msgstr "" #: src/ownership/borrowing.md:27 msgid "" "Notes on stack returns:\n" +"* Demonstrate that the return from `add` is cheap because the compiler can eliminate the copy operation. Change the above code to print stack addresses and run it on the [Playground]. In the \"DEBUG\" optimization level, the addresses should change, while they stay the same when changing to the \"RELEASE\" setting:" msgstr "" -"스택에 할당된 값을 리턴하는 것에 대한 참고: \n" - -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]에서 수행해 보세요. \"디버그\" 최적화 레벨에서는 주소가 바뀌지만, \"릴리즈\" 레벨에서는 바뀌지 않습니다:" #: src/ownership/borrowing.md:30 @@ -4048,6 +4114,8 @@ msgid "" " println!(\"{p1:?} + {p2:?} = {p3:?}\");\n" " }\n" " ```\n" +"* The Rust compiler can do return value optimization (RVO).\n" +"* In C++, copy elision has to be defined in the language specification because constructors can have side effects. In Rust, this is not an issue at all. If RVO did not happen, Rust will always performs a simple and efficient `memcpy` copy." msgstr "" " fn main() {\n" " let p1 = Point(3, 4);\n" @@ -4057,11 +4125,6 @@ msgstr "" " println!(\"{p1:?} + {p2:?} = {p3:?}\");\n" " }\n" " ```\n" - -msgid "" -"* The Rust compiler can do return value optimization (RVO).\n" -"* In C++, copy elision has to be defined in the language specification because constructors can have side effects. In Rust, this is not an issue at all. If RVO did not happen, Rust will always performs a simple and efficient `memcpy` copy." -msgstr "" "* 러스트 컴파일러는 반환값 최적화(RVO)를 수행할 수 있습니다.\n" "* C++에서 copy elision은 생성자의 부수효과 가능성이 있어 언어레벨의 정의가 필요하지만 러스트에서는 문제가 되지 않습니다. 만약 RVO가 발생하지 않으면 러스트는 항상 간단하고 효율적인 `memcpy`복사를 수행할 것입니다." @@ -4205,8 +4268,26 @@ msgstr "" #: src/ownership/lifetimes-function-calls.md:40 msgid "" +" fn main() {\n" +" let p1: Point = Point(10, 10);\n" +" let p3: &Point;\n" +" {\n" +" let p2: Point = Point(20, 20);\n" +" p3 = left_most(&p1, &p2);\n" +" }\n" +" println!(\"left-most point: {:?}\", p3);\n" +" }\n" +" ```\n" " Note how this does not compile since `p3` outlives `p2`." msgstr "" +" fn main() {\n" +" let p1 = Point(3, 4);\n" +" let p2 = Point(10, 20);\n" +" let p3 = add(&p1, &p2);\n" +" println!(\"&p3.0: {:p}\", &p3.0);\n" +" println!(\"{p1:?} + {p2:?} = {p3:?}\");\n" +" }\n" +" ```\n" " `p3`의 수명이 `p2` 보다 길기 때문에 이 예제는 컴파일되지 않음을 확인하시기 바랍니다." #: src/ownership/lifetimes-function-calls.md:52 @@ -4472,8 +4553,12 @@ msgstr "" #: src/exercises/day-1/book-library.md:102 msgid "" +"
\n" +" \n" "[Solution](solutions-afternoon.md#designing-a-library)" msgstr "" +"
\n" +" \n" "[해답](solutions-afternoon.md#designing-a-library)" #: src/exercises/day-1/iterators-and-ownership.md:1 @@ -4490,7 +4575,7 @@ msgstr "러스트의 소유권 모델은 많은 API에 반영이 되어 있습 #: src/exercises/day-1/iterators-and-ownership.md:8 msgid "## `Iterator`" -msgstr "" +msgstr "## `Iterator`" #: src/exercises/day-1/iterators-and-ownership.md:10 msgid "" @@ -4884,16 +4969,50 @@ msgstr "* `new`함수를 다음처럼 구조체 이름 대신 `Self`를 사용 #: src/structs/field-shorthand.md:29 msgid "" -"```rust,ignore\n" -"impl Person {\n" -" fn new(name: String, age: u8) -> Self {\n" -" Self { name, age }\n" -" }\n" -"}\n" -"```" +" ```rust,editable\n" +" #[derive(Debug)]\n" +" struct Person {\n" +" name: String,\n" +" age: u8,\n" +" }\n" +" impl Person {\n" +" fn new(name: String, age: u8) -> Self {\n" +" Self { name, age }\n" +" }\n" +" }\n" +" ``` \n" +"* Implement the `Default` trait for the struct. Define some fields and use the default values for the other fields." msgstr "" -#: src/structs/field-shorthand.md:37 +#: src/structs/field-shorthand.md:43 +msgid "" +" ```rust,editable\n" +" #[derive(Debug)]\n" +" struct Person {\n" +" name: String,\n" +" age: u8,\n" +" }\n" +" impl Default for Person {\n" +" fn default() -> Person {\n" +" Person {\n" +" name: \"Bot\".to_string(),\n" +" age: 0,\n" +" }\n" +" }\n" +" }\n" +" fn create_default() {\n" +" let tmp = Person {\n" +" ..Default::default()\n" +" };\n" +" let tmp = Person {\n" +" name: \"Sam\".to_string(),\n" +" ..Default::default()\n" +" };\n" +" }\n" +" ```" +msgstr "" + +#: src/structs/field-shorthand.md:68 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" @@ -4952,8 +5071,12 @@ msgstr "" #: src/enums.md:31 src/enums/sizes.md:27 msgid "" +"
\n" +" \n" "Key Points:" msgstr "" +"
\n" +" \n" "키 포인트:" #: src/enums.md:35 @@ -5109,26 +5232,9 @@ msgstr "" msgid "* See the [Rust Reference](https://doc.rust-lang.org/reference/type-layout.html)." msgstr "* 자세한 사항은 [공식문서](https://doc.rust-lang.org/reference/type-layout.html)를 확인하세요." -#: src/enums/sizes.md:39 -msgid "" -"Key Points: \n" -msgstr "" -"키 포인트: \n" - -msgid "" -" * Internally Rust is using a field (discriminant) to keep track of the enum variant.\n" -" * `Bar` enum demonstrates that there is a way to control the discriminant value and type. If `repr` is removed, the discriminant type takes 2 bytes, becuase 10001 fits 2 bytes.\n" -" * As a niche optimization an enum discriminant is merged with the pointer so that `Option<&Foo>` is the same size as `&Foo`.\n" -" * `Option` is another example of tight packing.\n" -" * For [some types](https://doc.rust-lang.org/std/option/#representation), Rust guarantees that `size_of::()` equals `size_of::>()`.\n" -" * Zero-sized types allow for efficient implementation of `HashSet` using `HashMap` with `()` as the value." -msgstr "" -"* 러스트는 열거형 variant를 구분하기 위해 내부적으로 식별자(discriminant) 필드를 사용합니다." -"* `Bar` 타입을 보면 식별자의 값을 직접 지정하거나 그 타입을 변경할 수 있음을 알 수 있습니다.`repr`을 제거하면 10001을 나타내는데 2바이트가 필요하기 때문에 식별자 타입이 2바이트를 차지합니다.\n" -"* 니치 최적화(niche optimization)로서 열거형(enum)의 식별자는 포인터에 결합됩니다.그래서 `Option<&Foo>` 타입은 `&Foo`와 같은 사이즈가 됩니다.\n" -"* `Option역시 이에 대한 또 다른 예입니다.\n" -"* [일부 타입](https://doc.rust-lang.org/std/option/#representation)의 경우 러스트는 `size_of::()`와 `size_of::>()`가 동일함을 보장합니다. \n" -"* 0크기 타입 덕분에 `HashMap`의 값을 `()`로 지정하는 식으로 `HashSet`을 효율적으로 구현할 수 있습니다." +#: src/enums/sizes.md:31 +msgid " * Internally Rust is using a field (discriminant) to keep track of the enum variant." +msgstr " * 러스트는 열거형 variant를 구분하기 위해 내부적으로 식별자(discriminant) 필드를 사용합니다." #: src/enums/sizes.md:33 msgid "" @@ -5417,10 +5523,6 @@ msgstr "" #: src/methods.md:30 msgid "" "Key Points:\n" -msgstr "" -"키 포인트: \n" - -msgid "" "* It can be helpful to introduce methods by comparing them to functions.\n" " * Methods are called on an instance of a type (such as a struct or enum), the first parameter represents the instance as `self`.\n" " * Developers may choose to use methods to take advantage of method receiver syntax and to help keep them more organized. By using methods we can keep all the implementation code in one predictable place.\n" @@ -5430,7 +5532,10 @@ msgid "" " * Note how `self` is used like other structs and dot notation can be used to refer to individual fields.\n" " * This might be a good time to demonstrate how the `&self` differs from `self` by modifying the code and trying to run say_hello twice. \n" "* We describe the distinction between method receivers next.\n" +" \n" +"
" msgstr "" +"키 포인트:\n" "* 메서드를 함수와 비교하여 소개하는 것도 도움이 될 수 있습니다.\n" " * 메서드는 구조체나 열거형과 같은 타입의 인스턴스에서 호출 되며, 첫번째 매개변수(파라메터)는 인스턴스를 `self`로 표기합니다.\n" " * 메서드를 이용하면 receiver 문법을 사용할 수 있고 코드를 좀더 체계적으로 정리할 수 있습니다. 메서드들이 예측 가능한 위치에 모여 있으니 찾기 쉽습니다.\n" @@ -5440,6 +5545,8 @@ msgstr "" " * 구조체의 필드를 접근할 때 점 표기를 사용하듯이 `self`에 점 표기를 사용하여 개별 필드들을 접근할 수 있습니다.\n" " * `say_hello` 함수가 두 번 호출되도록 코드를 수정하여 `&self`와 `self`가 어떻게 다른지 보여주는 것도 좋습니다.\n" "* 다음 슬라이드에서 receiver의 구분을 설명합니다.\n" +" \n" +"
" #: src/methods/receiver.md:1 msgid "# Method Receiver" @@ -5481,13 +5588,18 @@ msgstr "`self`를 사용하는 이같은 변형들 외에도 `Box`와 같 #: src/methods/receiver.md:23 msgid "" +"
\n" +" \n" "Consider emphasizing \"shared and immutable\" and \"unique and mutable\". These constraints always come\n" "together in Rust due to borrow checker rules, and `self` is no exception. It isn't possible to\n" "reference a struct from multiple locations and call a mutating (`&mut self`) method on it.\n" " \n" "
" msgstr "" -" \"공유가능한 불변\"과 \"유일한 가변\" 부분은 강조할 만합니다. 이러한 제약은 러스트의 빌림 검사기(borrow checker) 규칙으로 늘 붙어다닙니다. `self`도 예외는 아닙니다. 여러 위치에서 구조체를 참조하면서 객체를 수정하는(`&mut self`를 리시버로 하는) 메서드를 호출하는 것은 불가능합니다.\n" +"
\n" +" \n" +"\"공유가능한 불변\"과 \"유일한 가변\" 부분은 강조할 만합니다. 이러한 제약은 러스트의 빌림 검사기(borrow checker) 규칙으로 늘 붙어다닙니다. `self`도 예외는 아닙니다. 여러 위치에서 구조체를 참조하면서 객체를 수정하는(`&mut self`를 리시버로 하는) 메서드를 호출하는 것은 불가능합니다.\n" +" \n" "
" #: src/methods/example.md:1 src/concurrency/shared_state/example.md:1 @@ -5573,12 +5685,17 @@ msgstr "" #: src/methods/example.md:44 msgid "" +"
\n" +" \n" +"Key Points:\n" "* All four methods here use a different method receiver.\n" " * You can point out how that changes what the function can do with the variable values and if/how it can be used again in `main`.\n" " * You can showcase the error that appears when trying to call `finish` twice.\n" "* Note that although the method receivers are different, the non-static functions are called the same way in the main body. Rust enables automatic referencing and dereferencing when calling methods. Rust automatically adds in the `&`, `*`, `muts` so that that object matches the method signature.\n" "* You might point out that `print_laps` is using a vector that is iterated over. We describe vectors in more detail in the afternoon. " msgstr "" +"
\n" +" \n" "키 포인트:\n" "* 4가지 유형의 메서드 receiver에 대해 설명합니다.\n" " * receiver 유형에 따라 함수가 할 수 있는 일이 달라지고, 또 메소드를 호출한 뒤 `main`에서 해당 객체를 사용할 수 있는지 여부도 달라진다는 점을 강조하세요.\n" @@ -5625,6 +5742,9 @@ msgstr "`_`패턴은 어떤 값과도 매칭되는 와일드카드입니다." #: src/pattern-matching.md:23 msgid "" +"
\n" +" \n" +"Key Points:\n" "* You might point out how some specific characters are being used when in a pattern\n" " * `|` as an `or`\n" " * `..` can expand as much as it needs to be\n" @@ -5633,7 +5753,11 @@ msgid "" "* It can be useful to show how binding works, by for instance replacing a wildcard character with a variable, or removing the quotes around `q`.\n" "* You can demonstrate matching on a reference.\n" "* This might be a good time to bring up the concept of irrefutable patterns, as the term can show up in error messages.\n" +" \n" +"
" msgstr "" +"
\n" +" \n" "* 패턴에서 사용되는 특수 문자들을 알려주세요.\n" " * `|`: or 기호입니다.\n" " * `..`: 필요한 만큼 확장합니다.\n" @@ -5642,6 +5766,8 @@ msgstr "" "* 와일드카드 문자를 변수로 바꾸거나 `q`의 따옴표를 제거하는 식으로 수정하면서 바인딩이 어떻게 작동하는지 보여주는 것도 유용할 수 있습니다.\n" "* 참조를 매칭하는 것도 시연할 수 있습니다.\n" "* 에러 메시지에 \"반박 불가능 패턴(irrefutable pattern)\"이란 용어가 등장하기도 합니다. 지금 그 의미를 소개하는 것도 좋을 것 같습니다.\n" +" \n" +"
" #: src/pattern-matching/destructuring-enums.md:1 msgid "# Destructuring Enums" @@ -5714,9 +5840,11 @@ msgstr "`match`구문에서 `divide_in_two`함수에서 반환되는 `Result` #: src/pattern-matching/destructuring-enums.md:35 msgid "" +"Key points:\n" "* The `if`/`else` expression is returning an enum that is later unpacked with a `match`.\n" "* You can try adding a third variant to the enum definition and displaying the errors when running the code. Point out the places where your code is now inexhaustive and how the compiler tries to give you hints." msgstr "" +"키 포인트:\n" "* `if`/`else` 표현식은 열거형을 반환하고, 이 값은 나중에 `match`로 분해됩니다.\n" "* 열거형에 세번째 variant를 추가하고 코드를 실행하여 오류를 표시해보세요. 코드 어느 부분에 누락이 있는지, 그리고 컴파일러가 어떤 식으로 힌트를 주는지 같이 살펴보세요." @@ -5753,6 +5881,8 @@ msgid "" " Foo { y, .. } => println!(\"y = {y}, other fields were ignored\"),\n" " }\n" "}\n" +"```\n" +"
" msgstr "" "#[rustfmt::skip]\n" "fn main() {\n" @@ -5763,6 +5893,8 @@ msgstr "" " Foo { y, .. } => println!(\"y = {y}, other fields were ignored\"),\n" " }\n" "}\n" +"```\n" +"
" #: src/pattern-matching/destructuring-structs.md:23 msgid "" @@ -5830,9 +5962,38 @@ msgstr "" #: src/pattern-matching/destructuring-arrays.md:30 msgid "" -"* Show matching against the tail with patterns `[.., b]` and `[a@..,b]`\n" +"#[rustfmt::skip]\n" +"fn inspect(slice: &[i32]) {\n" +" println!(\"Tell me about {slice:?}\");\n" +" match slice {\n" +" &[0, y, z] => println!(\"First is 0, y = {y}, and z = {z}\"),\n" +" &[1, ..] => println!(\"First is 1 and the rest were ignored\"),\n" +" _ => println!(\"All elements were ignored\"),\n" +" }\n" +"}\n" +"```\n" +" \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 "" -"* `[.., b]`나 `[a@.., b]`와 같은 패턴으로 꼬리 부분을 매칭하는 것을 보여주세요.\n" +"#[rustfmt::skip]\n" +"fn main() {\n" +" let triple = [0, -2, 3];\n" +" println!(\"Tell me about {triple:?}\");\n" +" match triple {\n" +" [0, y, z] => println!(\"First is 0, y = {y}, and z = {z}\"),\n" +" [1, ..] => println!(\"First is 1 and the rest were ignored\"),\n" +" _ => println!(\"All elements were ignored\"),\n" +" }\n" +"}\n" +"```\n" +" \n" +"* `_`를 사용하여 요소를 매칭하는 패턴을 추가해보세요.\n" +"* 배열에 값을 더 추가해보세요.\n" +"* `..`가 요소 개수에 상관없이 매치될 수 있음을 알려주세요.\n" +"* `[.., b]`나 `[a@.., b]`와 같은 패턴으로 꼬리 부분을 매칭하는 것을 보여주세요." #: src/pattern-matching/match-guards.md:1 msgid "# Match Guards" @@ -5876,6 +6037,7 @@ msgstr "" #: src/pattern-matching/match-guards.md:22 msgid "" +"Key Points:\n" "* Match guards as a separate syntax feature are important and necessary when we wish to concisely express more complex ideas than patterns alone would allow.\n" "* They are not the same as separate `if` expression inside of the match arm. An `if` expression inside of the branch block (after `=>`) happens after the match arm is selected. Failing the `if` condition inside of that block won't result in other arms\n" "of the original `match` expression being considered. \n" @@ -5883,9 +6045,9 @@ msgid "" "* The condition defined in the guard applies to every expression in a pattern with an `|`.\n" "
" msgstr "" +"키 포인트:\n" "* 매치 가드는 별도의 문법 요소로서 패턴 자체만으로 표현하기 어려운 복잡한 경우를 간결하게 표현하고자 할 때 유용합니다.\n" -"* 매치의 각 팔(혹은 가지) 안에 따로 `if`를 사용한 것과 다릅니다. 매치 가지의 `=>` 뒤에 사용된 `if` 표현식은 해당\n" -" 가지가 선택된 다음에 실행됩니다. 따라서 여기서 `if` 조건이 실패하더라도 원래 `match`의 다른 가지는 고려되지 않습니다.\n" +"* 매치의 각 팔(혹은 가지) 안에 따로 `if`를 사용한 것과 다릅니다. 매치 가지의 `=>` 뒤에 사용된 `if` 표현식은 해당 가지가 선택된 다음에 실행됩니다. 따라서 여기서 `if` 조건이 실패하더라도 원래 `match`의 다른 가지는 고려되지 않습니다.\n" "* 패턴에 정의된 변수를 가드의 표현식에서 사용할 수 있습니다.\n" "* 가드에 정의된 조건은 `|` 를 포함하는 패턴의 모든 표현식에 적용됩니다.\n" "
" @@ -6209,15 +6371,12 @@ msgstr "누락된 메서드 시그니처를 올바르게 정의하는 것이 문 #: src/exercises/day-2/points-polygons.md:120 msgid "" "Other interesting parts of the exercise:\n" -msgstr "" -"연습문제의 다른 흥미로운 부분:\n" - -#: src/exercises/day-2/points-polygons.md:121 -msgid "" +" \n" "* Derive a `Copy` trait for some structs, as in tests the methods sometimes don't borrow their arguments.\n" "* Discover that `Add` trait must be implemented for two objects to be addable via \"+\". Note that we do not discuss generics until Day 3." - msgstr "" +"연습문제의 다른 흥미로운 부분:\n" +" \n" "* 테스트 코드를 보면 어떤 메서드들은 인자를 borrow하는 대신 `Copy` 트레잇을 사용하기도 합니다. 구조체가 `Copy` 트레잇을 상속(derive)하도록 하면 됩니다.\n" "* \"+\"를 사용하여 두 객체를 서로 더하려면 `Add` 트레잇을 구현해야 합니다. 이는 3일차에 다룰 내용입니다." @@ -6293,12 +6452,16 @@ msgstr "위의 `main` 함수는 마지막 표현식이 `;`로 끝나기 때문 #: src/control-flow/blocks.md:42 msgid "" +"Key Points:\n" "* The point of this slide is to show that blocks have a type and value in Rust. \n" "* You can show how the value of the block changes by changing the last line in the block. For instance, adding/removing a semicolon or using a `return`.\n" +" \n" +"
" msgstr "" "* 러스트에서는 블록이 타입과 값을 가진다는 점이 이 슬라이드의 핵심입니다.\n" -"* 블록 마지막 줄을 수정하면서 블록의 값이 어떻게 바뀌는지 보여주세요. 예를 들어, 세미콜론을\n" -" 넣거나 뺀다든지, 아니면 `return`을 사용해 보세요.\n" +"* 블록 마지막 줄을 수정하면서 블록의 값이 어떻게 바뀌는지 보여주세요. 예를 들어, 세미콜론을 넣거나 뺀다든지, 아니면 `return`을 사용해 보세요.\n" +" \n" +"
" #: src/control-flow/if-expressions.md:1 msgid "# `if` expressions" @@ -6498,11 +6661,15 @@ msgstr "다른 언어와 마찬가지로 `break` 와 `continue`를 사용할 수 #: src/control-flow/for-expressions.md:22 msgid "" +"
\n" +" \n" "* Index iteration is not a special syntax in Rust for just that case.\n" "* `(0..10)` is a range that implements an `Iterator` trait. \n" "* `step_by` is a method that returns another `Iterator` that skips every other element. \n" "* Modify the elements in the vector and explain the compiler errors. Change vector `v` to be mutable and the for loop to `for x in v.iter_mut()`." msgstr "" +"
\n" +" \n" "* 러스트는 인덱스 반복을 위해 별도의 문법을 사용하지 않습니다. \n" "* `(0..10)`은 `Iterator` 트레잇을 구현하는 범위(range) 값입니다. \n" "* `step_by`는 반복자의 요소들을 건너뛰는 또다른 `Iterator`를 반환하는 메서드입니다.\n" @@ -6540,8 +6707,12 @@ msgstr "" #: src/control-flow/loop-expressions.md:23 msgid "" +"
\n" +" \n" "* Break the `loop` with a value (e.g. `break 8`) and print it out." msgstr "" +"
\n" +" \n" "* `loop` 블록을 빠져나올 때 `break 8`처럼 값을 지정하고 그걸 출력해보세요." #: src/control-flow/match-expressions.md:1 @@ -6702,12 +6873,16 @@ msgstr "* [`Rc`](std/rc.md): 힙에 할당된 데이터에 대한 참조 카운 #: src/std.md:23 msgid "" +"
\n" +" \n" " * In fact, Rust contains several layers of the Standard Library: `core`, `alloc` and `std`. \n" " * `core` includes the most basic types and functions that don't depend on `libc`, allocator or\n" " even the presence of an operating system. \n" " * `alloc` includes types which require a global heap allocator, such as `Vec`, `Box` and `Arc`.\n" " * Embedded Rust applications often only use `core`, and sometimes `alloc`." msgstr "" +"
\n" +" \n" " * 사실, 러스트의 표준 라이브러리는 `core`, `alloc`, `std`와 같이 계층(layer)으로 나눠집니다.\n" " * `core`는 `libc`나 할당자(allocator), 심지어 OS에도 의존하지 않는 가장 기본적인 함수와 타입을 포함합니다.\n" " * `alloc`은 `Vec`, `Box`, `Arc`와 같이 전역 힙 할당이 필요한 타입을 포함합니다.\n" @@ -6802,7 +6977,7 @@ msgstr "" #: src/std/string.md:30 msgid "" -"* `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::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" @@ -7930,8 +8105,20 @@ msgstr "" #: src/traits.md:46 msgid "" "Compare these outputs in the above example:\n" +"```rust,ignore\n" +" println!(\"{} {}\", std::mem::size_of::(), std::mem::size_of::());\n" +" println!(\"{} {}\", std::mem::size_of::<&Dog>(), std::mem::size_of::<&Cat>());\n" +" println!(\"{}\", std::mem::size_of::<&dyn Greet>());\n" +" println!(\"{}\", std::mem::size_of::>());\n" +"```" msgstr "" -"위의 예제에 아래를 추가하여 출력을 비교해 보시기 바랍니다:\n" +"위 예제에서 다음 코드의 출력을 확인해보세요:\n" +"```rust,ignore\n" +" println!(\"{} {}\", std::mem::size_of::(), std::mem::size_of::());\n" +" println!(\"{} {}\", std::mem::size_of::<&Dog>(), std::mem::size_of::<&Cat>());\n" +" println!(\"{}\", std::mem::size_of::<&dyn Greet>());\n" +" println!(\"{}\", std::mem::size_of::>());\n" +"```" #: src/traits/deriving-traits.md:1 msgid "# Deriving Traits" @@ -8099,10 +8286,13 @@ msgid "" " (e.g. `map`, `filter`, `reduce`, etc). This is the trait where you can find all the documentation\n" " about them. In Rust these functions should produce the code as efficient as equivalent imperative\n" " implementations.\n" +" \n" +"
" msgstr "" "* `IntoIterator`는 루프가 작동하도록 만드는 트레잇입니다. `Vec`와 같은 컬렉션 타입과 그에 대한 참조 타입(`&Vec`, `&[T]`)들 모두 이 트레잇을 구현합니다. Range 역시 이를 구현합니다.\n" "* `Iterator` 트레잇은 컬렉션에 대해 다양한 함수형 프로그래밍 연산 (`map`, `filter`, `reduce` 등)을 구현합니다. 이 연산들에 대한 자세한 설명은 `Iterator` 트레잇의 API 레퍼런스에서 찾을 수 있습니다. 러스트에서 이러한 함수형 연산들은 절차형으로 구현된 코드와 동일한 성능을 보여줍니다.\n" " \n" +"
" #: src/traits/iterator.md:41 msgid "[1]: https://doc.rust-lang.org/std/iter/trait.Iterator.html" @@ -8137,7 +8327,7 @@ msgid "" " B: FromIterator,\n" " Self: Sized`" msgstr "" -"`Iterator`는 아래와 같이 구현됩니다.\n" +"`Iterator`에는 다음 함수가 정의되어 있습니다:\n" "`fn collect(self) -> B\n" "where\n" " B: FromIterator,\n" @@ -8147,7 +8337,7 @@ msgstr "" msgid "" "There are also implementations which let you do cool things like convert an\n" "`Iterator>` into a `Result, E>`." -msgstr "이는 또한 `Iterator>`을 `Result, E>`로 변경하는 멋진 작업도 구현합니다." +msgstr "`Iterator>`을 `Result, E>`로 변환할 수 있는 멋진 기능들도 구현되어 있습니다." #: src/traits/from-iterator.md:28 msgid "" @@ -8197,12 +8387,20 @@ msgstr "" #: src/traits/from-into.md:27 msgid "" +"
\n" +" \n" "* That's why it is common to only implement `From`, as your type will get `Into` implementation too.\n" "* When declaring a function argument input type like \"anything that can be converted into a `String`\", the rule is opposite, you should use `Into`.\n" " Your function will accept types that implement `From` and those that _only_ implement `Into`.\n" +" \n" +"
" msgstr "" +"
\n" +" \n" "* 그렇기 때문에 사용자 정의 타입의 경우에도 `From` 만 구현하는 것이 일반적입니다.\n" "* \"`String`으로 변환할 수 있는 모든 것\"과 같은 함수의 인수 타입을 선언할 때에는 `Into`를 사용해야 함을 조심하세요. 그래야만, 함수는 `From`을 구현한 타입과 `Into` _만_ 구현한 타입 모두를 인자로 받을 수 있습니다.\n" +" \n" +"
" #: src/traits/from-into.md:35 msgid "" @@ -8662,18 +8860,40 @@ msgstr "" #: src/generics/trait-bounds.md:35 msgid "" "Show a `where` clause, students will encounter it when reading code.\n" +" \n" +"```rust,ignore\n" +"fn duplicate(a: T) -> (T, T)\n" +"where\n" +" T: Clone,\n" +"{\n" +" (a.clone(), a.clone())\n" +"}\n" +"```" msgstr "" "`where` 문법을 사용할 수도 있습니다. 수강생들도 코드를 읽다가 그 문법을 마주할 수 있습니다.\n" +" \n" +"```rust,ignore\n" +"fn duplicate(a: T) -> (T, T)\n" +"where\n" +" T: Clone,\n" +"{\n" +" (a.clone(), a.clone())\n" +"}\n" +"```" #: src/generics/trait-bounds.md:46 msgid "" "* It declutters the function signature if you have many parameters.\n" "* It has additional features making it more powerful.\n" " * If someone asks, the extra feature is that the type on the left of \":\" can be arbitrary, like `Option`.\n" +" \n" +"
" msgstr "" "* 이를 이용하면 타입 파라메터가 많은 경우 함수 시그니처를 간결하게 정리하는 데 도움이 됩니다.\n" "* 좀 더 강력한 추가 기능도 제공합니다.\n" " * `:` 왼쪽에 임의의 타입(예를 들어 `Option`)을 사용할 수 있습니다.\n" +" \n" +"
" #: src/generics/impl-trait.md:1 msgid "# `impl Trait`" @@ -8738,9 +8958,12 @@ msgid "" "It would not work for this particular function, as the type we expect as input is likely not\n" "what `format!` returns. If we wanted to do the same via `: Display` syntax, we'd need two\n" "independent generic parameters.\n" +" \n" +"
" msgstr "" "이 예시는 `impl Display`가 두번 사용 되었다는 점에서 훌륭합니다. 여기서 중요한 것은 이 두 `impl Display`가 실제로 같은 타입일 필요가 없다는 것입니다. 만약 `T: Display`로 트레잇 경계를 정하고 입력 파라메터와 리턴 값의 타입을 모두 `T`로 했다면, 이는 입력과 리턴값이 같은 타입임을 강제합니다. 이렇게 했다면 위의 예제는 동작하지 않았을 것입니다. 왜냐하면, 입력 값의 타입이 `format!`이 리턴하는 타입과 같지 않을 가능성이 높기 때문입니다. 만약 `: Display` 문법을 사용하고 싶다면 독립적인 제네릭 매개변수가 두 개가 필요합니다.\n" " \n" +"
" #: src/generics/closures.md:1 msgid "# Closures" @@ -9379,9 +9602,13 @@ msgid "" " `unwrap()` or `expect()` can be called, and this is a signal of the developer intent too. \n" " * `Result` documentation is a recommended read. Not during the course, but it is worth mentioning. \n" " It contains a lot of convenience methods and functions that help functional-style programming. \n" +" \n" +"
" msgstr "" " * `Option`와 마찬가지로, 성공한 경우의 값은 `Result` 내부에 있습니다. 그래서, 개발자는 명시적으로 이를 추출하여야 합니다. 이렇게 함으로써 값을 읽기 전에 오류 발생 여부를 반드시 체크하도록 유도하고 있습니다. 만일 오류가 절대 발생하지 않는 경우라면 `unwrap()`이나 `expect()`를 사용할 수 있으며, 이는 개발자의 의도(_역주_: 오류가 발생할 수 없음)을 명시적으로 나타내는 방법이기도 합니다.\n" " * 수업중엔 아니지만 `Result`의 API 레퍼런스를 읽는 것을 권장합니다. 함수형 프로그래밍 스타일에 도움이 되는 편리한 메서드와 함수를 많이 배울 수 있습니다.\n" +" \n" +"
" #: src/error-handling/try-operator.md:1 msgid "# Propagating Errors with `?`" @@ -10066,20 +10293,27 @@ msgstr "# 원시 포인터 역참조(따라가기)" msgid "Creating pointers is safe, but dereferencing them requires `unsafe`:" msgstr "포인터를 만드는 것은 안전합니다. 하지만 역참조(따라가기)할 경우 `unsafe`가 필요합니다:" +#: src/unsafe/raw-pointers.md:5 msgid "" "```rust,editable\n" "fn main() {\n" -" let mut num = 5;\n" -"\n" +" let mut num = 5;" +msgstr "" +"```rust,editable\n" +"fn main() {\n" +" let mut num = 5;" + +#: src/unsafe/raw-pointers.md:9 +msgid "" " let r1 = &mut num as *mut i32;\n" -" let r2 = &num as *const i32;\n" -"\n" -" // Safe because r1 and r2 were obtained from references and so are " -"guaranteed to be non-null and\n" -" // properly aligned, the objects underlying the references from which " -"they were obtained are\n" -" // live throughout the whole unsafe block, and they are not accessed " -"either through the\n" +" let r2 = &num as *const i32;" +msgstr "" + +#: src/unsafe/raw-pointers.md:12 +msgid "" +" // Safe because r1 and r2 were obtained from references and so are guaranteed to be non-null and\n" +" // properly aligned, the objects underlying the references from which they were obtained are\n" +" // live throughout the whole unsafe block, and they are not accessed either through the\n" " // references or concurrently through any other pointers.\n" " unsafe {\n" " println!(\"r1 is: {}\", *r1);\n" @@ -10089,16 +10323,10 @@ msgid "" "}\n" "```" msgstr "" -"```rust,editable\n" -"fn main() {\n" -" let mut num = 5;\n" -"\n" -" let r1 = &mut num as *mut i32;\n" -" let r2 = &num as *const i32;\n" -"\n" -" // 아래 코드는 안전합니다. r1과 r2는 참조로 부터 만들어 졌기 때문에 null이 아니며 align이 맞다는 것이 보장됩니다.\n" -" // 참조가 가리키는 객체들은 unsafe 블럭이 수행되는 동안 메모리에 살아있습니다. 그리고 이 객체들은 r1과 r2가 아닌 다른\n" -" // 어떤 참조나 포인터로도 접근이 안되고 있습니다.\n" +" // 아래 코드는 안전합니다. r1과 r2는 참조로 부터 만들어 졌기 때문에 null이 아니며\n" +" // align이 맞다는 것이 보장됩니다. 참조가 가리키는 객체들은 unsafe 블럭이 수행되는\n" +" // 동안 메모리에 살아있습니다. 그리고 이 객체들은 r1과 r2가 아닌 다른 어떤 참조나\n" +" // 포인터로도 접근이 안되고 있습니다.\n" " unsafe {\n" " println!(\"r1 is: {}\", *r1);\n" " *r1 = 10;\n" @@ -10865,11 +11093,19 @@ msgstr "" #: src/concurrency/scoped-threads.md:35 msgid "" +"
\n" +" \n" "* The reason for that is that when the `thread::scope` function completes, all the threads are guaranteed to be joined, so they can return borrowed data.\n" "* Normal Rust borrowing rules apply: you can either borrow mutably by one thread, or immutably by any number of threads.\n" +" \n" +"
" msgstr "" +"
\n" +" \n" "* `thread::scope` 함수가 완료되면 그 안에서 생성된 모든 스레드들이 종료했음이 보장되기 때문에, 그 때 빌렸던 데이터들을 다시 반환할 수 있기 때문입니다.\n" "* 일반적인 러스트의 빌림 규칙이 적용됩니다: 한 스레드에 의한 가변 빌림 또는 여러 스레드에 대한 불변 빌림중 하나만 가능합니다.\n" +" \n" +"
" #: src/concurrency/channels.md:1 msgid "# Channels" @@ -11130,6 +11366,8 @@ msgstr "" #: src/concurrency/shared_state/mutex.md:29 msgid "" +"
\n" +" \n" "* `Mutex` in Rust looks like a collection with just one element - the protected data.\n" " * It is not possible to forget to acquire the mutex before accessing the protected data.\n" "* You can get an `&mut T` from an `&Mutex` by taking the lock. The `MutexGuard` ensures that the\n" @@ -11142,6 +11380,8 @@ msgid "" " fails with a [`PoisonError`]. You can call `into_inner()` on the error to recover the data\n" " regardless." msgstr "" +"
\n" +" \n" "* 러스트의 `Mutex`는 오직 하나의 데이터만 담을 수 있는 컬렉션처럼 볼 수도 있습니다. 다른 컬렉션과 다른 점은, 그 데이터가 동시성 문제로부터 자유롭다는 점입니다.\n" " * `Mutex`는 뮤텍스를 획득하지 않으면 보호된 데이터에 접근하는 것이 불가능 하도록 디자인 되어 있습니다.\n" "* `&Mutex`에 대해 lock을 획득하면 `&mut T`를 얻을 수 있습니다. `MutexGuard`는 `&mut T`가 획득한 lock보다 오래 살아남지 않음을 보장합니다.\n" @@ -11189,14 +11429,13 @@ msgstr "" #: src/concurrency/shared_state/example.md:23 msgid "" "Possible solution:\n" -msgstr "" -"가능한 해결방법입니다.:\n" - -msgid "" +" \n" "```rust,editable\n" "use std::sync::{Arc, Mutex};\n" "use std::thread;" msgstr "" +"가능한 해결방법입니다:\n" +" \n" "```rust,editable\n" "use std::sync::{Arc, Mutex};\n" "use std::thread;" @@ -11228,6 +11467,26 @@ msgstr "" msgid " handle.join().unwrap();" msgstr "" +#: src/concurrency/shared_state/example.md:45 +msgid "" +" {\n" +" let v = v.lock().unwrap();\n" +" println!(\"v: {v:?}\");\n" +" }\n" +"}\n" +"```\n" +" \n" +"Notable parts:" +msgstr "" +" {\n" +" let v = v.lock().unwrap();\n" +" println!(\"v: {v:?}\");\n" +" }\n" +"}\n" +"```\n" +" \n" +"눈여겨 볼 부분:" + #: src/concurrency/shared_state/example.md:54 msgid "" "* `v` is wrapped in both `Arc` and `Mutex`, because their concerns are orthogonal.\n" @@ -11281,10 +11540,13 @@ msgstr "" msgid "" "* One can think of these traits as markers that the type has certain thread-safety properties.\n" "* They can be used in the generic constraints as normal traits.\n" +" \n" +"
" msgstr "" "* `Sync`와 `Send`는 어떤 타입이 특정한 스레드-안전 속성을 가짐을 나타내는 마커로 생각할 수 있습니다.\n" "* 이 두 트레이트는 제너릭에서 제약 조건을 나타내는 트레이트로 사용될 수도 있습니다.\n" -"\n" +" \n" +"
" #: src/concurrency/send-sync/send.md:1 msgid "# `Send`" @@ -13250,8 +13512,18 @@ msgstr "" #: src/exercises/day-1/solutions-morning.md:73 msgid "" +" let transposed = transpose(matrix);\n" +" println!(\"transposed:\");\n" +" pretty_print(&transposed);\n" +"}\n" +"```\n" "### Bonus question" msgstr "" +" let transposed = transpose(matrix);\n" +" println!(\"transposed:\");\n" +" pretty_print(&transposed);\n" +"}\n" +"```\n" "### 보너스 문제" #: src/exercises/day-1/solutions-morning.md:80