msgid ""
msgstr ""
"Project-Id-Version: Rust By Example\n"
"POT-Creation-Date: 2026-01-13T13:46:42+09:00\n"
"PO-Revision-Date: 2026-01-13 13:46+0900\n"
"Last-Translator: ehottl <deepthought@postech.ac.kr>\n"
"Language-Team: Korean <translation-team-ko@googlegroups.com>\n"
"Language: ko\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: src/SUMMARY.md:1
msgid "Summary"
msgstr "요약"

#: src/SUMMARY.md:3
msgid "Introduction"
msgstr "소개"

#: src/SUMMARY.md:5 src/hello.md:1
msgid "Hello World"
msgstr "Hello World"

#: src/SUMMARY.md:6 src/hello/comment.md:1
msgid "Comments"
msgstr "주석"

#: src/SUMMARY.md:7 src/hello/print.md:1
msgid "Formatted print"
msgstr "형식화된 출력"

#: src/SUMMARY.md:8 src/hello/print/print_debug.md:1
msgid "Debug"
msgstr "디버그"

#: src/SUMMARY.md:9 src/hello/print/print_display.md:1
msgid "Display"
msgstr "디스플레이"

#: src/SUMMARY.md:10 src/hello/print/print_display/testcase_list.md:1
msgid "Testcase: List"
msgstr "테스트케이스: 리스트"

#: src/SUMMARY.md:11 src/hello/print/fmt.md:1
msgid "Formatting"
msgstr "형식화"

#: src/SUMMARY.md:13 src/primitives.md:1
msgid "Primitives"
msgstr "기본 자료형"

#: src/SUMMARY.md:14 src/primitives/literals.md:1
msgid "Literals and operators"
msgstr "리터럴과 연산자"

#: src/SUMMARY.md:15 src/primitives/tuples.md:1
msgid "Tuples"
msgstr "튜플"

#: src/SUMMARY.md:16 src/primitives/array.md:1
msgid "Arrays and Slices"
msgstr "배열과 슬라이스"

#: src/SUMMARY.md:18 src/custom_types.md:1
msgid "Custom Types"
msgstr "사용자 정의 타입"

#: src/SUMMARY.md:19 src/custom_types/structs.md:1
msgid "Structures"
msgstr "구조체"

#: src/SUMMARY.md:20 src/custom_types/enum.md:1
msgid "Enums"
msgstr "열거형"

#: src/SUMMARY.md:21 src/custom_types/enum/enum_use.md:1
msgid "use"
msgstr "use"

#: src/SUMMARY.md:22 src/custom_types/enum/c_like.md:1
msgid "C-like"
msgstr "C-like"

#: src/SUMMARY.md:23 src/custom_types/enum/testcase_linked_list.md:1
msgid "Testcase: linked-list"
msgstr "테스트케이스: 연결 리스트"

#: src/SUMMARY.md:24 src/custom_types/constants.md:1
msgid "constants"
msgstr "상수"

#: src/SUMMARY.md:26 src/variable_bindings.md:1
msgid "Variable Bindings"
msgstr "변수 바인딩"

#: src/SUMMARY.md:27 src/SUMMARY.md:120 src/SUMMARY.md:123
#: src/variable_bindings/mut.md:1 src/scope/move/mut.md:1
#: src/scope/borrow/mut.md:1
msgid "Mutability"
msgstr "가변성"

#: src/SUMMARY.md:28 src/variable_bindings/scope.md:1
msgid "Scope and Shadowing"
msgstr "스코프와 섀도잉"

#: src/SUMMARY.md:29 src/variable_bindings/declare.md:1
msgid "Declare first"
msgstr "선언 우선"

#: src/SUMMARY.md:30 src/variable_bindings/freeze.md:1
msgid "Freezing"
msgstr "동결"

#: src/SUMMARY.md:32 src/types.md:1
msgid "Types"
msgstr "타입"

#: src/SUMMARY.md:33 src/types/cast.md:1
msgid "Casting"
msgstr "형변환"

#: src/SUMMARY.md:34 src/types/literals.md:1
msgid "Literals"
msgstr "리터럴"

#: src/SUMMARY.md:35 src/types/inference.md:1
msgid "Inference"
msgstr "추론"

#: src/SUMMARY.md:36 src/SUMMARY.md:124 src/types/alias.md:1
#: src/scope/borrow/alias.md:1
msgid "Aliasing"
msgstr "별칭"

#: src/SUMMARY.md:38 src/conversion.md:1
msgid "Conversion"
msgstr "타입 변환"

#: src/SUMMARY.md:39 src/conversion/from_into.md:1
msgid "`From` and `Into`"
msgstr "`From`과 `Into`"

#: src/SUMMARY.md:40 src/conversion/try_from_try_into.md:1
msgid "`TryFrom` and `TryInto`"
msgstr "`TryFrom`과 `TryInto`"

#: src/SUMMARY.md:41
msgid "To and from `String`s"
msgstr "`String` 변환"

#: src/SUMMARY.md:43 src/expression.md:1
msgid "Expressions"
msgstr "표현식"

#: src/SUMMARY.md:45 src/flow_control.md:1
msgid "Flow of Control"
msgstr "제어 흐름"

#: src/SUMMARY.md:46 src/flow_control/if_else.md:1
msgid "if/else"
msgstr "if/else"

#: src/SUMMARY.md:47 src/flow_control/loop.md:1
msgid "loop"
msgstr "loop"

#: src/SUMMARY.md:48 src/flow_control/loop/nested.md:1
msgid "Nesting and labels"
msgstr "중첩과 레이블"

#: src/SUMMARY.md:49 src/flow_control/loop/return.md:1
msgid "Returning from loops"
msgstr "반복문에서 리턴하기"

#: src/SUMMARY.md:50 src/flow_control/while.md:1
msgid "while"
msgstr "while"

#: src/SUMMARY.md:51 src/flow_control/for.md:3
msgid "for and range"
msgstr "for와 range"

#: src/SUMMARY.md:52 src/flow_control/match.md:1
msgid "match"
msgstr "match"

#: src/SUMMARY.md:53 src/flow_control/match/destructuring.md:1
msgid "Destructuring"
msgstr "구조 분해"

#: src/SUMMARY.md:54
#: src/flow_control/match/destructuring/destructure_tuple.md:1
msgid "tuples"
msgstr "튜플"

#: src/SUMMARY.md:55
#: src/flow_control/match/destructuring/destructure_slice.md:1
msgid "arrays/slices"
msgstr "배열/슬라이스"

#: src/SUMMARY.md:56 src/flow_control/match/destructuring/destructure_enum.md:1
msgid "enums"
msgstr "열거형"

#: src/SUMMARY.md:57
#: src/flow_control/match/destructuring/destructure_pointers.md:1
msgid "pointers/ref"
msgstr "포인터/ref"

#: src/SUMMARY.md:58
#: src/flow_control/match/destructuring/destructure_structures.md:1
msgid "structs"
msgstr "구조체"

#: src/SUMMARY.md:59 src/flow_control/match/guard.md:1
msgid "Guards"
msgstr "가드"

#: src/SUMMARY.md:60 src/flow_control/match/binding.md:1
msgid "Binding"
msgstr "바인딩"

#: src/SUMMARY.md:61 src/flow_control/if_let.md:1
msgid "if let"
msgstr "if let"

#: src/SUMMARY.md:62 src/flow_control/let_else.md:1
msgid "let-else"
msgstr "let-else"

#: src/SUMMARY.md:63 src/flow_control/while_let.md:1
msgid "while let"
msgstr "while let"

#: src/SUMMARY.md:65 src/SUMMARY.md:103 src/SUMMARY.md:128 src/fn.md:1
#: src/generics/gen_fn.md:1 src/scope/lifetime/fn.md:1
msgid "Functions"
msgstr "함수"

#: src/SUMMARY.md:66 src/SUMMARY.md:129 src/scope/lifetime/methods.md:1
msgid "Methods"
msgstr "메서드"

#: src/SUMMARY.md:67 src/fn/closures.md:1
msgid "Closures"
msgstr "클로저"

#: src/SUMMARY.md:68 src/fn/closures/capture.md:1
msgid "Capturing"
msgstr "캡처"

#: src/SUMMARY.md:69 src/fn/closures/input_parameters.md:1
msgid "As input parameters"
msgstr "입력 파라미터로 사용"

#: src/SUMMARY.md:70 src/fn/closures/anonymity.md:1
msgid "Type anonymity"
msgstr "타입 익명성"

#: src/SUMMARY.md:71 src/fn/closures/input_functions.md:1
msgid "Input functions"
msgstr "입력 함수"

#: src/SUMMARY.md:72 src/fn/closures/output_parameters.md:1
msgid "As output parameters"
msgstr "출력 파라미터로 사용"

#: src/SUMMARY.md:73 src/fn/closures/closure_examples.md:1
msgid "Examples in `std`"
msgstr "`std` 예제"

#: src/SUMMARY.md:74 src/fn/closures/closure_examples/iter_any.md:1
msgid "Iterator::any"
msgstr "Iterator::any"

#: src/SUMMARY.md:75 src/fn/closures/closure_examples/iter_find.md:1
msgid "Searching through iterators"
msgstr "이터레이터 검색"

#: src/SUMMARY.md:76 src/fn/hof.md:1
msgid "Higher Order Functions"
msgstr "고차 함수"

#: src/SUMMARY.md:77 src/fn/diverging.md:1
msgid "Diverging functions"
msgstr "발산 함수"

#: src/SUMMARY.md:79 src/mod.md:1
msgid "Modules"
msgstr "모듈"

#: src/SUMMARY.md:80 src/mod/visibility.md:1
msgid "Visibility"
msgstr "가시성"

#: src/SUMMARY.md:81 src/mod/struct_visibility.md:1
msgid "Struct visibility"
msgstr "구조체 가시성"

#: src/SUMMARY.md:82 src/mod/use.md:1
msgid "The `use` declaration"
msgstr "`use` 선언"

#: src/SUMMARY.md:83 src/mod/super.md:1
msgid "`super` and `self`"
msgstr "`super`와 `self`"

#: src/SUMMARY.md:84 src/mod/split.md:1
msgid "File hierarchy"
msgstr "파일 계층 구조"

#: src/SUMMARY.md:86 src/SUMMARY.md:98 src/crates.md:1 src/attribute/crate.md:1
#: src/std_misc/arg.md:30
msgid "Crates"
msgstr "크레이트"

#: src/SUMMARY.md:87 src/crates/lib.md:1
msgid "Creating a Library"
msgstr "라이브러리 생성"

#: src/SUMMARY.md:88 src/crates/using_lib.md:1
msgid "Using a Library"
msgstr "라이브러리 사용"

#: src/SUMMARY.md:90 src/cargo.md:1
msgid "Cargo"
msgstr "카고"

#: src/SUMMARY.md:91 src/cargo/deps.md:1
msgid "Dependencies"
msgstr "의존성"

#: src/SUMMARY.md:92 src/cargo/conventions.md:1
msgid "Conventions"
msgstr "관례"

#: src/SUMMARY.md:93
msgid "Tests"
msgstr "테스트"

#: src/SUMMARY.md:94 src/cargo/build_scripts.md:1
msgid "Build Scripts"
msgstr "빌드 스크립트"

#: src/SUMMARY.md:96 src/attribute.md:1
msgid "Attributes"
msgstr "속성"

#: src/SUMMARY.md:97 src/attribute/unused.md:1
msgid "`dead_code`"
msgstr "`dead_code`"

#: src/SUMMARY.md:99 src/attribute/cfg.md:1
msgid "`cfg`"
msgstr "`cfg`"

#: src/SUMMARY.md:100 src/attribute/cfg/custom.md:1
msgid "Custom"
msgstr "사용자 정의"

#: src/SUMMARY.md:102 src/generics.md:1
msgid "Generics"
msgstr "제네릭"

#: src/SUMMARY.md:104 src/generics/impl.md:1
msgid "Implementation"
msgstr "구현"

#: src/SUMMARY.md:105 src/SUMMARY.md:131 src/SUMMARY.md:137
#: src/generics/gen_trait.md:1 src/scope/lifetime/trait.md:1 src/trait.md:1
msgid "Traits"
msgstr "트레이트"

#: src/SUMMARY.md:106 src/SUMMARY.md:132 src/generics/bounds.md:1
#: src/scope/lifetime/lifetime_bounds.md:1
msgid "Bounds"
msgstr "바운드"

#: src/SUMMARY.md:107 src/generics/bounds/testcase_empty.md:1
msgid "Testcase: empty bounds"
msgstr "테스트케이스: 빈 바운드"

#: src/SUMMARY.md:108 src/generics/multi_bounds.md:1
msgid "Multiple bounds"
msgstr "다중 바운드"

#: src/SUMMARY.md:109 src/generics/where.md:1
msgid "Where clauses"
msgstr "Where 절"

#: src/SUMMARY.md:110 src/generics/new_types.md:1
msgid "New Type Idiom"
msgstr "New Type 관용구"

#: src/SUMMARY.md:111 src/generics/assoc_items.md:1
msgid "Associated items"
msgstr "연관 아이템"

#: src/SUMMARY.md:112 src/generics/assoc_items/the_problem.md:1
msgid "The Problem"
msgstr "문제점"

#: src/SUMMARY.md:113 src/generics/assoc_items/types.md:1
msgid "Associated types"
msgstr "연관 타입"

#: src/SUMMARY.md:114 src/generics/phantom.md:1
msgid "Phantom type parameters"
msgstr "팬텀 타입 파라미터"

#: src/SUMMARY.md:115 src/generics/phantom/testcase_units.md:1
msgid "Testcase: unit clarification"
msgstr "테스트케이스: 단위 명확화"

#: src/SUMMARY.md:117 src/scope.md:1
msgid "Scoping rules"
msgstr "스코프 규칙"

#: src/SUMMARY.md:118 src/scope/raii.md:1
msgid "RAII"
msgstr "RAII"

#: src/SUMMARY.md:119 src/scope/move.md:1
msgid "Ownership and moves"
msgstr "소유권과 이동"

#: src/SUMMARY.md:121 src/scope/move/partial_move.md:1
msgid "Partial moves"
msgstr "부분 이동"

#: src/SUMMARY.md:122 src/scope/borrow.md:1
msgid "Borrowing"
msgstr "빌림"

#: src/SUMMARY.md:125 src/scope/borrow/ref.md:1
msgid "The ref pattern"
msgstr "ref 패턴"

#: src/SUMMARY.md:126 src/scope/lifetime.md:1
msgid "Lifetimes"
msgstr "라이프타임"

#: src/SUMMARY.md:127 src/scope/lifetime/explicit.md:1
msgid "Explicit annotation"
msgstr "명시적 어노테이션"

#: src/SUMMARY.md:130 src/scope/lifetime/struct.md:1
msgid "Structs"
msgstr "구조체"

#: src/SUMMARY.md:133 src/scope/lifetime/lifetime_coercion.md:1
msgid "Coercion"
msgstr "강제"

#: src/SUMMARY.md:134 src/scope/lifetime/static_lifetime.md:1
msgid "Static"
msgstr "Static"

#: src/SUMMARY.md:135 src/scope/lifetime/elision.md:1
msgid "Elision"
msgstr "생략"

#: src/SUMMARY.md:138 src/trait/derive.md:1
msgid "Derive"
msgstr "Derive"

#: src/SUMMARY.md:139 src/trait/dyn.md:1
msgid "Returning Traits with `dyn`"
msgstr "`dyn`으로 트레이트 반환하기"

#: src/SUMMARY.md:140 src/trait/ops.md:1
msgid "Operator Overloading"
msgstr "연산자 오버로딩"

#: src/SUMMARY.md:141 src/trait/drop.md:1
msgid "Drop"
msgstr "Drop"

#: src/SUMMARY.md:142 src/trait/iter.md:1
msgid "Iterators"
msgstr "이터레이터"

#: src/SUMMARY.md:143 src/trait/impl_trait.md:1
msgid "`impl Trait`"
msgstr "`impl Trait`"

#: src/SUMMARY.md:144 src/trait/clone.md:1
msgid "Clone"
msgstr "Clone"

#: src/SUMMARY.md:145 src/trait/supertraits.md:1
msgid "Supertraits"
msgstr "슈퍼트레이트"

#: src/SUMMARY.md:146 src/trait/disambiguating.md:1
msgid "Disambiguating overlapping traits"
msgstr "중복 트레이트 명확화"

#: src/SUMMARY.md:148
msgid "macro_rules!"
msgstr "macro_rules!"

#: src/SUMMARY.md:149 src/macros/syntax.md:1
msgid "Syntax"
msgstr "문법"

#: src/SUMMARY.md:150 src/macros/designators.md:1
msgid "Designators"
msgstr "지시자"

#: src/SUMMARY.md:151 src/macros/overload.md:1
msgid "Overload"
msgstr "오버로드"

#: src/SUMMARY.md:152 src/macros/repeat.md:1
msgid "Repeat"
msgstr "반복"

#: src/SUMMARY.md:153 src/macros/dry.md:1
msgid "DRY (Don't Repeat Yourself)"
msgstr "DRY (반복하지 말라)"

#: src/SUMMARY.md:154
msgid "DSL (Domain Specific Languages)"
msgstr "DSL (도메인 특화 언어)"

#: src/SUMMARY.md:155
msgid "Variadics"
msgstr "가변 인자"

#: src/SUMMARY.md:157 src/error.md:1
msgid "Error handling"
msgstr "에러 핸들링"

#: src/SUMMARY.md:158 src/error/panic.md:1
msgid "`panic`"
msgstr "`panic`"

#: src/SUMMARY.md:159
msgid "`abort` & `unwind`"
msgstr "`abort`와 `unwind`"

#: src/SUMMARY.md:160 src/error/option_unwrap.md:1
msgid "`Option` & `unwrap`"
msgstr "`Option`과 `unwrap`"

#: src/SUMMARY.md:161 src/error/option_unwrap/question_mark.md:1
msgid "Unpacking options with `?`"
msgstr "`?`로 옵션 풀기"

#: src/SUMMARY.md:162 src/error/option_unwrap/map.md:1
msgid "Combinators: `map`"
msgstr "콤비네이터: `map`"

#: src/SUMMARY.md:163 src/error/option_unwrap/and_then.md:1
msgid "Combinators: `and_then`"
msgstr "콤비네이터: `and_then`"

#: src/SUMMARY.md:164
msgid "Defaults: `or`, `or_else`, `get_or_insert`, `get_or_insert_with`"
msgstr "기본값: `or`, `or_else`, `get_or_insert`, `get_or_insert_with`"

#: src/SUMMARY.md:165 src/SUMMARY.md:183 src/error/result.md:1
#: src/std/result.md:1
msgid "`Result`"
msgstr "`Result`"

#: src/SUMMARY.md:166 src/error/result/result_map.md:1
msgid "`map` for `Result`"
msgstr "`Result`에서의 `map`"

#: src/SUMMARY.md:167 src/error/result/result_alias.md:1
msgid "aliases for `Result`"
msgstr "`Result`의 별칭"

#: src/SUMMARY.md:168 src/error/result/early_returns.md:1
msgid "Early returns"
msgstr "조기 리턴"

#: src/SUMMARY.md:169 src/error/result/enter_question_mark.md:1
msgid "Introducing `?`"
msgstr "`?` 소개"

#: src/SUMMARY.md:170 src/error/multiple_error_types.md:1
msgid "Multiple error types"
msgstr "여러 에러 타입"

#: src/SUMMARY.md:171 src/error/multiple_error_types/option_result.md:1
msgid "Pulling `Result`s out of `Option`s"
msgstr "`Option`에서 `Result` 꺼내기"

#: src/SUMMARY.md:172 src/error/multiple_error_types/define_error_type.md:1
msgid "Defining an error type"
msgstr "에러 타입 정의하기"

#: src/SUMMARY.md:173 src/error/multiple_error_types/boxing_errors.md:1
msgid "`Box`ing errors"
msgstr "에러 `Box`하기"

#: src/SUMMARY.md:174 src/error/multiple_error_types/reenter_question_mark.md:1
msgid "Other uses of `?`"
msgstr "`?`의 다른 용도"

#: src/SUMMARY.md:175 src/error/multiple_error_types/wrap_error.md:1
msgid "Wrapping errors"
msgstr "에러 감싸기"

#: src/SUMMARY.md:176 src/error/iter_result.md:1
msgid "Iterating over `Result`s"
msgstr "`Result` 반복하기"

#: src/SUMMARY.md:178 src/std.md:1
msgid "Std library types"
msgstr "표준 라이브러리 타입"

#: src/SUMMARY.md:179 src/std/box.md:1
msgid "Box, stack and heap"
msgstr "Box, 스택과 힙"

#: src/SUMMARY.md:180 src/std/vec.md:1
msgid "Vectors"
msgstr "벡터"

#: src/SUMMARY.md:181 src/std/str.md:1
msgid "Strings"
msgstr "문자열"

#: src/SUMMARY.md:182 src/std/option.md:1
msgid "`Option`"
msgstr "`Option`"

#: src/SUMMARY.md:184 src/std/result/question_mark.md:1
msgid "`?`"
msgstr "`?`"

#: src/SUMMARY.md:185 src/std/panic.md:1
msgid "`panic!`"
msgstr "`panic!`"

#: src/SUMMARY.md:186 src/std/hash.md:1
msgid "HashMap"
msgstr "해시맵"

#: src/SUMMARY.md:187 src/std/hash/alt_key_types.md:1
msgid "Alternate/custom key types"
msgstr "대체/사용자 정의 키 타입"

#: src/SUMMARY.md:188 src/std/hash/hashset.md:1
msgid "HashSet"
msgstr "해시셋"

#: src/SUMMARY.md:189 src/std/rc.md:1
msgid "`Rc`"
msgstr "`Rc`"

#: src/SUMMARY.md:190
msgid "`Arc`"
msgstr "`Arc`"

#: src/SUMMARY.md:192 src/std_misc.md:1
msgid "Std misc"
msgstr "기타 표준 라이브러리"

#: src/SUMMARY.md:193 src/std_misc.md:6 src/std_misc/threads.md:1
msgid "Threads"
msgstr "스레드"

#: src/SUMMARY.md:194 src/std_misc/threads/testcase_mapreduce.md:1
msgid "Testcase: map-reduce"
msgstr "테스트케이스: 맵-리듀스"

#: src/SUMMARY.md:195 src/std_misc.md:7 src/std_misc/channels.md:1
msgid "Channels"
msgstr "채널"

#: src/SUMMARY.md:196 src/std_misc/path.md:1
msgid "Path"
msgstr "경로"

#: src/SUMMARY.md:197 src/std_misc.md:8 src/std_misc/file.md:1
msgid "File I/O"
msgstr "파일 입출력"

#: src/SUMMARY.md:198 src/std_misc/file/open.md:1
msgid "`open`"
msgstr "`open`"

#: src/SUMMARY.md:199 src/std_misc/file/create.md:1
msgid "`create`"
msgstr "`create`"

#: src/SUMMARY.md:200 src/std_misc/file/read_lines.md:1
msgid "`read_lines`"
msgstr "`read_lines`"

#: src/SUMMARY.md:201 src/std_misc/process.md:1
msgid "Child processes"
msgstr "자식 프로세스"

#: src/SUMMARY.md:202 src/std_misc/process/pipe.md:1
msgid "Pipes"
msgstr "파이프"

#: src/SUMMARY.md:203 src/std_misc/process/wait.md:1
msgid "Wait"
msgstr "대기"

#: src/SUMMARY.md:204 src/std_misc/fs.md:1
msgid "Filesystem Operations"
msgstr "파일시스템 연산"

#: src/SUMMARY.md:205 src/std_misc/arg.md:1
msgid "Program arguments"
msgstr "프로그램 인자"

#: src/SUMMARY.md:206 src/std_misc/arg/matching.md:1
msgid "Argument parsing"
msgstr "인자 파싱"

#: src/SUMMARY.md:207 src/std_misc/ffi.md:1
msgid "Foreign Function Interface"
msgstr "외부 함수 인터페이스"

#: src/SUMMARY.md:209 src/cargo/test.md:1 src/testing.md:1
msgid "Testing"
msgstr "테스트"

#: src/SUMMARY.md:210 src/testing/unit_testing.md:1
msgid "Unit testing"
msgstr "유닛 테스트"

#: src/SUMMARY.md:211 src/testing/doc_testing.md:1
msgid "Documentation testing"
msgstr "문서 테스트"

#: src/SUMMARY.md:212 src/testing/integration_testing.md:1
msgid "Integration testing"
msgstr "통합 테스트"

#: src/SUMMARY.md:213
msgid "Dev-dependencies"
msgstr "개발 의존성"

#: src/SUMMARY.md:215 src/unsafe.md:1
msgid "Unsafe Operations"
msgstr "Unsafe 연산"

#: src/SUMMARY.md:216 src/unsafe/asm.md:1
msgid "Inline assembly"
msgstr "인라인 어셈블리"

#: src/SUMMARY.md:218 src/compatibility.md:1
msgid "Compatibility"
msgstr "호환성"

#: src/SUMMARY.md:219 src/compatibility/raw_identifiers.md:1
msgid "Raw identifiers"
msgstr "Raw 식별자"

#: src/SUMMARY.md:221 src/meta.md:1
msgid "Meta"
msgstr "메타"

#: src/SUMMARY.md:222 src/meta/doc.md:1
msgid "Documentation"
msgstr "문서화"

#: src/SUMMARY.md:223 src/meta/playground.md:1
msgid "Playground"
msgstr "플레이그라운드"

#: src/index.md:1
msgid "Rust by Example"
msgstr "Rust by Example"

#: src/index.md:3
msgid ""
"[Rust](https://www.rust-lang.org/) is a modern systems programming language "
"focusing on safety, speed, and concurrency. It accomplishes these goals by "
"being memory safe without using garbage collection."
msgstr ""
"[Rust](https://www.rust-lang.org/)는 안전성, 속도, 동시성에 중점을 둔 현대적"
"인 시스템 프로그래밍 언어입니다. 가비지 컬렉션을 사용하지 않고도 메모리 안전"
"성을 확보하여 이러한 목표를 달성합니다."

#: src/index.md:7
msgid ""
"Rust by Example (RBE) is a collection of runnable examples that illustrate "
"various Rust concepts and standard libraries. To get even more out of these "
"examples, don't forget to [install Rust locally](https://www.rust-lang.org/"
"tools/install) and check out the [official docs](https://doc.rust-lang.org/"
"std/). Additionally for the curious, you can also [check out the source code "
"for this site](https://github.com/rust-lang/rust-by-example)."
msgstr ""
"Rust by Example (RBE)는 다양한 Rust 개념과 표준 라이브러리를 보여주는 실행 가"
"능한 예제 모음입니다. 이러한 예제를 더 잘 활용하려면 [Rust를 로컬에 설치]"
"(https://www.rust-lang.org/tools/install)하고 [공식 문서](https://doc.rust-"
"lang.org/std/)를 확인해 보세요. 또한 궁금하신 분들은 [이 사이트의 소스 코드]"
"(https://github.com/rust-lang/rust-by-example)도 확인하실 수 있습니다."

#: src/index.md:12
msgid "Now let's begin!"
msgstr "자, 이제 시작해 봅시다!"

#: src/index.md:14
msgid "[Hello World](hello.md) - Start with a traditional Hello World program."
msgstr ""
"[Hello World](hello.md) - 전통적인 Hello World 프로그램으로 시작합니다."

#: src/index.md:16
msgid ""
"[Primitives](primitives.md) - Learn about signed integers, unsigned integers "
"and other primitives."
msgstr ""
"[기본 자료형](primitives.md) - 부호 있는 정수, 부호 없는 정수 및 기타 기본 자"
"료형에 대해 배웁니다."

#: src/index.md:18
msgid "[Custom Types](custom_types.md) - `struct` and `enum`."
msgstr "[사용자 정의 타입](custom_types.md) - `struct`와 `enum`."

#: src/index.md:20
msgid ""
"[Variable Bindings](variable_bindings.md) - mutable bindings, scope, "
"shadowing."
msgstr "[변수 바인딩](variable_bindings.md) - 가변 바인딩, 스코프, 섀도잉."

#: src/index.md:22
msgid "[Types](types.md) - Learn about changing and defining types."
msgstr "[타입](types.md) - 타입을 변경하고 정의하는 법을 배웁니다."

#: src/index.md:24
msgid ""
"[Conversion](conversion.md) - Convert between different types, such as "
"strings, integers, and floats."
msgstr ""
"[타입 변환](conversion.md) - 문자열, 정수, 부동 소수점 등 서로 다른 타입 간"
"의 변환에 대해 배웁니다."

#: src/index.md:26
msgid ""
"[Expressions](expression.md) - Learn about Expressions & how to use them."
msgstr "[표현식](expression.md) - 표현식과 그 사용법에 대해 배웁니다."

#: src/index.md:28
msgid "[Flow of Control](flow_control.md) - `if`/`else`, `for`, and others."
msgstr "[제어 흐름](flow_control.md) - `if`/`else`, `for` 등을 배웁니다."

#: src/index.md:30
msgid ""
"[Functions](fn.md) - Learn about Methods, Closures and Higher Order "
"Functions."
msgstr "[함수](fn.md) - 메서드, 클로저, 고차 함수에 대해 배웁니다."

#: src/index.md:32
msgid "[Modules](mod.md) - Organize code using modules"
msgstr "[모듈](mod.md) - 모듈을 사용하여 코드를 구성합니다."

#: src/index.md:34
msgid ""
"[Crates](crates.md) - A crate is a compilation unit in Rust. Learn to create "
"a library."
msgstr ""
"[크레이트](crates.md) - 크레이트는 Rust의 컴파일 단위입니다. 라이브러리를 만"
"드는 법을 배웁니다."

#: src/index.md:36
msgid ""
"[Cargo](cargo.md) - Go through some basic features of the official Rust "
"package management tool."
msgstr ""
"[Cargo](cargo.md) - Rust 공식 패키지 관리 도구의 기본적인 기능을 살펴봅니다."

#: src/index.md:38
msgid ""
"[Attributes](attribute.md) - An attribute is metadata applied to some "
"module, crate or item."
msgstr ""
"[속성](attribute.md) - 속성은 모듈, 크레이트 또는 아이템에 적용되는 메타데이"
"터입니다."

#: src/index.md:40
msgid ""
"[Generics](generics.md) - Learn about writing a function or data type which "
"can work for multiple types of arguments."
msgstr ""
"[제네릭](generics.md) - 다양한 타입의 인자에 대해 작동할 수 있는 함수나 데이"
"터 타입을 작성하는 법을 배웁니다."

#: src/index.md:42
msgid ""
"[Scoping rules](scope.md) - Scopes play an important part in ownership, "
"borrowing, and lifetimes."
msgstr ""
"[스코프 규칙](scope.md) - 스코프는 소유권, 빌림, 라이프타임에서 중요한 역할"
"을 합니다."

#: src/index.md:44
msgid ""
"[Traits](trait.md) - A trait is a collection of methods defined for an "
"unknown type: `Self`"
msgstr ""
"[트레이트](trait.md) - 트레이트는 알 수 없는 타입 `Self`에 대해 정의된 메서"
"드 모음입니다."

#: src/index.md:46
msgid ""
"[Macros](macros.md) - Macros are a way of writing code that writes other "
"code, which is known as metaprogramming."
msgstr ""
"[매크로](macros.md) - 매크로는 다른 코드를 작성하는 코드를 작성하는 방법으"
"로, 메타프로그래밍이라고도 합니다."

#: src/index.md:48
msgid "[Error handling](error.md) - Learn Rust way of handling failures."
msgstr "[에러 핸들링](error.md) - 실패를 처리하는 Rust의 방식을 배웁니다."

#: src/index.md:50
msgid ""
"[Std library types](std.md) - Learn about some custom types provided by "
"`std` library."
msgstr ""
"[표준 라이브러리 타입](std.md) - `std` 라이브러리에서 제공하는 몇 가지 사용"
"자 정의 타입에 대해 배웁니다."

#: src/index.md:52
msgid "[Std misc](std_misc.md) - More custom types for file handling, threads."
msgstr ""
"[기타 표준 라이브러리](std_misc.md) - 파일 처리, 스레드 등을 위한 추가적인 사"
"용자 정의 타입을 배웁니다."

#: src/index.md:54
msgid "[Testing](testing.md) - All sorts of testing in Rust."
msgstr "[테스트](testing.md) - Rust에서의 다양한 테스트 방식을 배웁니다."

#: src/index.md:56
msgid ""
"[Unsafe Operations](unsafe.md) - Learn about entering a block of unsafe "
"operations."
msgstr "[Unsafe 연산](unsafe.md) - Unsafe 연산 블록에 진입하는 법을 배웁니다."

#: src/index.md:58
msgid ""
"[Compatibility](compatibility.md) - Handling Rust's evolution and potential "
"compatibility issues."
msgstr ""
"[호환성](compatibility.md) - Rust의 발전과 잠재적인 호환성 문제를 처리하는 법"
"을 배웁니다."

#: src/index.md:60
msgid "[Meta](meta.md) - Documentation, Benchmarking."
msgstr "[메타](meta.md) - 문서화, 벤치마킹."

#: src/hello.md:3
msgid "This is the source code of the traditional Hello World program."
msgstr "전통적인 Hello World 프로그램의 소스 코드입니다."

#: src/hello.md:6
msgid ""
"// This is a comment, and is ignored by the compiler.\n"
"// You can test this code by clicking the \"Run\" button over there ->\n"
"// or if you prefer to use your keyboard, you can use the \"Ctrl + Enter\"\n"
"// shortcut.\n"
msgstr ""
"// 이것은 주석이며, 컴파일러에 의해 무시됩니다.\n"
"// 오른쪽에 있는 \"Run\" 버튼을 클릭하거나,\n"
"// 키보드를 사용하고 싶다면 \"Ctrl + Enter\" 단축키를 사용하여\n"
"// 이 코드를 테스트해 볼 수 있습니다.\n"

#: src/hello.md:10
msgid ""
"// This code is editable, feel free to hack it!\n"
"// You can always return to the original code by clicking the \"Reset\" "
"button ->\n"
msgstr ""
"// 이 코드는 수정 가능하므로, 자유롭게 고쳐보세요!\n"
"// \"Reset\" 버튼을 클릭하면 언제든지 원래 코드로 되돌릴 수 있습니다 ->\n"

#: src/hello.md:13
msgid "// This is the main function.\n"
msgstr "// 메인 함수입니다.\n"

#: src/hello.md:16
msgid "// Statements here are executed when the compiled binary is called.\n"
msgstr "// 여기에 있는 문장들은 컴파일된 바이너리가 호출될 때 실행됩니다.\n"

#: src/hello.md:18
msgid "// Print text to the console.\n"
msgstr "// 콘솔에 텍스트를 출력합니다.\n"

#: src/hello.md:19 src/error/result.md:55 src/meta/playground.md:12
msgid "\"Hello World!\""
msgstr "\"Hello World!\""

#: src/hello.md:23
msgid "`println!` is a [_macro_](macros.md) that prints text to the console."
msgstr "`println!`은 콘솔에 텍스트를 출력하는 [_매크로_](macros.md)입니다."

#: src/hello.md:26
msgid "A binary can be generated using the Rust compiler: `rustc`."
msgstr "Rust 컴파일러인 `rustc`를 사용하여 바이너리를 생성할 수 있습니다."

#: src/hello.md:32
msgid "`rustc` will produce a `hello` binary that can be executed."
msgstr "`rustc`는 실행 가능한 `hello` 바이너리를 생성합니다."

#: src/hello.md:39 src/hello/print/print_display.md:107
#: src/hello/print/print_display/testcase_list.md:53 src/hello/print/fmt.md:70
#: src/primitives/tuples.md:64 src/custom_types/structs.md:89
msgid "Activity"
msgstr "실습"

#: src/hello.md:41
msgid ""
"Click 'Run' above to see the expected output. Next, add a new line with a "
"second `println!` macro so that the output shows:"
msgstr ""
"위의 'Run'을 클릭하여 예상 출력을 확인하세요. 그런 다음, 두 번째 `println!` "
"매크로를 사용하여 다음과 같은 출력이 나오도록 새로운 라인을 추가하세요."

#: src/hello/comment.md:3
msgid ""
"Any program requires comments, and Rust supports a few different varieties:"
msgstr ""
"어떤 프로그램이든 주석이 필요하며, Rust는 몇 가지 다른 종류를 지원합니다."

#: src/hello/comment.md:6
msgid "Regular Comments"
msgstr "일반 주석"

#: src/hello/comment.md:8
msgid "These are ignored by the compiler:"
msgstr "이것들은 컴파일러에 의해 무시됩니다:"

#: src/hello/comment.md:10
msgid "**Line comments**: Start with `//` and continue to the end of the line"
msgstr "**라인 주석**: `//`로 시작하여 줄의 끝까지 이어집니다."

#: src/hello/comment.md:11
msgid "**Block comments**: Enclosed in `/* ... */` and can span multiple lines"
msgstr "**블록 주석**: `/* ... */`로 감싸여 여러 줄에 걸쳐 있을 수 있습니다."

#: src/hello/comment.md:13
msgid ""
"Documentation Comments (Doc Comments) which are parsed into HTML library "
"[documentation](../meta/doc.md):"
msgstr ""
"HTML 라이브러리 [문서](../meta/doc.md)로 파싱되는 문서화 주석 (Doc Comments):"

#: src/hello/comment.md:15
msgid "`///` - Generates docs for the item that follows it"
msgstr "`///` - 다음에 오는 아이템에 대한 문서를 생성합니다."

#: src/hello/comment.md:16
msgid ""
"`//!` - Generates docs for the enclosing item (typically used at the top of "
"a file or module)"
msgstr ""
"`//!` - 해당 아이템을 포함하는 아이템(주로 파일이나 모듈의 상단에서 사용됨)"
"에 대한 문서를 생성합니다."

#: src/hello/comment.md:20
msgid ""
"// Line comments start with two slashes.\n"
"    // Everything after the slashes is ignored by the compiler.\n"
msgstr ""
"// 라인 주석은 두 개의 슬래시로 시작합니다.\n"
"    // 슬래시 이후의 모든 내용은 컴파일러에 의해 무시됩니다.\n"

#: src/hello/comment.md:23
msgid ""
"// Example: This line won't execute\n"
"    // println!(\"Hello, world!\");\n"
msgstr ""
"// 예시: 이 줄은 실행되지 않습니다\n"
"    // println!(\"Hello, world!\");\n"

#: src/hello/comment.md:26
msgid "// Try removing the slashes above and running the code again.\n"
msgstr "// 위의 슬래시를 제거하고 코드를 다시 실행해 보세요.\n"

#: src/hello/comment.md:28
msgid ""
"/*\n"
"     * Block comments are useful for temporarily disabling code.\n"
"     * They can also be nested: /* like this */ which makes it easy\n"
"     * to comment out large sections quickly.\n"
"     */"
msgstr ""
"/*\n"
"     * 블록 주석은 코드를 일시적으로 비활성화하는 데 유용합니다.\n"
"     * 블록 주석은 중첩될 수도 있습니다: /* 이와 같이 */ 중첩이 가능하여\n"
"     * 큰 섹션을 빠르게 주석 처리하기 쉽습니다.\n"
"     */"

#: src/hello/comment.md:34
msgid ""
"/*\n"
"    Note: The asterisk column on the left is just for style - \n"
"    it's not required by the language.\n"
"    */"
msgstr ""
"/*\n"
"    참고: 왼쪽의 별표 기둥은 단지 스타일을 위한 것입니다 - \n"
"    언어적으로 요구되는 사항은 아닙니다.\n"
"    */"

#: src/hello/comment.md:39
msgid ""
"// Block comments make it easy to toggle code on/off by adding\n"
"    // or removing just one slash:\n"
msgstr ""
"// 블록 주석은 슬래시 하나를 추가하거나 제거하여\n"
"    // 코드를 켜고 끄기 쉽게 만들어 줍니다:\n"

#: src/hello/comment.md:42
msgid ""
"/* <- Add a '/' here to uncomment the entire block below\n"
"\n"
"    println!(\"Now\");\n"
"    println!(\"everything\");\n"
"    println!(\"executes!\");\n"
"    // Line comments inside remain unaffected\n"
"\n"
"    // */"
msgstr ""
"/* <- 여기에 '/'를 추가하면 아래 블록 전체의 주석이 해제됩니다\n"
"\n"
"    println!(\"이제\");\n"
"    println!(\"모든 것이\");\n"
"    println!(\"실행됩니다!\");\n"
"    // 내부의 라인 주석은 영향을 받지 않습니다\n"
"\n"
"    // */"

#: src/hello/comment.md:51
msgid "// Block comments can also be used within expressions:\n"
msgstr "// 블록 주석은 표현식 내에서도 사용될 수 있습니다:\n"

#: src/hello/comment.md:52
msgid "/* 90 + */"
msgstr "/* 90 + */"

#: src/hello/comment.md:53
msgid "\"Is `x` 10 or 100? x = {}\""
msgstr "\"`x`는 10인가요 100인가요? x = {}\""

#: src/hello/comment.md:57 src/hello/print.md:103
#: src/hello/print/print_debug.md:75 src/hello/print/print_display.md:128
#: src/hello/print/print_display/testcase_list.md:62 src/hello/print/fmt.md:94
#: src/primitives.md:64 src/custom_types/enum.md:100
#: src/custom_types/enum/enum_use.md:45 src/custom_types/enum/c_like.md:33
#: src/custom_types/enum/testcase_linked_list.md:78
#: src/custom_types/constants.md:35 src/types/alias.md:30
#: src/flow_control/for.md:121 src/flow_control/match/destructuring.md:17
#: src/flow_control/match/destructuring/destructure_tuple.md:25
#: src/flow_control/match/destructuring/destructure_slice.md:46
#: src/flow_control/match/destructuring/destructure_enum.md:48
#: src/flow_control/match/destructuring/destructure_pointers.md:63
#: src/flow_control/match/destructuring/destructure_structures.md:45
#: src/flow_control/match/guard.md:43 src/flow_control/match/binding.md:63
#: src/flow_control/if_let.md:118 src/flow_control/let_else.md:55
#: src/flow_control/while_let.md:56 src/fn/closures/capture.md:110
#: src/fn/closures/input_parameters.md:84 src/fn/closures/anonymity.md:47
#: src/fn/closures/input_functions.md:32
#: src/fn/closures/output_parameters.md:49
#: src/fn/closures/closure_examples/iter_any.md:51
#: src/fn/closures/closure_examples/iter_find.md:71
#: src/mod/struct_visibility.md:53 src/attribute/cfg.md:39 src/generics.md:59
#: src/generics/gen_fn.md:54 src/generics/impl.md:48
#: src/generics/gen_trait.md:39 src/generics/bounds.md:73
#: src/generics/bounds/testcase_empty.md:37 src/generics/multi_bounds.md:32
#: src/generics/where.md:49 src/generics/new_types.md:54
#: src/generics/assoc_items.md:10 src/generics/assoc_items/the_problem.md:62
#: src/generics/phantom.md:56 src/generics/phantom/testcase_units.md:75
#: src/scope/raii.md:92 src/scope/move/partial_move.md:57
#: src/scope/borrow/mut.md:56 src/scope/lifetime/explicit.md:68
#: src/scope/lifetime/fn.md:58 src/scope/lifetime/methods.md:24
#: src/scope/lifetime/struct.md:41 src/scope/lifetime/trait.md:28
#: src/scope/lifetime/lifetime_bounds.md:46
#: src/scope/lifetime/static_lifetime.md:133 src/scope/lifetime/elision.md:39
#: src/trait/derive.md:65 src/trait/supertraits.md:40
#: src/trait/disambiguating.md:60 src/error/option_unwrap/map.md:79
#: src/error/option_unwrap/and_then.md:73
#: src/error/option_unwrap/defaults.md:115 src/error/result/result_alias.md:41
#: src/error/multiple_error_types/boxing_errors.md:57
#: src/error/multiple_error_types/reenter_question_mark.md:74
#: src/error/multiple_error_types/wrap_error.md:91 src/std.md:12
#: src/std/rc.md:55 src/std_misc.md:12
#: src/std_misc/threads/testcase_mapreduce.md:127 src/std_misc/path.md:52
#: src/std_misc/fs.md:149 src/meta/doc.md:109 src/meta/playground.md:49
msgid "See also:"
msgstr "참고:"

#: src/hello/comment.md:59
msgid "[Library documentation](../meta/doc.md)"
msgstr "[라이브러리 문서](../meta/doc.md)"

#: src/hello/print.md:3
msgid ""
"Printing is handled by a series of [`macros`](../macros.md) defined in "
"[`std::fmt`](https://doc.rust-lang.org/std/fmt/) some of which are:"
msgstr ""
"출력은 [`std::fmt`](https://doc.rust-lang.org/std/fmt/)에 정의된 일련의 [`매"
"크로`](../macros.md)들에 의해 처리되며, 그 중 몇 가지는 다음과 같습니다:"

#: src/hello/print.md:6
msgid "`format!`: write formatted text to [`String`](../std/str.md)"
msgstr "`format!`: 형식화된 텍스트를 [`String`](../std/str.md)에 씁니다."

#: src/hello/print.md:7
msgid ""
"`print!`: same as `format!` but the text is printed to the console "
"(io::stdout)."
msgstr "`print!`: `format!`과 같지만 텍스트가 콘솔(io::stdout)에 출력됩니다."

#: src/hello/print.md:9
msgid "`println!`: same as `print!` but a newline is appended."
msgstr "`println!`: `print!`와 같지만 줄바꿈 문자가 추가됩니다."

#: src/hello/print.md:10
msgid ""
"`eprint!`: same as `print!` but the text is printed to the standard error "
"(io::stderr)."
msgstr ""
"`eprint!`: `print!`와 같지만 텍스트가 표준 에러(io::stderr)로 출력됩니다."

#: src/hello/print.md:12
msgid "`eprintln!`: same as `eprint!` but a newline is appended."
msgstr "`eprintln!`: `eprint!`와 같지만 줄바꿈 문자가 추가됩니다."

#: src/hello/print.md:14
msgid ""
"All parse text in the same fashion. As a plus, Rust checks formatting "
"correctness at compile time."
msgstr ""
"모두 같은 방식으로 텍스트를 파싱합니다. 추가로, Rust는 컴파일 타임에 형식화"
"의 올바름을 검사합니다."

#: src/hello/print.md:19
msgid ""
"// In general, the `{}` will be automatically replaced with any\n"
"    // arguments. These will be stringified.\n"
msgstr ""
"// 일반적으로 `{}`는 어떤 인자로든 자동으로 교체됩니다.\n"
"    // 이들은 문자열화될 것입니다.\n"

#: src/hello/print.md:21
msgid "\"{} days\""
msgstr "\"{}일\""

#: src/hello/print.md:23
msgid ""
"// Positional arguments can be used. Specifying an integer inside `{}`\n"
"    // determines which additional argument will be replaced. Arguments "
"start\n"
"    // at 0 immediately after the format string.\n"
msgstr ""
"// 위치 인자를 사용할 수 있습니다. `{}` 안에 정수를 지정하면\n"
"    // 어떤 추가 인자가 교체될지 결정합니다. 인자는 형식 문자열\n"
"    // 바로 뒤에서 0부터 시작합니다.\n"

#: src/hello/print.md:26
msgid "\"{0}, this is {1}. {1}, this is {0}\""
msgstr "\"{0}, 여기는 {1}입니다. {1}, 여기는 {0}입니다.\""

#: src/hello/print.md:26 src/scope/move/partial_move.md:31
msgid "\"Alice\""
msgstr "\"앨리스\""

#: src/hello/print.md:26 src/flow_control/for.md:65 src/flow_control/for.md:85
#: src/flow_control/for.md:104
msgid "\"Bob\""
msgstr "\"밥\""

#: src/hello/print.md:28
msgid "// As can named arguments.\n"
msgstr "// 이름을 지정한 인자(named arguments)도 사용할 수 있습니다.\n"

#: src/hello/print.md:29
msgid "\"{subject} {verb} {object}\""
msgstr "\"{subject} {verb} {object}\""

#: src/hello/print.md:30
msgid "\"the lazy dog\""
msgstr "\"게으른 개\""

#: src/hello/print.md:31
msgid "\"the quick brown fox\""
msgstr "\"빠른 갈색 여우\""

#: src/hello/print.md:32
msgid "\"jumps over\""
msgstr "\"넘어 뛰어넘다\""

#: src/hello/print.md:34
msgid ""
"// Different formatting can be invoked by specifying the format character\n"
"    // after a `:`.\n"
msgstr "// `:` 뒤에 형식 문자를 지정하여 다양한 형식화를 수행할 수 있습니다.\n"

#: src/hello/print.md:36
msgid "\"Base 10:               {}\""
msgstr "\"10진수:               {}\""

#: src/hello/print.md:36
msgid "// 69420\n"
msgstr "// 69420\n"

#: src/hello/print.md:37
msgid "\"Base 2 (binary):       {:b}\""
msgstr "\"2진수:                {:b}\""

#: src/hello/print.md:37
msgid "// 10000111100101100\n"
msgstr "// 10000111100101100\n"

#: src/hello/print.md:38
msgid "\"Base 8 (octal):        {:o}\""
msgstr "\"8진수:                {:o}\""

#: src/hello/print.md:38
msgid "// 207454\n"
msgstr "// 207454\n"

#: src/hello/print.md:39
msgid "\"Base 16 (hexadecimal): {:x}\""
msgstr "\"16진수:               {:x}\""

#: src/hello/print.md:39
msgid "// 10f2c\n"
msgstr "// 10f2c\n"

#: src/hello/print.md:41
msgid ""
"// You can right-justify text with a specified width. This will\n"
"    // output \"    1\". (Four white spaces and a \"1\", for a total width "
"of 5.)\n"
msgstr ""
"// 지정된 너비로 텍스트를 오른쪽 정렬할 수 있습니다. 이 예시는\n"
"    // \"    1\"을 출력할 것입니다. (공백 4개와 \"1\" 하나로 총 너비 5가 됩니"
"다.)\n"

#: src/hello/print.md:43
msgid "\"{number:>5}\""
msgstr "\"{number:>5}\""

#: src/hello/print.md:45
msgid "// You can pad numbers with extra zeroes,\n"
msgstr "// 숫자를 0으로 채울 수도 있습니다,\n"

#: src/hello/print.md:46
msgid "\"{number:0>5}\""
msgstr "\"{number:0>5}\""

#: src/hello/print.md:46
msgid ""
"// 00001\n"
"    // and left-adjust by flipping the sign. This will output \"10000\".\n"
msgstr ""
"// 00001\n"
"    // 그리고 부호를 뒤집어 왼쪽 정렬할 수 있습니다. 이것은 \"10000\"을 출력"
"합니다.\n"

#: src/hello/print.md:48
msgid "\"{number:0<5}\""
msgstr "\"{number:0<5}\""

#: src/hello/print.md:48
msgid "// 10000\n"
msgstr "// 10000\n"

#: src/hello/print.md:50
msgid ""
"// You can use named arguments in the format specifier by appending a `$`.\n"
msgstr ""
"// 형식 지정자(format specifier)에 `$`를 붙여 명명된 인자를 사용할 수 있습니"
"다.\n"

#: src/hello/print.md:51
msgid "\"{number:0>width$}\""
msgstr "\"{number:0>width$}\""

#: src/hello/print.md:53
msgid ""
"// Rust even checks to make sure the correct number of arguments are used.\n"
msgstr "// Rust는 올바른 개수의 인자가 사용되었는지도 확인합니다.\n"

#: src/hello/print.md:54
msgid "\"My name is {0}, {1} {0}\""
msgstr "\"제 이름은 {0}, {1} {0}입니다.\""

#: src/hello/print.md:54
msgid "\"Bond\""
msgstr "\"본드\""

#: src/hello/print.md:55
msgid "// FIXME ^ Add the missing argument: \"James\"\n"
msgstr "// FIXME ^ 누락된 인자를 추가하세요: \"제임스\"\n"

#: src/hello/print.md:57
msgid ""
"// Only types that implement fmt::Display can be formatted with `{}`. User-\n"
"    // defined types do not implement fmt::Display by default.\n"
msgstr ""
"// fmt::Display를 구현하는 타입만 `{}`로 형식화할 수 있습니다. 사용자\n"
"    // 정의 타입은 기본적으로 fmt::Display를 구현하지 않습니다.\n"

#: src/hello/print.md:60
msgid "// disable `dead_code` which warn against unused module\n"
msgstr "// 사용되지 않는 모듈에 대한 경고인 `dead_code`를 비활성화합니다\n"

#: src/hello/print.md:63
msgid ""
"// This will not compile because `Structure` does not implement\n"
"    // fmt::Display.\n"
"    // println!(\"This struct `{}` won't print...\", Structure(3));\n"
"    // TODO ^ Try uncommenting this line\n"
msgstr ""
"// `Structure`가 fmt::Display를 구현하지 않으므로 컴파일되지 않습니다.\n"
"    // println!(\"이 구조체 `{}`는 출력되지 않습니다...\", Structure(3));\n"
"    // TODO ^ 이 줄의 주석을 해제해 보세요\n"

#: src/hello/print.md:68
msgid ""
"// For Rust 1.58 and above, you can directly capture the argument from a\n"
"    // surrounding variable. Just like the above, this will output\n"
"    // \"    1\", 4 white spaces and a \"1\".\n"
msgstr ""
"// Rust 1.58 이상에서는 주변 변수에서 직접 인자를 캡처할 수 있습니다.\n"
"    // 위와 마찬가지로, 이것은 \"    1\"(공백 4개와 \"1\")을 출력합니다.\n"

#: src/hello/print.md:73
msgid "\"{number:>width$}\""
msgstr "\"{number:>width$}\""

#: src/hello/print.md:77
msgid ""
"[`std::fmt`](https://doc.rust-lang.org/std/fmt/) contains many [`traits`]"
"(https://doc.rust-lang.org/std/fmt/#formatting-traits) which govern the "
"display of text. The base form of two important ones are listed below:"
msgstr ""
"[`std::fmt`](https://doc.rust-lang.org/std/fmt/)에는 텍스트 표시를 제어하는 "
"많은 [`트레이트`](https://doc.rust-lang.org/std/fmt/#formatting-traits)가 포"
"함되어 있습니다. 그 중 중요한 두 가지의 기본 형태는 다음과 같습니다:"

#: src/hello/print.md:80
msgid ""
"`fmt::Debug`: Uses the `{:?}` marker. Format text for debugging purposes."
msgstr ""
"`fmt::Debug`: `{:?}` 마커를 사용합니다. 디버깅 목적으로 텍스트 형식을 지정합"
"니다."

#: src/hello/print.md:81
msgid ""
"`fmt::Display`: Uses the `{}` marker. Format text in a more elegant, user "
"friendly fashion."
msgstr ""
"`fmt::Display`: `{}` 마커를 사용합니다. 보다 우아하고 사용자 친화적인 방식으"
"로 텍스트 형식을 지정합니다."

#: src/hello/print.md:84
msgid ""
"Here, we used `fmt::Display` because the std library provides "
"implementations for these types. To print text for custom types, more steps "
"are required."
msgstr ""
"여기서는 표준 라이브러리가 이러한 타입들에 대한 구현을 제공하기 때문에 "
"`fmt::Display`를 사용했습니다. 커스텀 타입에 대해 텍스트를 출력하려면 더 많"
"은 단계가 필요합니다."

#: src/hello/print.md:87
msgid ""
"Implementing the `fmt::Display` trait automatically implements the "
"[`ToString`](https://doc.rust-lang.org/std/string/trait.ToString.html) trait "
"which allows us to [convert](../conversion/string.md) the type to [`String`]"
"(../std/str.md)."
msgstr ""
"`fmt::Display` 트레이트를 구현하면 타입을 [`String`](../std/str.md)으로 [변"
"환](../conversion/string.md)할 수 있게 해주는 [`ToString`](https://doc.rust-"
"lang.org/std/string/trait.ToString.html) 트레이트가 자동으로 구현됩니다."

#: src/hello/print.md:90
msgid ""
"In _line 43_, `#[allow(dead_code)]` is an [attribute](../attribute.md) which "
"only applies to the module after it."
msgstr ""
"_43행_의 `#[allow(dead_code)]`는 그 뒤에 오는 모듈에만 적용되는 [속성](../"
"attribute.md)입니다."

#: src/hello/print.md:92
msgid "Activities"
msgstr "실습"

#: src/hello/print.md:94
msgid ""
"Fix the issue in the above code (see FIXME) so that it runs without error."
msgstr "위 코드의 문제(FIXME 참고)를 수정하여 에러 없이 실행되도록 하세요."

#: src/hello/print.md:96
msgid ""
"Try uncommenting the line that attempts to format the `Structure` struct "
"(see TODO)"
msgstr ""
"`Structure` 구조체를 형식화하려는 줄의 주석을 제거해 보세요 (TODO 참고)."

#: src/hello/print.md:98
msgid ""
"Add a `println!` macro call that prints: `Pi is roughly 3.142` by "
"controlling the number of decimal places shown. For the purposes of this "
"exercise, use `let pi = 3.141592` as an estimate for pi. (Hint: you may need "
"to check the [`std::fmt`](https://doc.rust-lang.org/std/fmt/) documentation "
"for setting the number of decimals to display)"
msgstr ""
"표시되는 소수점 자릿수를 제어하여 `Pi is roughly 3.142`를 출력하는 `println!"
"` 매크로 호출을 추가하세요. 이 연습을 위해 파이의 근사값으로 `let pi = "
"3.141592`를 사용하세요. (힌트: 표시할 소수점 자릿수를 설정하는 방법은 "
"[`std::fmt`](https://doc.rust-lang.org/std/fmt/) 문서를 확인해야 할 수도 있습"
"니다.)"

#: src/hello/print.md:105
msgid ""
"[`std::fmt`](https://doc.rust-lang.org/std/fmt/), [`macros`](../macros.md), "
"[`struct`](../custom_types/structs.md), [`traits`](https://doc.rust-lang.org/"
"std/fmt/#formatting-traits), and [`dead_code`](../attribute/unused.md)"
msgstr ""
"[`std::fmt`](https://doc.rust-lang.org/std/fmt/), [`매크로`](../macros.md), "
"[`구조체`](../custom_types/structs.md), [`트레이트`](https://doc.rust-"
"lang.org/std/fmt/#formatting-traits), 그리고 [`dead_code`](../attribute/"
"unused.md)"

#: src/hello/print/print_debug.md:3
msgid ""
"All types which want to use `std::fmt` formatting `traits` require an "
"implementation to be printable. Automatic implementations are only provided "
"for types such as in the `std` library. All others _must_ be manually "
"implemented somehow."
msgstr ""
"`std::fmt` 형식화 `트레이트`를 사용하려는 모든 타입은 출력 가능하도록 구현이 "
"필요합니다. 자동 구현은 `std` 라이브러리와 같은 타입들에 대해서만 제공됩니"
"다. 그 외의 모든 타입은 어떻게든 수동으로 구현_해야만_ 합니다."

#: src/hello/print/print_debug.md:8
msgid ""
"The `fmt::Debug` `trait` makes this very straightforward. _All_ types can "
"`derive` (automatically create) the `fmt::Debug` implementation. This is not "
"true for `fmt::Display` which must be manually implemented."
msgstr ""
"`fmt::Debug` `트레이트`는 이를 매우 간단하게 만들어 줍니다. _모든_ 타입은 "
"`fmt::Debug` 구현을 `derive`(자동 생성)할 수 있습니다. 하지만 `fmt::Display`"
"는 그렇지 않으며 수동으로 구현해야 합니다."

#: src/hello/print/print_debug.md:13
msgid ""
"// This structure cannot be printed either with `fmt::Display` or\n"
"// with `fmt::Debug`.\n"
msgstr ""
"// 이 구조체는 `fmt::Display`나 `fmt::Debug` 중 어느 것으로도\n"
"// 출력할 수 없습니다.\n"

#: src/hello/print/print_debug.md:16
msgid ""
"// The `derive` attribute automatically creates the implementation\n"
"// required to make this `struct` printable with `fmt::Debug`.\n"
msgstr ""
"// `derive` 속성은 이 `구조체`를 `fmt::Debug`로 출력 가능하게 만드는 데\n"
"// 필요한 구현을 자동으로 생성합니다.\n"

#: src/hello/print/print_debug.md:23
msgid "All `std` library types are automatically printable with `{:?}` too:"
msgstr "모든 `std` 라이브러리 타입들도 `{:?}`로 자동 출력이 가능합니다:"

#: src/hello/print/print_debug.md:26
msgid ""
"// Derive the `fmt::Debug` implementation for `Structure`. `Structure`\n"
"// is a structure which contains a single `i32`.\n"
msgstr ""
"// `Structure`에 대해 `fmt::Debug` 구현을 유도(derive)합니다. `Structure`는\n"
"// 단일 `i32`를 포함하는 구조체입니다.\n"

#: src/hello/print/print_debug.md:30
msgid ""
"// Put a `Structure` inside of the structure `Deep`. Make it printable\n"
"// also.\n"
msgstr ""
"// `Deep` 구조체 안에 `Structure`를 넣으세요. 그리고 역시 출력 가능하게 만드"
"세요.\n"

#: src/hello/print/print_debug.md:37
msgid "// Printing with `{:?}` is similar to with `{}`.\n"
msgstr "// `{:?}`를 이용한 출력은 `{}`와 유사합니다.\n"

#: src/hello/print/print_debug.md:38
msgid "\"{:?} months in a year.\""
msgstr "\"1년은 {:?}개월입니다.\""

#: src/hello/print/print_debug.md:39
msgid "\"{1:?} {0:?} is the {actor:?} name.\""
msgstr "\"{1:?} {0:?}은 {actor:?}의 이름입니다.\""

#: src/hello/print/print_debug.md:40
msgid "\"Slater\""
msgstr "\"슬레이터\""

#: src/hello/print/print_debug.md:41
msgid "\"Christian\""
msgstr "\"크리스찬\""

#: src/hello/print/print_debug.md:42
msgid "\"actor's\""
msgstr "\"배우의\""

#: src/hello/print/print_debug.md:44
msgid "// `Structure` is printable!\n"
msgstr "// `Structure`는 출력 가능합니다!\n"

#: src/hello/print/print_debug.md:45 src/hello/print/print_debug.md:49
msgid "\"Now {:?} will print!\""
msgstr "\"이제 {:?}가 출력될 것입니다!\""

#: src/hello/print/print_debug.md:47
msgid ""
"// The problem with `derive` is there is no control over how\n"
"    // the results look. What if I want this to just show a `7`?\n"
msgstr ""
"// `derive`의 문제점은 결과가 어떻게 보일지 제어할 수 없다는 것입니다.\n"
"    // 만약 이것을 단지 `7`로 보여주고 싶다면 어떡하죠?\n"

#: src/hello/print/print_debug.md:53
msgid ""
"So `fmt::Debug` definitely makes this printable but sacrifices some "
"elegance. Rust also provides \"pretty printing\" with `{:#?}`."
msgstr ""
"따라서 `fmt::Debug`는 확실히 출력을 가능하게 하지만 우아함을 어느 정도 희생합"
"니다. Rust는 `{:#?}`를 사용한 \"예쁘게 출력하기(pretty printing)\"도 제공합니"
"다."

#: src/hello/print/print_debug.md:64 src/custom_types/structs.md:42
msgid "\"Peter\""
msgstr "\"피터\""

#: src/hello/print/print_debug.md:68
msgid "// Pretty print\n"
msgstr "// 예쁘게 출력하기\n"

#: src/hello/print/print_debug.md:69
msgid "\"{:#?}\""
msgstr "\"{:#?}\""

#: src/hello/print/print_debug.md:73
msgid "One can manually implement `fmt::Display` to control the display."
msgstr "`fmt::Display`를 수동으로 구현하여 출력을 제어할 수 있습니다."

#: src/hello/print/print_debug.md:77
msgid ""
"[`attributes`](https://doc.rust-lang.org/reference/attributes.html), "
"[`derive`](../../trait/derive.md), [`std::fmt`](https://doc.rust-lang.org/"
"std/fmt/), and [`struct`](../../custom_types/structs.md)"
msgstr ""
"[`속성`](https://doc.rust-lang.org/reference/attributes.html), [`derive`]"
"(../../trait/derive.md), [`std::fmt`](https://doc.rust-lang.org/std/fmt/), 그"
"리고 [`구조체`](../../custom_types/structs.md)"

#: src/hello/print/print_display.md:3
msgid ""
"`fmt::Debug` hardly looks compact and clean, so it is often advantageous to "
"customize the output appearance. This is done by manually implementing "
"[`fmt::Display`](https://doc.rust-lang.org/std/fmt/), which uses the `{}` "
"print marker. Implementing it looks like this:"
msgstr ""
"`fmt::Debug`는 콤팩트하고 깔끔해 보이지 않으므로, 출력 모양을 커스터마이징하"
"는 것이 종종 유리합니다. 이는 `{}` 출력 마커를 사용하는 [`fmt::Display`]"
"(https://doc.rust-lang.org/std/fmt/)를 수동으로 구현함으로써 수행됩니다. 구현"
"은 다음과 같습니다:"

#: src/hello/print/print_display.md:9
msgid "// Import (via `use`) the `fmt` module to make it available.\n"
msgstr "// `fmt` 모듈을 (`use`를 통해) 가져와서 사용할 수 있게 합니다.\n"

#: src/hello/print/print_display.md:11
msgid ""
"// Define a structure for which `fmt::Display` will be implemented. This is\n"
"// a tuple struct named `Structure` that contains an `i32`.\n"
msgstr ""
"// `fmt::Display`를 구현할 구조체를 정의합니다. 이것은\n"
"// `i32`를 포함하는 `Structure`라는 이름의 튜플 구조체입니다.\n"

#: src/hello/print/print_display.md:15
msgid ""
"// To use the `{}` marker, the trait `fmt::Display` must be implemented\n"
"// manually for the type.\n"
msgstr ""
"// `{}` 마커를 사용하려면, `fmt::Display` 트레이트가 해당 타입에 대해\n"
"// 수동으로 구현되어야 합니다.\n"

#: src/hello/print/print_display.md:19
msgid "// This trait requires `fmt` with this exact signature.\n"
msgstr "// 이 트레이트는 정확히 이 시그니처를 가진 `fmt`를 요구합니다.\n"

#: src/hello/print/print_display.md:21
msgid ""
"// Write strictly the first element into the supplied output\n"
"        // stream: `f`. Returns `fmt::Result` which indicates whether the\n"
"        // operation succeeded or failed. Note that `write!` uses syntax "
"which\n"
"        // is very similar to `println!`.\n"
msgstr ""
"// 제공된 출력 스트림 `f`에 첫 번째 요소를 씁니다.\n"
"        // 작업의 성공 또는 실패 여부를 나타내는 `fmt::Result`를 반환합니"
"다.\n"
"        // `write!`는 `println!`과 매우 유사한 구문을 사용한다는 점에 유의하"
"세요.\n"

#: src/hello/print/print_display.md:25
#: src/hello/print/print_display/testcase_list.md:13
#: src/hello/print/print_display/testcase_list.md:39
#: src/hello/print/print_display/testcase_list.md:49 src/hello/print/fmt.md:53
#: src/custom_types/enum/testcase_linked_list.md:74 src/conversion/string.md:25
#: src/flow_control/loop.md:26 src/flow_control/while.md:21
#: src/flow_control/for.md:23 src/flow_control/for.md:43 src/fn.md:40
#: src/fn/closures/capture.md:96 src/fn/closures/capture.md:97
#: src/fn/closures/anonymity.md:41 src/generics/bounds.md:12
#: src/macros/repeat.md:24 src/macros/repeat.md:25 src/macros/repeat.md:26
#: src/error/result.md:73 src/std/str.md:92 src/std/str.md:102
#: src/std/str.md:106 src/std/str.md:111 src/std/result.md:72
#: src/std/result/question_mark.md:57 src/std/result/question_mark.md:65
#: src/std_misc/file/read_lines.md:60 src/std_misc/arg/matching.md:9
#: src/std_misc/arg/matching.md:13
msgid "\"{}\""
msgstr "\"{}\""

#: src/hello/print/print_display.md:30
msgid ""
"`fmt::Display` may be cleaner than `fmt::Debug` but this presents a problem "
"for the `std` library. How should ambiguous types be displayed? For example, "
"if the `std` library implemented a single style for all `Vec<T>`, what style "
"should it be? Would it be either of these two?"
msgstr ""
"`fmt::Display`가 `fmt::Debug`보다 깔끔할 수 있지만, 이는 `std` 라이브러리에 "
"문제를 제기합니다. 모호한 타입들은 어떻게 표시되어야 할까요? 예를 들어, "
"`std` 라이브러리가 모든 `Vec<T>`에 대해 단일 스타일을 구현했다면, 어떤 스타일"
"이어야 할까요? 다음 두 가지 중 하나일까요?"

#: src/hello/print/print_display.md:35
msgid "`Vec<path>`: `/:/etc:/home/username:/bin` (split on `:`)"
msgstr "`Vec<path>`: `/:/etc:/home/username:/bin` (`:`로 구분)"

#: src/hello/print/print_display.md:36
msgid "`Vec<number>`: `1,2,3` (split on `,`)"
msgstr "`Vec<number>`: `1,2,3` (`,`로 구분)"

#: src/hello/print/print_display.md:38
msgid ""
"No, because there is no ideal style for all types and the `std` library "
"doesn't presume to dictate one. `fmt::Display` is not implemented for "
"`Vec<T>` or for any other generic containers. `fmt::Debug` must then be used "
"for these generic cases."
msgstr ""
"아니요, 모든 타입에 이상적인 스타일은 없으며 `std` 라이브러리가 하나를 독단적"
"으로 정하지 않기 때문입니다. `fmt::Display`는 `Vec<T>`나 다른 제네릭 컨테이너"
"에 대해 구현되어 있지 않습니다. 따라서 이러한 제네릭 케이스에는 `fmt::Debug`"
"를 사용해야 합니다."

#: src/hello/print/print_display.md:43
msgid ""
"This is not a problem though because for any new _container_ type which is "
"_not_ generic, `fmt::Display` can be implemented."
msgstr ""
"하지만 제네릭이 _아닌_ 새로운 _컨테이너_ 타입에 대해서는 `fmt::Display`를 구"
"현할 수 있으므로 이는 문제가 되지 않습니다."

#: src/hello/print/print_display.md:47
msgid "// Import `fmt`\n"
msgstr "// `fmt` 가져오기\n"

#: src/hello/print/print_display.md:48
msgid ""
"// A structure holding two numbers. `Debug` will be derived so the results "
"can\n"
"// be contrasted with `Display`.\n"
msgstr ""
"// 두 숫자를 보유하는 구조체입니다. `Display`와 대조해 볼 수 있도록\n"
"// `Debug`를 유도(derive)할 것입니다.\n"

#: src/hello/print/print_display.md:53
msgid "// Implement `Display` for `MinMax`.\n"
msgstr "// `MinMax`에 대해 `Display`를 구현합니다.\n"

#: src/hello/print/print_display.md:57
msgid "// Use `self.number` to refer to each positional data point.\n"
msgstr "// 각 위치별 데이터 지점을 참조하기 위해 `self.number`를 사용합니다.\n"

#: src/hello/print/print_display.md:58
msgid "\"({}, {})\""
msgstr "\"({}, {})\""

#: src/hello/print/print_display.md:61
msgid "// Define a structure where the fields are nameable for comparison.\n"
msgstr "// 비교를 위해 필드에 이름을 붙일 수 있는 구조체를 정의합니다.\n"

#: src/hello/print/print_display.md:68
msgid "// Similarly, implement `Display` for `Point2D`.\n"
msgstr "// 마찬가지로, `Point2D`에 대해 `Display`를 구현합니다.\n"

#: src/hello/print/print_display.md:72
msgid "// Customize so only `x` and `y` are denoted.\n"
msgstr "// `x`와 `y`만 표시되도록 커스터마이징합니다.\n"

#: src/hello/print/print_display.md:73
msgid "\"x: {}, y: {}\""
msgstr "\"x: {}, y: {}\""

#: src/hello/print/print_display.md:80
msgid "\"Compare structures:\""
msgstr "\"구조체 비교:\""

#: src/hello/print/print_display.md:81 src/hello/print/print_display.md:94
msgid "\"Display: {}\""
msgstr "\"디스플레이: {}\""

#: src/hello/print/print_display.md:82 src/hello/print/print_display.md:95
msgid "\"Debug: {:?}\""
msgstr "\"디버그: {:?}\""

#: src/hello/print/print_display.md:87
msgid "\"The big range is {big} and the small is {small}\""
msgstr "\"큰 범위는 {big}이고 작은 범위는 {small}입니다.\""

#: src/hello/print/print_display.md:93
msgid "\"Compare points:\""
msgstr "\"좌표 비교:\""

#: src/hello/print/print_display.md:97
msgid ""
"// Error. Both `Debug` and `Display` were implemented, but `{:b}`\n"
"    // requires `fmt::Binary` to be implemented. This will not work.\n"
"    // println!(\"What does Point2D look like in binary: {:b}?\", point);\n"
msgstr ""
"// 에러. `Debug`와 `Display`는 모두 구현되었지만, `{:b}`는\n"
"    // `fmt::Binary` 구현을 요구합니다. 이것은 작동하지 않을 것입니다.\n"
"    // println!(\"Point2D의 2진수 형태는 무엇일까요: {:b}?\", point);\n"

#: src/hello/print/print_display.md:103
msgid ""
"So, `fmt::Display` has been implemented but `fmt::Binary` has not, and "
"therefore cannot be used. `std::fmt` has many such [`traits`](https://"
"doc.rust-lang.org/std/fmt/#formatting-traits) and each requires its own "
"implementation. This is detailed further in [`std::fmt`](https://doc.rust-"
"lang.org/std/fmt/)."
msgstr ""
"따라서, `fmt::Display`는 구현되었지만 `fmt::Binary`는 구현되지 않았으므로 사"
"용할 수 없습니다. `std::fmt`에는 이와 같은 많은 [`트레이트`](https://"
"doc.rust-lang.org/std/fmt/#formatting-traits)가 있으며 각각은 자체적인 구현"
"을 요구합니다. 이에 대한 자세한 내용은 [`std::fmt`](https://doc.rust-"
"lang.org/std/fmt/)에 나와 있습니다."

#: src/hello/print/print_display.md:109
msgid ""
"After checking the output of the above example, use the `Point2D` struct as "
"a guide to add a `Complex` struct to the example. When printed in the same "
"way, the output should be:"
msgstr ""
"위 예제의 출력을 확인한 후, `Point2D` 구조체를 가이드로 삼아 예제에 "
"`Complex` 구조체를 추가해 보세요. 같은 방식으로 출력했을 때의 결과는 다음과 "
"같아야 합니다:"

#: src/hello/print/print_display.md:121
msgid "Bonus: Add a space before the `+`/`-` signs."
msgstr "보너스: `+`/`-` 기호 앞에 공백을 추가하세요."

#: src/hello/print/print_display.md:123
msgid "Hints in case you get stuck:"
msgstr "막혔을 때를 위한 힌트:"

#: src/hello/print/print_display.md:125
msgid ""
"Check the documentation for [`Sign/#/0`](https://doc.rust-lang.org/std/fmt/"
"#sign0) in `std::fmt`."
msgstr ""
"`std::fmt`에서 [`Sign/#/0`](https://doc.rust-lang.org/std/fmt/#sign0)에 대한 "
"문서를 확인하세요."

#: src/hello/print/print_display.md:126
msgid ""
"Bonus: Check [`if`\\-`else`](../../flow_control/if_else.md) branching and "
"the [`abs`](https://doc.rust-lang.org/std/primitive.f64.html#method.abs) "
"function."
msgstr ""
"보너스: [`if`\\-`else`](../../flow_control/if_else.md) 분기와 [`abs`]"
"(https://doc.rust-lang.org/std/primitive.f64.html#method.abs) 함수를 확인하세"
"요."

#: src/hello/print/print_display.md:130
msgid ""
"[`derive`](../../trait/derive.md), [`std::fmt`](https://doc.rust-lang.org/"
"std/fmt/), [`macros`](../../macros.md), [`struct`](../../custom_types/"
"structs.md), [`trait`](https://doc.rust-lang.org/std/fmt/#formatting-"
"traits), and [`use`](../../mod/use.md)"
msgstr ""
"[`derive`](../../trait/derive.md), [`std::fmt`](https://doc.rust-lang.org/"
"std/fmt/), [`매크로`](../../macros.md), [`구조체`](../../custom_types/"
"structs.md), [`트레이트`](https://doc.rust-lang.org/std/fmt/#formatting-"
"traits), 그리고 [`use`](../../mod/use.md)"

#: src/hello/print/print_display/testcase_list.md:3
msgid ""
"Implementing `fmt::Display` for a structure where the elements must each be "
"handled sequentially is tricky. The problem is that each `write!` generates "
"a `fmt::Result`. Proper handling of this requires dealing with _all_ the "
"results. Rust provides the `?` operator for exactly this purpose."
msgstr ""
"각 요소를 순차적으로 처리해야 하는 구조체에 대해 `fmt::Display`를 구현하는 것"
"은 까다롭습니다. 문제는 각 `write!`가 `fmt::Result`를 생성한다는 것입니다. 이"
"를 적절히 처리하려면 _모든_ 결과를 다뤄야 합니다. Rust는 정확히 이 목적을 위"
"해 `?` 연산자를 제공합니다."

#: src/hello/print/print_display/testcase_list.md:8
msgid "Using `?` on `write!` looks like this:"
msgstr "`write!`에 `?`를 사용하는 것은 다음과 같습니다:"

#: src/hello/print/print_display/testcase_list.md:11
msgid ""
"// Try `write!` to see if it errors. If it errors, return\n"
"// the error. Otherwise continue.\n"
msgstr ""
"// `write!`가 에러를 발생시키는지 확인합니다. 에러가 발생하면\n"
"// 에러를 반환합니다. 그렇지 않으면 계속 진행합니다.\n"

#: src/hello/print/print_display/testcase_list.md:16
msgid ""
"With `?` available, implementing `fmt::Display` for a `Vec` is "
"straightforward:"
msgstr "`?`가 사용 가능해지면 `Vec`에 대한 `fmt::Display` 구현은 간단해집니다:"

#: src/hello/print/print_display/testcase_list.md:20
msgid "// Import the `fmt` module.\n"
msgstr "// `fmt` 모듈을 가져옵니다.\n"

#: src/hello/print/print_display/testcase_list.md:21
msgid "// Define a structure named `List` containing a `Vec`.\n"
msgstr "// `Vec`을 포함하는 `List`라는 이름의 구조체를 정의합니다.\n"

#: src/hello/print/print_display/testcase_list.md:27
msgid ""
"// Extract the value using tuple indexing,\n"
"        // and create a reference to `vec`.\n"
msgstr ""
"// 튜플 인덱싱을 사용하여 값을 추출하고,\n"
"        // `vec`에 대한 참조를 생성합니다.\n"

#: src/hello/print/print_display/testcase_list.md:31
msgid "\"[\""
msgstr "\"[\""

#: src/hello/print/print_display/testcase_list.md:33
msgid ""
"// Iterate over `v` in `vec` while enumerating the iteration\n"
"        // index in `index`.\n"
msgstr "// `vec`의 `v`를 순회하면서 반복 인덱스를 `index`에 열거합니다.\n"

#: src/hello/print/print_display/testcase_list.md:36
msgid ""
"// For every element except the first, add a comma.\n"
"            // Use the ? operator to return on errors.\n"
msgstr ""
"// 첫 번째를 제외한 모든 요소에 콤마를 추가합니다.\n"
"            // 에러 시 반환하기 위해 ? 연산자를 사용합니다.\n"

#: src/hello/print/print_display/testcase_list.md:38 src/std/str.md:36
msgid "\", \""
msgstr "\", \""

#: src/hello/print/print_display/testcase_list.md:42
msgid "// Close the opened bracket and return a fmt::Result value.\n"
msgstr "// 열려 있는 대괄호를 닫고 `fmt::Result` 값을 반환합니다.\n"

#: src/hello/print/print_display/testcase_list.md:43
msgid "\"]\""
msgstr "\"]\""

#: src/hello/print/print_display/testcase_list.md:55
msgid ""
"Try changing the program so that the index of each element in the vector is "
"also printed. The new output should look like this:"
msgstr ""
"벡터의 각 요소의 인덱스도 출력되도록 프로그램을 변경해 보세요. 새로운 출력은 "
"다음과 같아야 합니다:"

#: src/hello/print/print_display/testcase_list.md:64
msgid ""
"[`for`](../../../flow_control/for.md), [`ref`](../../../scope/borrow/"
"ref.md), [`Result`](../../../std/result.md), [`struct`](../../../"
"custom_types/structs.md), [`?`](../../../std/result/question_mark.md), and "
"[`vec!`](../../../std/vec.md)"
msgstr ""
"[`for`](../../../flow_control/for.md), [`ref`](../../../scope/borrow/"
"ref.md), [`Result`](../../../std/result.md), [`구조체`](../../../"
"custom_types/structs.md), [`?`](../../../std/result/question_mark.md), 그리"
"고 [`vec!`](../../../std/vec.md)"

#: src/hello/print/fmt.md:3
msgid "We've seen that formatting is specified via a _format string_:"
msgstr "형식화는 _형식 문자열_을 통해 지정되는 것을 보았습니다:"

#: src/hello/print/fmt.md:5
msgid "`format!(\"{}\", foo)` -> `\"3735928559\"`"
msgstr "`format!(\"{}\", foo)` -> `\"3735928559\"`"

#: src/hello/print/fmt.md:6
msgid ""
"`format!(\"0x{:X}\", foo)` -> [`\"0xDEADBEEF\"`](https://en.wikipedia.org/"
"wiki/Deadbeef#Magic_debug_values)"
msgstr ""
"`format!(\"0x{:X}\", foo)` -> [`\"0xDEADBEEF\"`](https://en.wikipedia.org/"
"wiki/Deadbeef#Magic_debug_values)"

#: src/hello/print/fmt.md:7
msgid "`format!(\"0o{:o}\", foo)` -> `\"0o33653337357\"`"
msgstr "`format!(\"0o{:o}\", foo)` -> `\"0o33653337357\"`"

#: src/hello/print/fmt.md:9
msgid ""
"The same variable (`foo`) can be formatted differently depending on which "
"_argument type_ is used: `X` vs `o` vs _unspecified_."
msgstr ""
"동일한 변수(`foo`)라도 `X`, `o` 또는 _지정되지 않음_과 같이 어떤 _인자 타입_"
"이 사용되느냐에 따라 다르게 형식화될 수 있습니다."

#: src/hello/print/fmt.md:12
msgid ""
"This formatting functionality is implemented via traits, and there is one "
"trait for each argument type. The most common formatting trait is `Display`, "
"which handles cases where the argument type is left unspecified: `{}` for "
"instance."
msgstr ""
"이 형식화 기능은 트레이트를 통해 구현되며, 각 인자 타입에 대해 하나의 트레이"
"트가 존재합니다. 가장 일반적인 형식화 트레이트는 `Display`이며, 인자 타입이 "
"지정되지 않은 경우(예: `{}`)를 처리합니다."

#: src/hello/print/fmt.md:21
msgid "// Latitude\n"
msgstr "// 위도\n"

#: src/hello/print/fmt.md:23
msgid "// Longitude\n"
msgstr "// 경도\n"

#: src/hello/print/fmt.md:28
msgid ""
"// `f` is a buffer, and this method must write the formatted string into "
"it.\n"
msgstr "// `f`는 버퍼이며, 이 메서드는 버퍼에 형식화된 문자열을 써야 합니다.\n"

#: src/hello/print/fmt.md:30
msgid "'N'"
msgstr "'북'"

#: src/hello/print/fmt.md:30
msgid "'S'"
msgstr "'남'"

#: src/hello/print/fmt.md:31
msgid "'E'"
msgstr "'동'"

#: src/hello/print/fmt.md:31
msgid "'W'"
msgstr "'서'"

#: src/hello/print/fmt.md:33
msgid ""
"// `write!` is like `format!`, but it will write the formatted string\n"
"        // into a buffer (the first argument).\n"
msgstr ""
"// `write!`는 `format!`과 비슷하지만, 형식화된 문자열을\n"
"        // 버퍼(첫 번째 인자)에 씁니다.\n"

#: src/hello/print/fmt.md:35
msgid "\"{}: {:.3}°{} {:.3}°{}\""
msgstr "\"{}: {:.3}°{} {:.3}°{}\""

#: src/hello/print/fmt.md:49
msgid "\"Dublin\""
msgstr "\"더블린\""

#: src/hello/print/fmt.md:50
msgid "\"Oslo\""
msgstr "\"오슬로\""

#: src/hello/print/fmt.md:51
msgid "\"Vancouver\""
msgstr "\"밴쿠버\""

#: src/hello/print/fmt.md:60
msgid ""
"// Switch this to use {} once you've added an implementation\n"
"        // for fmt::Display.\n"
msgstr "// fmt::Display 구현을 추가한 후에는 {}를 사용하도록 변경하세요.\n"

#: src/hello/print/fmt.md:62 src/primitives/tuples.md:60
#: src/custom_types/structs.md:47 src/types/inference.md:23
#: src/conversion/string.md:76 src/generics/bounds.md:49
#: src/generics/where.md:38 src/std/str.md:137 src/std/result.md:59
#: src/std/result.md:61 src/std/result.md:63 src/std/arc.md:26
#: src/std_misc/channels.md:53
msgid "\"{:?}\""
msgstr "\"{:?}\""

#: src/hello/print/fmt.md:67
msgid ""
"You can view a [full list of formatting traits](https://doc.rust-lang.org/"
"std/fmt/#formatting-traits) and their argument types in the [`std::fmt`]"
"(https://doc.rust-lang.org/std/fmt/) documentation."
msgstr ""
"[`std::fmt`](https://doc.rust-lang.org/std/fmt/) 문서에서 [형식화 트레이트 전"
"체 목록](https://doc.rust-lang.org/std/fmt/#formatting-traits)과 해당 인자 타"
"입을 확인할 수 있습니다."

#: src/hello/print/fmt.md:72
msgid ""
"Add an implementation of the `fmt::Display` trait for the `Color` struct "
"above so that the output displays as:"
msgstr ""
"위의 `Color` 구조체에 `fmt::Display` 트레이트 구현을 추가하여 다음과 같이 출"
"력되도록 하세요:"

#: src/hello/print/fmt.md:81
msgid "Two hints if you get stuck:"
msgstr "막혔을 때를 위한 두 가지 힌트:"

#: src/hello/print/fmt.md:83
msgid ""
"You [may need to list each color more than once](https://doc.rust-lang.org/"
"std/fmt/#named-parameters)."
msgstr ""
"[각 색상을 두 번 이상 나열해야 할 수도 있습니다](https://doc.rust-lang.org/"
"std/fmt/#named-parameters)."

#: src/hello/print/fmt.md:84
msgid ""
"You can [pad with zeros to a width of 2](https://doc.rust-lang.org/std/fmt/"
"#width) with `:0>2`. For hexadecimals, you can use `:02X`."
msgstr ""
"`:0>2`를 사용하여 [0을 채워 너비를 2로 맞출](https://doc.rust-lang.org/std/"
"fmt/#width) 수 있습니다. 16진수의 경우 `:02X`를 사용할 수 있습니다."

#: src/hello/print/fmt.md:87
msgid "Bonus:"
msgstr "보너스:"

#: src/hello/print/fmt.md:89
msgid ""
"If you would like to experiment with [type casting](../../types/cast.md) in "
"advance, the formula for [calculating a color in the RGB color space]"
"(https://www.rapidtables.com/web/color/RGB_Color.html#rgb-format) is `RGB = "
"(R * 65_536) + (G * 256) + B`, where `R is RED, G is GREEN, and B is BLUE`. "
"An unsigned 8-bit integer (`u8`) can only hold numbers up to 255. To cast "
"`u8` to `u32`, you can write `variable_name as u32`."
msgstr ""
"[타입 변환(type casting)](../../types/cast.md)을 미리 실험해보고 싶다면, "
"[RGB 색 공간에서 색상을 계산하는 공식](https://www.rapidtables.com/web/color/"
"RGB_Color.html#rgb-format)은 `RGB = (R * 65_536) + (G * 256) + B`이며, 여기"
"서 `R은 RED, G는 GREEN, B는 BLUE`입니다. 부호 없는 8비트 정수(`u8`)는 255까지"
"의 숫자만 담을 수 있습니다. `u8`을 `u32`로 변환하려면 `variable_name as u32`"
"와 같이 쓸 수 있습니다."

#: src/hello/print/fmt.md:96
msgid "[`std::fmt`](https://doc.rust-lang.org/std/fmt/)"
msgstr "[`std::fmt`](https://doc.rust-lang.org/std/fmt/)"

#: src/primitives.md:3
msgid ""
"Rust provides access to a wide variety of `primitives`. A sample includes:"
msgstr ""
"Rust는 다양한 `기본 자료형(primitives)`에 대한 접근을 제공합니다. 샘플은 다음"
"과 같습니다:"

#: src/primitives.md:5
msgid "Scalar Types"
msgstr "스칼라 타입"

#: src/primitives.md:7
msgid ""
"Signed integers: `i8`, `i16`, `i32`, `i64`, `i128` and `isize` (pointer size)"
msgstr ""
"부호 있는 정수: `i8`, `i16`, `i32`, `i64`, `i128` 및 `isize` (포인터 크기)"

#: src/primitives.md:8
msgid ""
"Unsigned integers: `u8`, `u16`, `u32`, `u64`, `u128` and `usize` (pointer "
"size)"
msgstr ""
"부호 없는 정수: `u8`, `u16`, `u32`, `u64`, `u128` 및 `usize` (포인터 크기)"

#: src/primitives.md:10
msgid "Floating point: `f32`, `f64`"
msgstr "부동 소수점: `f32`, `f64`"

#: src/primitives.md:11
msgid "`char` Unicode scalar values like `'a'`, `'α'` and `'∞'` (4 bytes each)"
msgstr "`char` 유니코드 스칼라 값: `'a'`, `'α'`, `'∞'` 등 (각 4바이트)"

#: src/primitives.md:12
msgid "`bool` either `true` or `false`"
msgstr "`bool`: `true` 또는 `false`"

#: src/primitives.md:13
msgid "The unit type `()`, whose only possible value is an empty tuple: `()`"
msgstr "유닛 타입 `()`: 가능한 유일한 값은 빈 튜플 `()`입니다."

#: src/primitives.md:15
msgid ""
"Despite the value of a unit type being a tuple, it is not considered a "
"compound type because it does not contain multiple values."
msgstr ""
"유닛 타입의 값이 튜플임에도 불구하고, 여러 값을 포함하지 않기 때문에 복합 타"
"입(compound type)으로 간주되지 않습니다."

#: src/primitives.md:18
msgid "Compound Types"
msgstr "복합 타입"

#: src/primitives.md:20
msgid "Arrays like `[1, 2, 3]`"
msgstr "`[1, 2, 3]`과 같은 배열"

#: src/primitives.md:21
msgid "Tuples like `(1, true)`"
msgstr "`(1, true)`와 같은 튜플"

#: src/primitives.md:23
msgid ""
"Variables can always be _type annotated_. Numbers may additionally be "
"annotated via a _suffix_ or _by default_. Integers default to `i32` and "
"floats to `f64`. Note that Rust can also infer types from context."
msgstr ""
"변수는 항상 _타입 어노테이션_이 가능합니다. 숫자는 추가적으로 _접미사"
"(suffix)_를 통하거나 _기본값_으로 어노테이션될 수 있습니다. 정수 기본값은 "
"`i32`이고 부동 소수점 기본값은 `f64`입니다. 또한 Rust는 문맥으로부터 타입을 "
"추론할 수도 있습니다."

#: src/primitives.md:29
msgid "// Variables can be type annotated.\n"
msgstr "// 변수는 타입 어노테이션이 가능합니다.\n"

#: src/primitives.md:32
msgid "// Regular annotation\n"
msgstr "// 일반적인 어노테이션\n"

#: src/primitives.md:33
msgid "// Suffix annotation\n"
msgstr "// 접미사 어노테이션\n"

#: src/primitives.md:35
msgid "// Or a default will be used.\n"
msgstr "// 혹은 기본값이 사용됩니다.\n"

#: src/primitives.md:36
msgid "// `f64`\n"
msgstr "// `f64`\n"

#: src/primitives.md:37
msgid "// `i32`\n"
msgstr "// `i32`\n"

#: src/primitives.md:39
msgid "// A type can also be inferred from context.\n"
msgstr "// 타입을 문맥에서 추론할 수도 있습니다.\n"

#: src/primitives.md:40
msgid "// Type i64 is inferred from another line.\n"
msgstr "// i64 타입이 다른 줄에서 추론됩니다.\n"

#: src/primitives.md:43
msgid "// A mutable variable's value can be changed.\n"
msgstr "// 가변 변수의 값은 변경될 수 있습니다.\n"

#: src/primitives.md:44
msgid "// Mutable `i32`\n"
msgstr "// 가변 `i32`\n"

#: src/primitives.md:47
msgid "// Error! The type of a variable can't be changed.\n"
msgstr "// 에러! 변수의 타입은 변경할 수 없습니다.\n"

#: src/primitives.md:50
msgid "// Variables can be overwritten with shadowing.\n"
msgstr "// 변수는 섀도잉(shadowing)을 통해 덮어쓸 수 있습니다.\n"

#: src/primitives.md:53
msgid "/* Compound types - Array and Tuple */"
msgstr "/* 복합 타입 - 배열과 튜플 */"

#: src/primitives.md:55
msgid "// Array signature consists of Type T and length as [T; length].\n"
msgstr "// 배열 시그니처는 타입 T와 길이를 포함하여 [T; length] 형식입니다.\n"

#: src/primitives.md:58
msgid ""
"// Tuple is a collection of values of different types\n"
"    // and is constructed using parentheses ().\n"
msgstr ""
"// 튜플은 서로 다른 타입의 값들을 모아놓은 것이며\n"
"    // 소괄호 ()를 사용하여 구성됩니다.\n"

#: src/primitives.md:66
msgid ""
"[the `std` library](https://doc.rust-lang.org/std/), [`mut`]"
"(variable_bindings/mut.md), [`inference`](types/inference.md), and "
"[`shadowing`](variable_bindings/scope.md)"
msgstr ""
"[`std` 라이브러리](https://doc.rust-lang.org/std/), [`mut`]"
"(variable_bindings/mut.md), [`추론(inference)`](types/inference.md), 그리고 "
"[`섀도잉(shadowing)`](variable_bindings/scope.md)"

#: src/primitives/literals.md:3
msgid ""
"Integers `1`, floats `1.2`, characters `'a'`, strings `\"abc\"`, booleans "
"`true` and the unit type `()` can be expressed using literals."
msgstr ""
"정수 `1`, 부동 소수점 `1.2`, 문자 `'a'`, 문자열 `\"abc\"`, 불리언 `true` 그리"
"고 유닛 타입 `()`은 리터럴을 사용하여 표현할 수 있습니다."

#: src/primitives/literals.md:6
msgid ""
"Integers can, alternatively, be expressed using hexadecimal, octal or binary "
"notation using these prefixes respectively: `0x`, `0o` or `0b`."
msgstr ""
"정수는 또한 `0x`, `0o`, `0b` 접두사를 사용하여 각각 16진수, 8진수, 2진수 표기"
"법으로 표현할 수 있습니다."

#: src/primitives/literals.md:9
msgid ""
"Underscores can be inserted in numeric literals to improve readability, e.g. "
"`1_000` is the same as `1000`, and `0.000_001` is the same as `0.000001`."
msgstr ""
"가독성을 높이기 위해 숫자 리터럴에 언더스코어(_)를 삽입할 수 있습니다. 예를 "
"들어 `1_000`은 `1000`과 같고, `0.000_001`은 `0.000001`과 같습니다."

#: src/primitives/literals.md:12
msgid ""
"Rust also supports scientific [E-notation](https://en.wikipedia.org/wiki/"
"Scientific_notation#E_notation), e.g. `1e6`, `7.6e-4`. The associated type "
"is `f64`."
msgstr ""
"Rust는 또한 과학적 기수법([E-표기법](https://en.wikipedia.org/wiki/"
"Scientific_notation#E_notation))을 지원합니다. (예: `1e6`, `7.6e-4`). 관련 타"
"입은 `f64`입니다."

#: src/primitives/literals.md:15
msgid ""
"We need to tell the compiler the type of the literals we use. For now, we'll "
"use the `u32` suffix to indicate that the literal is an unsigned 32-bit "
"integer, and the `i32` suffix to indicate that it's a signed 32-bit integer."
msgstr ""
"우리는 사용하는 리터럴의 타입을 컴파일러에게 알려주어야 합니다. 당분간은 부"
"호 없는 32비트 정수임을 나타내기 위해 `u32` 접미사를 사용하고, 부호 있는 32비"
"트 정수임을 나타내기 위해 `i32` 접미사를 사용할 것입니다."

#: src/primitives/literals.md:19
msgid ""
"The operators available and their precedence [in Rust](https://doc.rust-"
"lang.org/reference/expressions.html#expression-precedence) are similar to "
"other [C-like languages](https://en.wikipedia.org/wiki/"
"Operator_precedence#Programming_languages)."
msgstr ""
"[Rust에서의](https://doc.rust-lang.org/reference/expressions.html#expression-"
"precedence) 사용 가능한 연산자와 우선순위는 다른 [C 계열 언어들](https://"
"en.wikipedia.org/wiki/Operator_precedence#Programming_languages)과 유사합니"
"다."

#: src/primitives/literals.md:24
msgid "// Integer addition\n"
msgstr "// 정수 덧셈\n"

#: src/primitives/literals.md:25
msgid "\"1 + 2 = {}\""
msgstr "\"1 + 2 = {}\""

#: src/primitives/literals.md:27
msgid "// Integer subtraction\n"
msgstr "// 정수 뺄셈\n"

#: src/primitives/literals.md:28
msgid "\"1 - 2 = {}\""
msgstr "\"1 - 2 = {}\""

#: src/primitives/literals.md:29
msgid ""
"// TODO ^ Try changing `1i32` to `1u32` to see why the type is important\n"
msgstr ""
"// TODO ^ `1i32`를 `1u32`로 변경하여 타입이 중요한 이유를 확인해 보세요\n"

#: src/primitives/literals.md:31
msgid "// Scientific notation\n"
msgstr "// 과학적 표기법\n"

#: src/primitives/literals.md:32
msgid "\"1e4 is {}, -2.5e-3 is {}\""
msgstr "\"1e4는 {}, -2.5e-3은 {}입니다\""

#: src/primitives/literals.md:34
msgid "// Short-circuiting boolean logic\n"
msgstr "// 단락(Short-circuiting) 불리언 로직\n"

#: src/primitives/literals.md:35
msgid "\"true AND false is {}\""
msgstr "\"true AND false는 {}입니다\""

#: src/primitives/literals.md:36
msgid "\"true OR false is {}\""
msgstr "\"true OR false는 {}입니다\""

#: src/primitives/literals.md:37
msgid "\"NOT true is {}\""
msgstr "\"NOT true는 {}입니다\""

#: src/primitives/literals.md:39
msgid "// Bitwise operations\n"
msgstr "// 비트 연산\n"

#: src/primitives/literals.md:40
msgid "\"0011 AND 0101 is {:04b}\""
msgstr "\"0011 AND 0101은 {:04b}입니다\""

#: src/primitives/literals.md:41
msgid "\"0011 OR 0101 is {:04b}\""
msgstr "\"0011 OR 0101은 {:04b}입니다\""

#: src/primitives/literals.md:42
msgid "\"0011 XOR 0101 is {:04b}\""
msgstr "\"0011 XOR 0101은 {:04b}입니다\""

#: src/primitives/literals.md:43
msgid "\"1 << 5 is {}\""
msgstr "\"1 << 5는 {}입니다\""

#: src/primitives/literals.md:44
msgid "\"0x80 >> 2 is 0x{:x}\""
msgstr "\"0x80 >> 2는 0x{:x}입니다\""

#: src/primitives/literals.md:46
msgid "// Use underscores to improve readability!\n"
msgstr "// 가독성을 높이기 위해 밑줄을 사용하세요!\n"

#: src/primitives/literals.md:47
msgid "\"One million is written as {}\""
msgstr "\"백만은 {}로 씁니다\""

#: src/primitives/tuples.md:3
msgid ""
"A tuple is a collection of values of different types. Tuples are constructed "
"using parentheses `()`, and each tuple itself is a value with type signature "
"`(T1, T2, ...)`, where `T1`, `T2` are the types of its members. Functions "
"can use tuples to return multiple values, as tuples can hold any number of "
"values."
msgstr ""
"튜플은 서로 다른 타입의 값들의 모음입니다. 튜플은 괄호 `()`를 사용하여 생성되"
"며, 각 튜플 자체는 `(T1, T2, ...)` 형태의 타입 시그니처를 가진 값입니다. 여기"
"서 `T1`, `T2`는 튜플 멤버의 타입입니다. 튜플은 여러 값을 담을 수 있으므로 함"
"수에서 여러 값을 반환하는 데 사용할 수 있습니다."

#: src/primitives/tuples.md:9
msgid "// Tuples can be used as function arguments and as return values.\n"
msgstr "// 튜플은 함수의 인자와 반환값으로 사용될 수 있습니다.\n"

#: src/primitives/tuples.md:11
msgid "// `let` can be used to bind the members of a tuple to variables.\n"
msgstr "// `let`을 사용하여 튜플의 멤버를 변수에 바인딩할 수 있습니다.\n"

#: src/primitives/tuples.md:16
msgid "// The following struct is for the activity.\n"
msgstr "// 다음 구조체는 실습을 위한 것입니다.\n"

#: src/primitives/tuples.md:22
msgid "// A tuple with a bunch of different types.\n"
msgstr "// 여러 다른 타입을 가진 튜플입니다.\n"

#: src/primitives/tuples.md:26 src/generics.md:50 src/generics.md:55
#: src/generics/gen_fn.md:47
msgid "'a'"
msgstr "'a'"

#: src/primitives/tuples.md:28
msgid "// Values can be extracted from the tuple using tuple indexing.\n"
msgstr "// 튜플 인덱싱을 사용하여 튜플에서 값을 추출할 수 있습니다.\n"

#: src/primitives/tuples.md:29
msgid "\"Long tuple first value: {}\""
msgstr "\"긴 튜플의 첫 번째 값: {}\""

#: src/primitives/tuples.md:30
msgid "\"Long tuple second value: {}\""
msgstr "\"긴 튜플의 두 번째 값: {}\""

#: src/primitives/tuples.md:32
msgid "// Tuples can be tuple members.\n"
msgstr "// 튜플은 튜플의 멤버가 될 수 있습니다.\n"

#: src/primitives/tuples.md:35
msgid "// Tuples are printable.\n"
msgstr "// 튜플은 출력 가능합니다.\n"

#: src/primitives/tuples.md:36
msgid "\"tuple of tuples: {:?}\""
msgstr "\"튜플의 튜플: {:?}\""

#: src/primitives/tuples.md:38
msgid ""
"// But long Tuples (more than 12 elements) cannot be printed.\n"
"    //let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);\n"
"    //println!(\"Too long tuple: {:?}\", too_long_tuple);\n"
"    // TODO ^ Uncomment the above 2 lines to see the compiler error\n"
msgstr ""
"// 하지만 긴 튜플(요소 12개 초과)은 출력할 수 없습니다.\n"
"    //let too_long_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13);\n"
"    //println!(\"Too long tuple: {:?}\", too_long_tuple);\n"
"    // TODO ^ 위의 두 줄의 주석을 해제하여 컴파일 에러를 확인해 보세요\n"

#: src/primitives/tuples.md:44
msgid "\"Pair is {:?}\""
msgstr "\"페어는 {:?}입니다\""

#: src/primitives/tuples.md:46
msgid "\"The reversed pair is {:?}\""
msgstr "\"반전된 페어는 {:?}입니다\""

#: src/primitives/tuples.md:48
msgid ""
"// To create one element tuples, the comma is required to tell them apart\n"
"    // from a literal surrounded by parentheses.\n"
msgstr ""
"// 요소가 하나인 튜플을 만들려면, 괄호로 둘러싸인 리터럴과\n"
"    // 구분하기 위해 콤마가 필요합니다.\n"

#: src/primitives/tuples.md:50
msgid "\"One element tuple: {:?}\""
msgstr "\"요소가 하나인 튜플: {:?}\""

#: src/primitives/tuples.md:51
msgid "\"Just an integer: {:?}\""
msgstr "\"그냥 정수: {:?}\""

#: src/primitives/tuples.md:53
msgid "// Tuples can be destructured to create bindings.\n"
msgstr "// 튜플은 구조 분해(destructure)하여 바인딩을 생성할 수 있습니다.\n"

#: src/primitives/tuples.md:54 src/conversion/from_into.md:17
#: src/fn/closures/input_parameters.md:52 src/std_misc/fs.md:51
msgid "\"hello\""
msgstr "\"안녕\""

#: src/primitives/tuples.md:57
msgid "\"{:?}, {:?}, {:?}, {:?}\""
msgstr "\"{:?}, {:?}, {:?}, {:?}\""

#: src/primitives/tuples.md:66
msgid ""
"_Recap_: Add the `fmt::Display` trait to the `Matrix` struct in the above "
"example, so that if you switch from printing the debug format `{:?}` to the "
"display format `{}`, you see the following output:"
msgstr ""
"_요약_: 위 예제의 `Matrix` 구조체에 `fmt::Display` 트레이트를 추가하여, 디버"
"그 형식 `{:?}`에서 디스플레이 형식 `{}`로 출력을 전환했을 때 다음과 같은 출력"
"이 나오도록 하세요:"

#: src/primitives/tuples.md:75
msgid ""
"You may want to refer back to the example for [print display](../hello/print/"
"print_display.md)."
msgstr ""
"[표시 출력](../hello/print/print_display.md)에 대한 예제를 다시 참조하고 싶"
"을 수도 있습니다."

#: src/primitives/tuples.md:76
msgid ""
"Add a `transpose` function using the `reverse` function as a template, which "
"accepts a matrix as an argument, and returns a matrix in which two elements "
"have been swapped. For example:"
msgstr ""
"`reverse` 함수를 템플릿으로 사용하여 `transpose` 함수를 추가하세요. 이 함수"
"는 행렬을 인자로 받아 두 요소가 바뀐 행렬을 반환합니다. 예를 들어:"

#: src/primitives/tuples.md:81
msgid "\"Matrix:\\n{}\""
msgstr "\"행렬:\\n{}\""

#: src/primitives/tuples.md:82
msgid "\"Transpose:\\n{}\""
msgstr "\"전치(Transpose):\\n{}\""

#: src/primitives/tuples.md:85
msgid "Results in the output:"
msgstr "출력 결과:"

#: src/primitives/array.md:3
msgid ""
"An array is a collection of objects of the same type `T`, stored in "
"contiguous memory. Arrays are created using brackets `[]`, and their length, "
"which is known at compile time, is part of their type signature `[T; "
"length]`."
msgstr ""
"배열은 연속된 메모리에 저장된 동일한 타입 `T`를 가진 객체들의 모음입니다. 배"
"열은 대괄호 `[]`를 사용하여 생성되며, 컴파일 타임에 알려진 배열의 길이는 타"
"입 시그니처 `[T; length]`의 일부가 됩니다."

#: src/primitives/array.md:7
msgid ""
"Slices are similar to arrays, but their length is not known at compile time. "
"Instead, a slice is a two-word object; the first word is a pointer to the "
"data, the second word is the length of the slice. The word size is the same "
"as usize, determined by the processor architecture, e.g. 64 bits on an "
"x86-64. Slices can be used to borrow a section of an array and have the type "
"signature `&[T]`."
msgstr ""
"슬라이스는 배열과 유사하지만, 컴파일 타임에 그 길이를 알 수 없습니다. 대신, "
"슬라이스는 두 개의 워드(word)로 구성된 객체입니다. 첫 번째 워드는 데이터에 대"
"한 포인터이고, 두 번째 워드는 슬라이스의 길이입니다. 워드 크기는 프로세서 아"
"키텍처에 의해 결정되는 usize와 같으며, 예를 들어 x86-64에서는 64비트입니다. "
"슬라이스는 배열의 일부분을 빌려오는 데 사용될 수 있으며 `&[T]`라는 타입 시그"
"니처를 가집니다."

#: src/primitives/array.md:15
msgid "// This function borrows a slice.\n"
msgstr "// 이 함수는 슬라이스를 빌려옵니다.\n"

#: src/primitives/array.md:18
msgid "\"First element of the slice: {}\""
msgstr "\"슬라이스의 첫 번째 요소: {}\""

#: src/primitives/array.md:19
msgid "\"The slice has {} elements\""
msgstr "\"슬라이스는 {}개의 요소를 가지고 있습니다\""

#: src/primitives/array.md:23
msgid "// Fixed-size array (type signature is superfluous).\n"
msgstr "// 고정 크기 배열 (타입 시그니처는 생략 가능합니다).\n"

#: src/primitives/array.md:26
msgid "// All elements can be initialized to the same value.\n"
msgstr "// 모든 요소를 동일한 값으로 초기화할 수 있습니다.\n"

#: src/primitives/array.md:29
msgid "// Indexing starts at 0.\n"
msgstr "// 인덱싱은 0부터 시작합니다.\n"

#: src/primitives/array.md:30
msgid "\"First element of the array: {}\""
msgstr "\"배열의 첫 번째 요소: {}\""

#: src/primitives/array.md:31
msgid "\"Second element of the array: {}\""
msgstr "\"배열의 두 번째 요소: {}\""

#: src/primitives/array.md:33
msgid "// `len` returns the count of elements in the array.\n"
msgstr "// `len`은 배열의 요소 개수를 반환합니다.\n"

#: src/primitives/array.md:34
msgid "\"Number of elements in array: {}\""
msgstr "\"배열의 요소 개수: {}\""

#: src/primitives/array.md:36
msgid "// Arrays are stack allocated.\n"
msgstr "// 배열은 스택에 할당됩니다.\n"

#: src/primitives/array.md:37
msgid "\"Array occupies {} bytes\""
msgstr "\"배열의 점유 메모리: {} 바이트\""

#: src/primitives/array.md:39
msgid "// Arrays can be automatically borrowed as slices.\n"
msgstr "// 배열은 자동으로 슬라이스로 빌려올 수 있습니다.\n"

#: src/primitives/array.md:40
msgid "\"Borrow the whole array as a slice.\""
msgstr "\"배열 전체를 슬라이스로 빌려옵니다.\""

#: src/primitives/array.md:43
msgid ""
"// Slices can point to a section of an array.\n"
"    // They are of the form [starting_index..ending_index].\n"
"    // `starting_index` is the first position in the slice.\n"
"    // `ending_index` is one more than the last position in the slice.\n"
msgstr ""
"// 슬라이스는 배열의 한 섹션을 가리킬 수 있습니다.\n"
"    // [시작_인덱스..종료_인덱스] 형태입니다.\n"
"    // `시작_인덱스`는 슬라이스의 첫 번째 위치입니다.\n"
"    // `종료_인덱스`는 슬라이스의 마지막 위치보다 하나 더 큰 값입니다.\n"

#: src/primitives/array.md:47
msgid "\"Borrow a section of the array as a slice.\""
msgstr "\"배열의 한 섹션을 슬라이스로 빌려옵니다.\""

#: src/primitives/array.md:50
msgid "// Example of empty slice `&[]`:\n"
msgstr "// 빈 슬라이스 `&[]`의 예시:\n"

#: src/primitives/array.md:53
msgid "// Same but more verbose\n"
msgstr "// 동일하지만 더 장황한 표현\n"

#: src/primitives/array.md:55
msgid ""
"// Arrays can be safely accessed using `.get`, which returns an\n"
"    // `Option`. This can be matched as shown below, or used with\n"
"    // `.expect()` if you would like the program to exit with a nice\n"
"    // message instead of happily continue.\n"
msgstr ""
"// 배열은 `.get`을 사용하여 안전하게 접근할 수 있으며, 이는 `Option`을 반환합"
"니다.\n"
"    // 이는 아래와 같이 매치(match)될 수 있으며, 프로그램을 계속 진행하는 대"
"신\n"
"    // 친절한 메시지와 함께 종료하고 싶다면 `.expect()`와 함께 사용될 수 있습"
"니다.\n"

#: src/primitives/array.md:59
msgid "// Oops, one element too far!\n"
msgstr "// 이런, 범위를 하나 벗어났네요!\n"

#: src/primitives/array.md:61
msgid "\"{}: {}\""
msgstr "\"{}: {}\""

#: src/primitives/array.md:62
msgid "\"Slow down! {} is too far!\""
msgstr "\"진정하세요! {}는 너무 멀리 갔습니다!\""

#: src/primitives/array.md:66
msgid ""
"// Out of bound indexing on array with constant value causes compile time "
"error.\n"
"    //println!(\"{}\", xs[5]);\n"
"    // Out of bound indexing on slice causes runtime error.\n"
"    //println!(\"{}\", xs[..][5]);\n"
msgstr ""
"// 상수 값을 사용한 배열의 범위를 벗어난 인덱싱은 컴파일 타임 에러를 발생시킵"
"니다.\n"
"    //println!(\"{}\", xs[5]);\n"
"    // 슬라이스에서 범위를 벗어난 인덱싱은 런타임 에러를 발생시킵니다.\n"
"    //println!(\"{}\", xs[..][5]);\n"

#: src/custom_types.md:3
msgid "Rust custom data types are formed mainly through the two keywords:"
msgstr ""
"Rust의 사용자 정의 데이터 타입은 주로 다음 두 키워드를 통해 형성됩니다:"

#: src/custom_types.md:5
msgid "`struct`: define a structure"
msgstr "`struct`: 구조체를 정의합니다"

#: src/custom_types.md:6
msgid "`enum`: define an enumeration"
msgstr "`enum`: 열거형을 정의합니다"

#: src/custom_types.md:8
msgid "Constants can also be created via the `const` and `static` keywords."
msgstr "상수는 `const`와 `static` 키워드를 통해 생성할 수 있습니다."

#: src/custom_types/structs.md:3
msgid ""
"There are three types of structures (\"structs\") that can be created using "
"the `struct` keyword:"
msgstr ""
"`struct` 키워드를 사용하여 생성할 수 있는 구조체(\"structs\")에는 세 가지 유"
"형이 있습니다:"

#: src/custom_types/structs.md:6
msgid "Tuple structs, which are, basically, named tuples."
msgstr "기본적으로 이름이 붙은 튜플인 튜플 구조체."

#: src/custom_types/structs.md:7
msgid ""
"The classic [C structs](https://en.wikipedia.org/wiki/"
"Struct_(C_programming_language))"
msgstr ""
"전통적인 [C 구조체](https://en.wikipedia.org/wiki/"
"Struct_(C_programming_language))"

#: src/custom_types/structs.md:8
msgid "Unit structs, which are field-less, are useful for generics."
msgstr "필드가 없는 유닛 구조체로, 제네릭에 유용합니다."

#: src/custom_types/structs.md:11 src/custom_types/enum/enum_use.md:6
#: src/custom_types/enum/c_like.md:6
msgid "// An attribute to hide warnings for unused code.\n"
msgstr "// 사용되지 않는 코드에 대한 경고를 숨기기 위한 속성입니다.\n"

#: src/custom_types/structs.md:19
msgid "// A unit struct\n"
msgstr "// 유닛 구조체\n"

#: src/custom_types/structs.md:22
msgid "// A tuple struct\n"
msgstr "// 튜플 구조체\n"

#: src/custom_types/structs.md:25
msgid "// A struct with two fields\n"
msgstr "// 두 개의 필드를 가진 구조체\n"

#: src/custom_types/structs.md:31
msgid "// Structs can be reused as fields of another struct\n"
msgstr "// 구조체는 다른 구조체의 필드로 재사용될 수 있습니다.\n"

#: src/custom_types/structs.md:34
msgid ""
"// A rectangle can be specified by where the top left and bottom right\n"
"    // corners are in space.\n"
msgstr ""
"// 사각형은 공간상에서 왼쪽 위와 오른쪽 아래 모서리의 위치로 지정될 수 있습니"
"다.\n"

#: src/custom_types/structs.md:41
msgid "// Create struct with field init shorthand\n"
msgstr "// 필드 초기화 축약형(field init shorthand)으로 구조체를 생성합니다.\n"

#: src/custom_types/structs.md:46
msgid "// Print debug struct\n"
msgstr "// 디버그용 구조체 출력\n"

#: src/custom_types/structs.md:49
msgid "// Instantiate a `Point`\n"
msgstr "// `Point` 인스턴스 생성\n"

#: src/custom_types/structs.md:53
msgid "// Access the fields of the point\n"
msgstr "// 좌표의 필드에 접근\n"

#: src/custom_types/structs.md:54
msgid "\"point coordinates: ({}, {})\""
msgstr "\"좌표 좌표: ({}, {})\""

#: src/custom_types/structs.md:56
msgid ""
"// Make a new point by using struct update syntax to use the fields of our\n"
"    // other one\n"
msgstr ""
"// 구조체 업데이트 구문을 사용하여 다른 포인트의 필드를 활용해\n"
"    // 새로운 포인트를 만듭니다.\n"

#: src/custom_types/structs.md:60
msgid ""
"// `bottom_right.y` will be the same as `another_point.y` because we used "
"that field\n"
"    // from `another_point`\n"
msgstr ""
"// `another_point`의 필드를 사용했으므로 `bottom_right.y`는 `another_point.y`"
"와 동일합니다.\n"

#: src/custom_types/structs.md:62
msgid "\"second point: ({}, {})\""
msgstr "\"두 번째 좌표: ({}, {})\""

#: src/custom_types/structs.md:64
msgid "// Destructure the point using a `let` binding\n"
msgstr "// `let` 바인딩을 사용하여 좌표를 구조 분해합니다.\n"

#: src/custom_types/structs.md:68
msgid "// struct instantiation is an expression too\n"
msgstr "// 구조체 인스턴스 생성은 표현식이기도 합니다.\n"

#: src/custom_types/structs.md:73
msgid "// Instantiate a unit struct\n"
msgstr "// 유닛 구조체 인스턴스 생성\n"

#: src/custom_types/structs.md:76
msgid "// Instantiate a tuple struct\n"
msgstr "// 튜플 구조체 인스턴스 생성\n"

#: src/custom_types/structs.md:79
msgid "// Access the fields of a tuple struct\n"
msgstr "// 튜플 구조체의 필드에 접근\n"

#: src/custom_types/structs.md:80 src/custom_types/structs.md:85
msgid "\"pair contains {:?} and {:?}\""
msgstr "\"페어는 {:?}와 {:?}를 포함합니다\""

#: src/custom_types/structs.md:82
msgid "// Destructure a tuple struct\n"
msgstr "// 튜플 구조체 구조 분해\n"

#: src/custom_types/structs.md:91
msgid ""
"Add a function `rect_area` which calculates the area of a `Rectangle` (try "
"using nested destructuring)."
msgstr ""
"`Rectangle`의 넓이를 계산하는 `rect_area` 함수를 추가하세요. (중첩된 구조 분"
"해를 사용해 보세요)."

#: src/custom_types/structs.md:93
msgid ""
"Add a function `square` which takes a `Point` and a `f32` as arguments, and "
"returns a `Rectangle` with its top left corner on the point, and a width and "
"height corresponding to the `f32`."
msgstr ""
"`Point`와 `f32`를 인자로 받아, 해당 포인트를 왼쪽 위 모서리로 하고 `f32`에 해"
"당하는 너비와 높이를 가진 `Rectangle`을 반환하는 `square` 함수를 추가하세요."

#: src/custom_types/structs.md:97
msgid "See also"
msgstr "참고"

#: src/custom_types/structs.md:99
msgid ""
"[`attributes`](../attribute.md), [raw identifiers](../compatibility/"
"raw_identifiers.md) and [destructuring](../flow_control/match/"
"destructuring.md)"
msgstr ""
"[`속성`](../attribute.md), [raw 식별자](../compatibility/raw_identifiers.md) "
"및 [구조 분해](../flow_control/match/destructuring.md)"

#: src/custom_types/enum.md:3
msgid ""
"The `enum` keyword allows the creation of a type which may be one of a few "
"different variants. Any variant which is valid as a `struct` is also valid "
"in an `enum`."
msgstr ""
"`enum` 키워드는 몇 가지 다른 변체 중 하나일 수 있는 타입을 생성할 수 있게 합"
"니다. `struct`로 유효한 모든 변체는 `enum`에서도 유효합니다."

#: src/custom_types/enum.md:8
msgid ""
"// Create an `enum` to classify a web event. Note how both\n"
"// names and type information together specify the variant:\n"
"// `PageLoad != PageUnload` and `KeyPress(char) != Paste(String)`.\n"
"// Each is different and independent.\n"
msgstr ""
"// 웹 이벤트를 분류하기 위한 `enum`을 생성합니다. 이름과 타입 정보가\n"
"// 함께 변체를 지정하는 방식에 주목하세요:\n"
"// `PageLoad != PageUnload` 이고 `KeyPress(char) != Paste(String)` 입니다.\n"
"// 각각은 서로 다르고 독립적입니다.\n"

#: src/custom_types/enum.md:13
msgid "// An `enum` variant may either be `unit-like`,\n"
msgstr "// `enum` 변체는 유닛 형태(unit-like)일 수도 있고,\n"

#: src/custom_types/enum.md:16
msgid "// like tuple structs,\n"
msgstr "// 튜플 구조체 형태일 수도 있으며,\n"

#: src/custom_types/enum.md:19
msgid "// or c-like structures.\n"
msgstr "// 또는 C 구조체 형태일 수도 있습니다.\n"

#: src/custom_types/enum.md:22
msgid ""
"// A function which takes a `WebEvent` enum as an argument and\n"
"// returns nothing.\n"
msgstr ""
"// `WebEvent` 열거형을 인자로 받고 아무것도 반환하지 않는 함수입니다.\n"

#: src/custom_types/enum.md:27
msgid "\"page loaded\""
msgstr "\"페이지 로드됨\""

#: src/custom_types/enum.md:28
msgid "\"page unloaded\""
msgstr "\"페이지 언로드됨\""

#: src/custom_types/enum.md:29
msgid "// Destructure `c` from inside the `enum` variant.\n"
msgstr "// `enum` 변체 내부에서 `c`를 구조 분해합니다.\n"

#: src/custom_types/enum.md:30
msgid "\"pressed '{}'.\""
msgstr "\"'{}' 키가 눌렸습니다.\""

#: src/custom_types/enum.md:31
msgid "\"pasted \\\"{}\\\".\""
msgstr "\"\\\"{}\\\"가 붙여넣기 되었습니다.\""

#: src/custom_types/enum.md:32
msgid "// Destructure `Click` into `x` and `y`.\n"
msgstr "// `Click`을 `x`와 `y`로 구조 분해합니다.\n"

#: src/custom_types/enum.md:34
msgid "\"clicked at x={}, y={}.\""
msgstr "\"x={}, y={} 지점이 클릭되었습니다.\""

#: src/custom_types/enum.md:40
msgid "'x'"
msgstr "'x'"

#: src/custom_types/enum.md:41
msgid "// `to_owned()` creates an owned `String` from a string slice.\n"
msgstr ""
"// `to_owned()`는 문자열 슬라이스로부터 소유권이 있는 `String`을 생성합니"
"다.\n"

#: src/custom_types/enum.md:42
msgid "\"my text\""
msgstr "\"나의 텍스트\""

#: src/custom_types/enum.md:56
msgid "Type aliases"
msgstr "타입 별칭"

#: src/custom_types/enum.md:58
msgid ""
"If you use a type alias, you can refer to each enum variant via its alias. "
"This might be useful if the enum's name is too long or too generic, and you "
"want to rename it."
msgstr ""
"타입 별칭을 사용하면, 별칭을 통해 각 열거형 변체를 참조할 수 있습니다. 이는 "
"열거형의 이름이 너무 길거나 너무 일반적이어서 이름을 바꾸고 싶을 때 유용할 "
"수 있습니다."

#: src/custom_types/enum.md:67
msgid "// Creates a type alias\n"
msgstr "// 타입 별칭을 생성합니다\n"

#: src/custom_types/enum.md:72
msgid ""
"// We can refer to each variant via its alias, not its long and "
"inconvenient\n"
"    // name.\n"
msgstr "// 길고 불편한 이름 대신 별칭을 통해 각 변체를 참조할 수 있습니다.\n"

#: src/custom_types/enum.md:78
msgid ""
"The most common place you'll see this is in `impl` blocks using the `Self` "
"alias."
msgstr ""
"이를 가장 흔히 볼 수 있는 곳은 `Self` 별칭을 사용하는 `impl` 블록 내부입니다."

#: src/custom_types/enum.md:96
msgid ""
"To learn more about enums and type aliases, you can read the [stabilization "
"report](https://github.com/rust-lang/rust/pull/61682/"
"#issuecomment-502472847) from when this feature was stabilized into Rust."
msgstr ""
"열거형과 타입 별칭에 대해 더 자세히 알아보려면, 이 기능이 Rust에서 안정화되었"
"을 때의 [안정화 보고서](https://github.com/rust-lang/rust/pull/61682/"
"#issuecomment-502472847)를 읽어보세요."

#: src/custom_types/enum.md:102
msgid ""
"[`match`](../flow_control/match.md), [`fn`](../fn.md), and [`String`](../std/"
"str.md), [\"Type alias enum variants\" RFC](https://rust-lang.github.io/rfcs/"
"2338-type-alias-enum-variants.html)"
msgstr ""
"[`match`](../flow_control/match.md), [`fn`](../fn.md), 그리고 [`String`](../"
"std/str.md), [\"타입 별칭 열거형 변체\" RFC](https://rust-lang.github.io/"
"rfcs/2338-type-alias-enum-variants.html)"

#: src/custom_types/enum/enum_use.md:3
msgid ""
"The `use` declaration can be used to avoid typing the full module path to "
"access a name:"
msgstr ""
"`use` 선언을 사용하면 이름을 사용하기 위해 전체 모듈 경로를 입력하는 것을 피"
"할 수 있습니다:"

#: src/custom_types/enum/enum_use.md:20
msgid ""
"// Explicitly `use` each name so they are available without\n"
"    // manual scoping.\n"
msgstr ""
"// 각 이름을 명시적으로 `use`하여 수동으로 스코프를 지정하지 않고도\n"
"    // 사용할 수 있게 합니다.\n"

#: src/custom_types/enum/enum_use.md:23
msgid "// Automatically `use` each name inside `Role`.\n"
msgstr "// `Role` 내부의 각 이름을 자동으로 `use`합니다.\n"

#: src/custom_types/enum/enum_use.md:26
msgid "// Equivalent to `Stage::Beginner`.\n"
msgstr "// `Stage::Beginner`와 동일합니다.\n"

#: src/custom_types/enum/enum_use.md:28
msgid "// Equivalent to `Role::Student`.\n"
msgstr "// `Role::Student`와 동일합니다.\n"

#: src/custom_types/enum/enum_use.md:32
msgid "// Note the lack of scoping because of the explicit `use` above.\n"
msgstr "// 위의 명시적 `use` 덕분에 스코프 지정이 필요 없음에 주목하세요.\n"

#: src/custom_types/enum/enum_use.md:33
msgid "\"Beginners are starting their learning journey!\""
msgstr "\"초보자들이 학습 여정을 시작합니다!\""

#: src/custom_types/enum/enum_use.md:34
msgid "\"Advanced learners are mastering their subjects...\""
msgstr "\"상급 학습자들이 주제를 마스터하고 있습니다...\""

#: src/custom_types/enum/enum_use.md:38
msgid "// Note again the lack of scoping.\n"
msgstr "// 다시 한번 스코프 지정이 없음에 주목하세요.\n"

#: src/custom_types/enum/enum_use.md:39
msgid "\"Students are acquiring knowledge!\""
msgstr "\"학생들이 지식을 습득하고 있습니다!\""

#: src/custom_types/enum/enum_use.md:40
msgid "\"Teachers are spreading knowledge!\""
msgstr "\"교사들이 지식을 전파하고 있습니다!\""

#: src/custom_types/enum/enum_use.md:47
msgid "[`match`](../../flow_control/match.md) and [`use`](../../mod/use.md)"
msgstr "[`match`](../../flow_control/match.md)와 [`use`](../../mod/use.md)"

#: src/custom_types/enum/c_like.md:3
msgid "`enum` can also be used as C-like enums."
msgstr "`enum`은 C 스타일의 열거형으로도 사용될 수 있습니다."

#: src/custom_types/enum/c_like.md:8
msgid "// enum with implicit discriminator (starts at 0)\n"
msgstr "// 암시적 식별자(0부터 시작)를 가진 열거형\n"

#: src/custom_types/enum/c_like.md:15
msgid "// enum with explicit discriminator\n"
msgstr "// 명시적 식별자를 가진 열거형\n"

#: src/custom_types/enum/c_like.md:24
msgid "// `enums` can be cast as integers.\n"
msgstr "// `enum`은 정수로 형변환(cast)될 수 있습니다.\n"

#: src/custom_types/enum/c_like.md:25
msgid "\"zero is {}\""
msgstr "\"0은 {}입니다\""

#: src/custom_types/enum/c_like.md:26
msgid "\"one is {}\""
msgstr "\"1은 {}입니다\""

#: src/custom_types/enum/c_like.md:28
msgid "\"roses are #{:06x}\""
msgstr "\"장미는 #{:06x}색입니다\""

#: src/custom_types/enum/c_like.md:29
msgid "\"violets are #{:06x}\""
msgstr "\"제비꽃은 #{:06x}색입니다\""

#: src/custom_types/enum/c_like.md:35
msgid "[casting](../../types/cast.md)"
msgstr "[형변환](../../types/cast.md)"

#: src/custom_types/enum/testcase_linked_list.md:3
msgid "A common way to implement a linked-list is via `enums`:"
msgstr "연결 리스트를 구현하는 일반적인 방법은 `enums`를 사용하는 것입니다:"

#: src/custom_types/enum/testcase_linked_list.md:9
msgid ""
"// Cons: Tuple struct that wraps an element and a pointer to the next node\n"
msgstr "// Cons: 요소와 다음 노드에 대한 포인터를 감싸는 튜플 구조체\n"

#: src/custom_types/enum/testcase_linked_list.md:11
msgid "// Nil: A node that signifies the end of the linked list\n"
msgstr "// Nil: 연결 리스트의 끝을 나타내는 노드\n"

#: src/custom_types/enum/testcase_linked_list.md:14
msgid "// Methods can be attached to an enum\n"
msgstr "// 열거형에 메서드를 붙일 수 있습니다\n"

#: src/custom_types/enum/testcase_linked_list.md:17
msgid "// Create an empty list\n"
msgstr "// 빈 리스트를 생성합니다\n"

#: src/custom_types/enum/testcase_linked_list.md:19
msgid "// `Nil` has type `List`\n"
msgstr "// `Nil`은 `List` 타입을 가집니다\n"

#: src/custom_types/enum/testcase_linked_list.md:23
msgid ""
"// Consume a list, and return the same list with a new element at its front\n"
msgstr ""
"// 리스트를 소비하고, 그 앞에 새로운 요소가 추가된 동일한 리스트를 반환합니"
"다\n"

#: src/custom_types/enum/testcase_linked_list.md:25
msgid "// `Cons` also has type List\n"
msgstr "// `Cons` 역시 `List` 타입을 가집니다\n"

#: src/custom_types/enum/testcase_linked_list.md:29
msgid "// Return the length of the list\n"
msgstr "// 리스트의 길이를 반환합니다\n"

#: src/custom_types/enum/testcase_linked_list.md:31
msgid ""
"// `self` has to be matched, because the behavior of this method\n"
"        // depends on the variant of `self`\n"
"        // `self` has type `&List`, and `*self` has type `List`, matching on "
"a\n"
"        // concrete type `T` is preferred over a match on a reference `&T`\n"
"        // after Rust 2018 you can use self here and tail (with no ref) "
"below as well,\n"
"        // rust will infer &s and ref tail.\n"
"        // See https://doc.rust-lang.org/edition-guide/rust-2018/ownership-"
"and-lifetimes/default-match-bindings.html\n"
msgstr ""
"// 메서드의 동작이 `self`의 변체에 따라 달라지므로 `self`에 대해 매치(match)"
"를 수행해야 합니다.\n"
"        // `self`는 `&List` 타입이고, `*self`는 `List` 타입입니다. 구체적인 "
"타입 `T`에 대한 매칭이\n"
"        // 참조 `&T`에 대한 매칭보다 선호됩니다.\n"
"        // Rust 2018 이후에는 여기서 self를 사용하고 아래에서 tail(ref 없이)"
"을 사용할 수도 있습니다.\n"
"        // Rust가 &s와 ref tail을 추론할 것입니다.\n"
"        // 참고: https://doc.rust-lang.org/edition-guide/rust-2018/ownership-"
"and-lifetimes/default-match-bindings.html\n"

#: src/custom_types/enum/testcase_linked_list.md:39
msgid ""
"// Can't take ownership of the tail, because `self` is borrowed;\n"
"            // instead take a reference to the tail\n"
"            // And it's a non-tail recursive call which may cause stack "
"overflow for long lists.\n"
msgstr ""
"// `self`가 빌려온 상태이므로 꼬리(tail)의 소유권을 가질 수 없습니다.\n"
"            // 대신 꼬리에 대한 참조를 가져옵니다.\n"
"            // 그리고 이것은 꼬리 재귀가 아닌 호출이므로 긴 리스트의 경우 스"
"택 오버플로우가 발생할 수 있습니다.\n"

#: src/custom_types/enum/testcase_linked_list.md:43
msgid "// Base Case: An empty list has zero length\n"
msgstr "// 기저 사례(Base Case): 빈 리스트의 길이는 0입니다\n"

#: src/custom_types/enum/testcase_linked_list.md:48
msgid "// Return representation of the list as a (heap allocated) string\n"
msgstr "// 리스트를 (힙에 할당된) 문자열 표현으로 반환합니다\n"

#: src/custom_types/enum/testcase_linked_list.md:52
msgid ""
"// `format!` is similar to `print!`, but returns a heap\n"
"                // allocated string instead of printing to the console\n"
msgstr ""
"// `format!`은 `print!`와 유사하지만, 콘솔에 출력하는 대신\n"
"                // 힙에 할당된 문자열을 반환합니다\n"

#: src/custom_types/enum/testcase_linked_list.md:54 src/generics/impl.md:44
msgid "\"{}, {}\""
msgstr "\"{}, {}\""

#: src/custom_types/enum/testcase_linked_list.md:57
msgid "\"Nil\""
msgstr "\"Nil\""

#: src/custom_types/enum/testcase_linked_list.md:64
msgid "// Create an empty linked list\n"
msgstr "// 빈 연결 리스트를 생성합니다\n"

#: src/custom_types/enum/testcase_linked_list.md:67
msgid "// Prepend some elements\n"
msgstr "// 몇 가지 요소를 앞에 추가합니다\n"

#: src/custom_types/enum/testcase_linked_list.md:72
msgid "// Show the final state of the list\n"
msgstr "// 리스트의 최종 상태를 보여줍니다\n"

#: src/custom_types/enum/testcase_linked_list.md:73
msgid "\"linked list has length: {}\""
msgstr "\"연결 리스트의 길이는 {}입니다\""

#: src/custom_types/enum/testcase_linked_list.md:80
msgid "[`Box`](../../std/box.md) and [methods](../../fn/methods.md)"
msgstr "[`Box`](../../std/box.md)와 [메서드](../../fn/methods.md)"

#: src/custom_types/constants.md:3
msgid ""
"Rust has two different types of constants which can be declared in any scope "
"including global. Both require explicit type annotation:"
msgstr ""
"Rust에는 전역 범위를 포함한 모든 범위에서 선언할 수 있는 두 가지 유형의 상수"
"가 있습니다. 둘 다 명시적인 타입 어노테이션이 필요합니다:"

#: src/custom_types/constants.md:6
msgid "`const`: An unchangeable value (the common case)."
msgstr "`const`: 변경할 수 없는 값 (일반적인 경우)."

#: src/custom_types/constants.md:7
msgid ""
"`static`: A possibly mutable variable with [`'static`](../scope/lifetime/"
"static_lifetime.md) lifetime. The static lifetime is inferred and does not "
"have to be specified. Accessing or modifying a mutable static variable is "
"[`unsafe`](../unsafe.md)."
msgstr ""
"`static`: [`'static`](../scope/lifetime/static_lifetime.md) 라이프타임을 가"
"진, 가변적일 수 있는 변수입니다. static 라이프타임은 추론되므로 명시할 필요"
"는 없습니다. 가변적인 static 변수에 접근하거나 수정하는 것은 [`unsafe`](../"
"unsafe.md)합니다."

#: src/custom_types/constants.md:12
msgid "// Globals are declared outside all other scopes.\n"
msgstr "// 전역 변수는 다른 모든 범위의 바깥에 선언됩니다.\n"

#: src/custom_types/constants.md:13
msgid "\"Rust\""
msgstr "\"러스트\""

#: src/custom_types/constants.md:17
msgid "// Access constant in some function\n"
msgstr "// 어떤 함수 내에서 상수에 접근\n"

#: src/custom_types/constants.md:24
msgid "// Access constant in the main thread\n"
msgstr "// 메인 스레드에서 상수에 접근\n"

#: src/custom_types/constants.md:25
msgid "\"This is {}\""
msgstr "\"이것은 {}입니다\""

#: src/custom_types/constants.md:26
msgid "\"The threshold is {}\""
msgstr "\"임계값은 {}입니다\""

#: src/custom_types/constants.md:27
msgid "\"{} is {}\""
msgstr "\"{}은(는) {}입니다\""

#: src/custom_types/constants.md:27
msgid "\"big\""
msgstr "\"큰\""

#: src/custom_types/constants.md:27
msgid "\"small\""
msgstr "\"작은\""

#: src/custom_types/constants.md:29
msgid "// Error! Cannot modify a `const`.\n"
msgstr "// 에러! `const`는 수정할 수 없습니다.\n"

#: src/custom_types/constants.md:31 src/variable_bindings/scope.md:22
#: src/variable_bindings/declare.md:27 src/variable_bindings/freeze.md:16
#: src/types/cast.md:19 src/types/cast.md:28 src/flow_control/for.md:95
#: src/scope/borrow.md:41 src/scope/borrow/mut.md:52 src/std/vec.md:32
#: src/std/vec.md:45 src/std/hash/hashset.md:48
msgid "// FIXME ^ Comment out this line\n"
msgstr "// FIXME ^ 이 줄을 주석 처리하세요\n"

#: src/custom_types/constants.md:37
msgid ""
"[The `const`/`static` RFC](https://github.com/rust-lang/rfcs/blob/master/"
"text/0246-const-vs-static.md), [`'static` lifetime](../scope/lifetime/"
"static_lifetime.md)"
msgstr ""
"[`const`/`static` RFC](https://github.com/rust-lang/rfcs/blob/master/text/"
"0246-const-vs-static.md), [`'static` 라이프타임](../scope/lifetime/"
"static_lifetime.md)"

#: src/variable_bindings.md:3
msgid ""
"Rust provides type safety via static typing. Variable bindings can be type "
"annotated when declared. However, in most cases, the compiler will be able "
"to infer the type of the variable from the context, heavily reducing the "
"annotation burden."
msgstr ""
"Rust는 정적 타이핑을 통해 타입 안전성을 제공합니다. 변수 바인딩은 선언 시 타"
"입 어노테이션을 할 수 있습니다. 하지만 대부분의 경우, 컴파일러는 문맥으로부"
"터 변수의 타입을 추론할 수 있어 어노테이션의 부담을 크게 줄여줍니다."

#: src/variable_bindings.md:8
msgid ""
"Values (like literals) can be bound to variables, using the `let` binding."
msgstr "값(리터럴 등)은 `let` 바인딩을 사용하여 변수에 바인딩될 수 있습니다."

#: src/variable_bindings.md:16
msgid "// copy `an_integer` into `copied_integer`\n"
msgstr "// `an_integer`를 `copied_integer`로 복사합니다\n"

#: src/variable_bindings.md:19
msgid "\"An integer: {:?}\""
msgstr "\"정수: {:?}\""

#: src/variable_bindings.md:20
msgid "\"A boolean: {:?}\""
msgstr "\"불리언: {:?}\""

#: src/variable_bindings.md:21
msgid "\"Meet the unit value: {:?}\""
msgstr "\"유닛 값을 만나보세요: {:?}\""

#: src/variable_bindings.md:23
msgid ""
"// The compiler warns about unused variable bindings; these warnings can\n"
"    // be silenced by prefixing the variable name with an underscore\n"
msgstr ""
"// 컴파일러는 사용되지 않는 변수 바인딩에 대해 경고를 보냅니다. 이러한 경고"
"는\n"
"    // 변수 이름 앞에 밑줄을 붙여서 비활성화할 수 있습니다.\n"

#: src/variable_bindings.md:28
msgid ""
"// FIXME ^ Prefix with an underscore to suppress the warning\n"
"    // Please note that warnings may not be shown in a browser\n"
msgstr ""
"// FIXME ^ 경고를 억제하기 위해 밑줄을 접두사로 붙이세요\n"
"    // 브라우저에서는 경고가 표시되지 않을 수 있음에 유의하세요\n"

#: src/variable_bindings/mut.md:3
msgid ""
"Variable bindings are immutable by default, but this can be overridden using "
"the `mut` modifier."
msgstr ""
"변수 바인딩은 기본적으로 불변(immutable)이지만, `mut` 수식어를 사용하여 이를 "
"재정의할 수 있습니다."

#: src/variable_bindings/mut.md:11
msgid "\"Before mutation: {}\""
msgstr "\"변경 전: {}\""

#: src/variable_bindings/mut.md:13
msgid "// Ok\n"
msgstr "// 좋습니다\n"

#: src/variable_bindings/mut.md:16
msgid "\"After mutation: {}\""
msgstr "\"변경 후: {}\""

#: src/variable_bindings/mut.md:18
msgid "// Error! Cannot assign a new value to an immutable variable\n"
msgstr "// 에러! 불변 변수에는 새로운 값을 할당할 수 없습니다\n"

#: src/variable_bindings/mut.md:23
msgid "The compiler will throw a detailed diagnostic about mutability errors."
msgstr "컴파일러는 가변성 에러에 대해 상세한 진단을 제공할 것입니다."

#: src/variable_bindings/scope.md:3
msgid ""
"Variable bindings have a scope, and are constrained to live in a _block_. A "
"block is a collection of statements enclosed by braces `{}`."
msgstr ""
"변수 바인딩은 스코프(범위)를 가지며, _블록_ 내에 거주하도록 제한됩니다. 블록"
"은 중괄호 `{}`로 둘러싸인 문장들의 모음입니다."

#: src/variable_bindings/scope.md:8
msgid "// This binding lives in the main function\n"
msgstr "// 이 바인딩은 메인 함수에 거주합니다\n"

#: src/variable_bindings/scope.md:11
msgid "// This is a block, and has a smaller scope than the main function\n"
msgstr "// 이것은 블록이며, 메인 함수보다 더 작은 스코프를 가집니다\n"

#: src/variable_bindings/scope.md:13
msgid "// This binding only exists in this block\n"
msgstr "// 이 바인딩은 이 블록 내에만 존재합니다\n"

#: src/variable_bindings/scope.md:16
msgid "\"inner short: {}\""
msgstr "\"내부 short: {}\""

#: src/variable_bindings/scope.md:18
msgid "// End of the block\n"
msgstr "// 블록의 끝\n"

#: src/variable_bindings/scope.md:20
msgid "// Error! `short_lived_binding` doesn't exist in this scope\n"
msgstr "// 에러! `short_lived_binding`은 이 스코프에 존재하지 않습니다\n"

#: src/variable_bindings/scope.md:21
msgid "\"outer short: {}\""
msgstr "\"외부 short: {}\""

#: src/variable_bindings/scope.md:24
msgid "\"outer long: {}\""
msgstr "\"외부 long: {}\""

#: src/variable_bindings/scope.md:28
msgid ""
"Also, [variable shadowing](https://en.wikipedia.org/wiki/Variable_shadowing) "
"is allowed."
msgstr ""
"또한, [변수 섀도잉](https://en.wikipedia.org/wiki/Variable_shadowing)이 허용"
"됩니다."

#: src/variable_bindings/scope.md:35
msgid "\"before being shadowed: {}\""
msgstr "\"섀도잉 전: {}\""

#: src/variable_bindings/scope.md:37
msgid "// This binding *shadows* the outer one\n"
msgstr "// 이 바인딩은 외부 바인딩을 *섀도잉*합니다\n"

#: src/variable_bindings/scope.md:38
msgid "\"abc\""
msgstr "\"abc\""

#: src/variable_bindings/scope.md:40
msgid "\"shadowed in inner block: {}\""
msgstr "\"내부 블록에서 섀도잉됨: {}\""

#: src/variable_bindings/scope.md:42
msgid "\"outside inner block: {}\""
msgstr "\"내부 블록 밖: {}\""

#: src/variable_bindings/scope.md:44
msgid "// This binding *shadows* the previous binding\n"
msgstr "// 이 바인딩은 이전 바인딩을 *섀도잉*합니다\n"

#: src/variable_bindings/scope.md:46
msgid "\"shadowed in outer block: {}\""
msgstr "\"외부 블록에서 섀도잉됨: {}\""

#: src/variable_bindings/declare.md:3
msgid ""
"It is possible to declare variable bindings first and initialize them later, "
"but all variable bindings must be initialized before they are used: the "
"compiler forbids use of uninitialized variable bindings, as it would lead to "
"undefined behavior."
msgstr ""
"변수 바인딩을 먼저 선언하고 나중에 초기화하는 것이 가능하지만, 모든 변수 바인"
"딩은 사용되기 전에 초기화되어야 합니다. 컴파일러는 정의되지 않은 동작을 초래"
"할 수 있는 초기화되지 않은 변수 바인딩의 사용을 금지합니다."

#: src/variable_bindings/declare.md:5
msgid ""
"It is not common to declare a variable binding and initialize it later in "
"the function. It is more difficult for a reader to find the initialization "
"when initialization is separated from declaration. It is common to declare "
"and initialize a variable binding near where the variable will be used."
msgstr ""
"변수 바인딩을 선언하고 나중에 함수 내에서 초기화하는 것은 일반적이지 않습니"
"다. 선언과 초기화가 분리되어 있으면 독자가 초기화 지점을 찾기 더 어렵기 때문"
"입니다. 변수가 사용될 위치 근처에서 선언과 초기화를 함께 하는 것이 일반적입니"
"다."

#: src/variable_bindings/declare.md:11
msgid "// Declare a variable binding\n"
msgstr "// 변수 바인딩 선언\n"

#: src/variable_bindings/declare.md:17
msgid "// Initialize the binding\n"
msgstr "// 바인딩 초기화\n"

#: src/variable_bindings/declare.md:21
msgid "\"a binding: {}\""
msgstr "\"바인딩 a: {}\""

#: src/variable_bindings/declare.md:25
msgid "// Error! Use of uninitialized binding\n"
msgstr "// 에러! 초기화되지 않은 바인딩 사용\n"

#: src/variable_bindings/declare.md:26 src/variable_bindings/declare.md:31
msgid "\"another binding: {}\""
msgstr "\"또 다른 바인딩: {}\""

#: src/variable_bindings/freeze.md:3
msgid ""
"When data is bound by the same name immutably, it also _freezes_. _Frozen_ "
"data can't be modified until the immutable binding goes out of scope:"
msgstr ""
"데이터가 동일한 이름으로 불변하게 바인딩되면, 해당 데이터는 _동결(freeze)_됩"
"니다. _동결된_ 데이터는 불변 바인딩이 스코프를 벗어날 때까지 수정할 수 없습니"
"다."

#: src/variable_bindings/freeze.md:11
msgid "// Shadowing by immutable `_mutable_integer`\n"
msgstr "// 불변 `_mutable_integer`에 의한 섀도잉\n"

#: src/variable_bindings/freeze.md:14
msgid "// Error! `_mutable_integer` is frozen in this scope\n"
msgstr "// 에러! `_mutable_integer`는 이 스코프에서 동결되었습니다\n"

#: src/variable_bindings/freeze.md:18
msgid "// `_mutable_integer` goes out of scope\n"
msgstr "// `_mutable_integer`가 스코프를 벗어납니다\n"

#: src/variable_bindings/freeze.md:21
msgid "// Ok! `_mutable_integer` is not frozen in this scope\n"
msgstr "// 좋습니다! `_mutable_integer`는 이 스코프에서 동결되지 않았습니다\n"

#: src/types.md:3
msgid ""
"Rust provides several mechanisms to change or define the type of primitive "
"and user defined types. The following sections cover:"
msgstr ""
"Rust는 기본 타입과 사용자 정의 타입의 타입을 변경하거나 정의하기 위한 여러 메"
"커니즘을 제공합니다. 다음 섹션에서는 다음을 다룹니다:"

#: src/types.md:6
msgid "[Casting](types/cast.md) between primitive types"
msgstr "기본 타입 간의 [형변환(Casting)](types/cast.md)"

#: src/types.md:7
msgid "Specifying the desired type of [literals](types/literals.md)"
msgstr "[리터럴](types/literals.md)의 원하는 타입을 지정하는 법"

#: src/types.md:8
msgid "Using [type inference](types/inference.md)"
msgstr "[타입 추론(type inference)](types/inference.md) 사용"

#: src/types.md:9
msgid "[Aliasing](types/alias.md) types"
msgstr "타입 [별칭(Aliasing)](types/alias.md)"

#: src/types/cast.md:3
msgid ""
"Rust provides no implicit type conversion (coercion) between primitive "
"types. But, explicit type conversion (casting) can be performed using the "
"`as` keyword."
msgstr ""
"Rust는 기본 타입 간의 암시적 타입 변환(강제)을 제공하지 않습니다. 하지만 "
"`as` 키워드를 사용하여 명시적 타입 변환(캐스팅)을 수행할 수 있습니다."

#: src/types/cast.md:6
msgid ""
"Rules for converting between integral types follow C conventions generally, "
"except in cases where C has undefined behavior. The behavior of all casts "
"between integral types is well defined in Rust."
msgstr ""
"정수 타입 간의 변환 규칙은 일반적으로 C 언어의 관례를 따르지만, C에서 정의되"
"지 않은 동작(undefined behavior)이 발생하는 경우는 예외입니다. Rust에서 정수 "
"타입 간의 모든 캐스팅 동작은 잘 정의되어 있습니다."

#: src/types/cast.md:11
msgid "// Suppress all errors from casts which overflow.\n"
msgstr "// 오버플로우가 발생하는 캐스팅으로 인한 모든 에러를 억제합니다.\n"

#: src/types/cast.md:17
msgid "// Error! No implicit conversion\n"
msgstr "// 에러! 암시적 변환 없음\n"

#: src/types/cast.md:21
msgid "// Explicit conversion\n"
msgstr "// 명시적 변환\n"

#: src/types/cast.md:25
msgid ""
"// Error! There are limitations in conversion rules.\n"
"    // A float cannot be directly converted to a char.\n"
msgstr ""
"// 에러! 변환 규칙에 제한이 있습니다.\n"
"    // 부동 소수점은 문자로 직접 변환할 수 없습니다.\n"

#: src/types/cast.md:30
msgid "\"Casting: {} -> {} -> {}\""
msgstr "\"형변환: {} -> {} -> {}\""

#: src/types/cast.md:32
msgid ""
"// when casting any value to an unsigned type, T,\n"
"    // T::MAX + 1 is added or subtracted until the value\n"
"    // fits into the new type ONLY when the #![allow(overflowing_literals)]\n"
"    // lint is specified like above. Otherwise there will be a compiler "
"error.\n"
msgstr ""
"// 값을 부호 없는 타입 T로 캐스팅할 때, #![allow(overflowing_literals)]\n"
"    // 린트가 위와 같이 지정된 경우에만 값이 새로운 타입에 맞을 때까지\n"
"    // T::MAX + 1을 더하거나 뺍니다. 그렇지 않으면 컴파일 에러가 발생합니"
"다.\n"

#: src/types/cast.md:37
msgid "// 1000 already fits in a u16\n"
msgstr "// 1000은 이미 u16에 들어맞습니다\n"

#: src/types/cast.md:38
msgid "\"1000 as a u16 is: {}\""
msgstr "\"1000을 u16으로 변환하면: {}\""

#: src/types/cast.md:40
msgid ""
"// 1000 - 256 - 256 - 256 = 232\n"
"    // Under the hood, the first 8 least significant bits (LSB) are kept,\n"
"    // while the rest towards the most significant bit (MSB) get truncated.\n"
msgstr ""
"// 1000 - 256 - 256 - 256 = 232\n"
"    // 내부적으로는 첫 8개의 최하위 비트(LSB)는 유지되고,\n"
"    // 최상위 비트(MSB) 쪽의 나머지 비트들은 잘려 나갑니다.\n"

#: src/types/cast.md:43 src/types/cast.md:62
msgid "\"1000 as a u8 is : {}\""
msgstr "\"1000을 u8로 변환하면 : {}\""

#: src/types/cast.md:44
msgid "// -1 + 256 = 255\n"
msgstr "// -1 + 256 = 255\n"

#: src/types/cast.md:45
msgid "\"  -1 as a u8 is : {}\""
msgstr "\"  -1을 u8로 변환하면 : {}\""

#: src/types/cast.md:47
msgid "// For positive numbers, this is the same as the modulus\n"
msgstr "// 양수의 경우, 이는 나머지 연산(modulus)과 동일합니다\n"

#: src/types/cast.md:48
msgid "\"1000 mod 256 is : {}\""
msgstr "\"1000 mod 256은 : {}\""

#: src/types/cast.md:50
msgid ""
"// When casting to a signed type, the (bitwise) result is the same as\n"
"    // first casting to the corresponding unsigned type. If the most "
"significant\n"
"    // bit of that value is 1, then the value is negative.\n"
msgstr ""
"// 부호 있는 타입으로 캐스팅할 때, (비트 단위) 결과는 먼저\n"
"    // 대응하는 부호 없는 타입으로 캐스팅하는 것과 같습니다. 만약 그 값의\n"
"    // 최상위 비트가 1이면, 그 값은 음수입니다.\n"

#: src/types/cast.md:54
msgid "// Unless it already fits, of course.\n"
msgstr "// 물론 이미 들어맞는 경우는 제외합니다.\n"

#: src/types/cast.md:55
msgid "\" 128 as a i16 is: {}\""
msgstr "\" 128을 i16으로 변환하면: {}\""

#: src/types/cast.md:57
msgid ""
"// In boundary case 128 value in 8-bit two's complement representation is "
"-128\n"
msgstr ""
"// 경계 케이스의 경우, 8비트 2의 보수 표현에서 128이라는 값은 -128입니다.\n"

#: src/types/cast.md:58
msgid "\" 128 as a i8 is : {}\""
msgstr "\" 128을 i8로 변환하면 : {}\""

#: src/types/cast.md:60
msgid ""
"// repeating the example above\n"
"    // 1000 as u8 -> 232\n"
msgstr ""
"// 위 예제를 반복합니다\n"
"    // 1000을 u8로 변환 -> 232\n"

#: src/types/cast.md:63
msgid ""
"// and the value of 232 in 8-bit two's complement representation is -24\n"
msgstr "// 그리고 8비트 2의 보수 표현에서 232라는 값은 -24입니다.\n"

#: src/types/cast.md:64
msgid "\" 232 as a i8 is : {}\""
msgstr "\" 232를 i8로 변환하면 : {}\""

#: src/types/cast.md:66
msgid ""
"// Since Rust 1.45, the `as` keyword performs a *saturating cast*\n"
"    // when casting from float to int. If the floating point value exceeds\n"
"    // the upper bound or is less than the lower bound, the returned value\n"
"    // will be equal to the bound crossed.\n"
msgstr ""
"// Rust 1.45부터, 부동 소수점을 정수로 캐스팅할 때 `as` 키워드는\n"
"    // *포화 캐스팅(saturating cast)*을 수행합니다. 부동 소수점 값이\n"
"    // 상한을 초과하거나 하한보다 작으면, 반환되는 값은 해당 경계값이 됩니"
"다.\n"

#: src/types/cast.md:71
msgid "// 300.0 as u8 is 255\n"
msgstr "// 300.0을 u8로 변환하면 255입니다\n"

#: src/types/cast.md:72 src/types/cast.md:83
msgid "\" 300.0 as u8 is : {}\""
msgstr "\" 300.0을 u8로 변환하면 : {}\""

#: src/types/cast.md:73
msgid "// -100.0 as u8 is 0\n"
msgstr "// -100.0을 u8로 변환하면 0입니다\n"

#: src/types/cast.md:74 src/types/cast.md:85
msgid "\"-100.0 as u8 is : {}\""
msgstr "\"-100.0을 u8로 변환하면 : {}\""

#: src/types/cast.md:75 src/types/cast.md:86
msgid "// nan as u8 is 0\n"
msgstr "// nan을 u8로 변환하면 0입니다\n"

#: src/types/cast.md:76 src/types/cast.md:87
msgid "\"   nan as u8 is : {}\""
msgstr "\"   nan을 u8로 변환하면 : {}\""

#: src/types/cast.md:78
msgid ""
"// This behavior incurs a small runtime cost and can be avoided\n"
"    // with unsafe methods, however the results might overflow and\n"
"    // return **unsound values**. Use these methods wisely:\n"
msgstr ""
"// 이러한 동작은 약간의 런타임 비용을 발생시키며, unsafe 메서드를 사용하여\n"
"    // 피할 수 있습니다. 하지만 결과가 오버플로우되어 **불건전한 값(unsound "
"values)**을\n"
"    // 반환할 수 있습니다. 이러한 메서드들은 현명하게 사용하세요:\n"

#: src/types/cast.md:82
msgid "// 300.0 as u8 is 44\n"
msgstr "// 300.0을 u8로 변환하면 44입니다\n"

#: src/types/cast.md:84
msgid "// -100.0 as u8 is 156\n"
msgstr "// -100.0을 u8로 변환하면 156입니다\n"

#: src/types/literals.md:3
msgid ""
"Numeric literals can be type annotated by adding the type as a suffix. As an "
"example, to specify that the literal `42` should have the type `i32`, write "
"`42i32`."
msgstr ""
"숫자 리터럴은 타입 이름을 접미사로 추가하여 타입 어노테이션을 할 수 있습니"
"다. 예를 들어, 리터럴 `42`가 `i32` 타입을 가져야 함을 지정하려면 `42i32`라고 "
"씁니다."

#: src/types/literals.md:6
msgid ""
"The type of unsuffixed numeric literals will depend on how they are used. If "
"no constraint exists, the compiler will use `i32` for integers, and `f64` "
"for floating-point numbers."
msgstr ""
"접미사가 없는 숫자 리터럴의 타입은 어떻게 사용되느냐에 따라 달라집니다. 아무"
"런 제약이 없다면 컴파일러는 정수에 대해서는 `i32`를, 부동 소수점 숫자에 대해"
"서는 `f64`를 사용합니다."

#: src/types/literals.md:12
msgid "// Suffixed literals, their types are known at initialization\n"
msgstr "// 접미사가 붙은 리터럴은 초기화 시 그 타입을 알 수 있습니다.\n"

#: src/types/literals.md:17
msgid "// Unsuffixed literals, their types depend on how they are used\n"
msgstr ""
"// 접미사가 없는 리터럴의 타입은 어떻게 사용되느냐에 따라 달라집니다.\n"

#: src/types/literals.md:21
msgid "// `size_of_val` returns the size of a variable in bytes\n"
msgstr "// `size_of_val`은 변수의 크기를 바이트 단위로 반환합니다.\n"

#: src/types/literals.md:22
msgid "\"size of `x` in bytes: {}\""
msgstr "`x`의 바이트 크기: {}"

#: src/types/literals.md:23
msgid "\"size of `y` in bytes: {}\""
msgstr "`y`의 바이트 크기: {}"

#: src/types/literals.md:24
msgid "\"size of `z` in bytes: {}\""
msgstr "`z`의 바이트 크기: {}"

#: src/types/literals.md:25
msgid "\"size of `i` in bytes: {}\""
msgstr "`i`의 바이트 크기: {}"

#: src/types/literals.md:26
msgid "\"size of `f` in bytes: {}\""
msgstr "`f`의 바이트 크기: {}"

#: src/types/literals.md:30
msgid ""
"There are some concepts used in the previous code that haven't been "
"explained yet, here's a brief explanation for the impatient readers:"
msgstr ""
"앞선 코드에서 아직 설명되지 않은 몇 가지 개념이 사용되었습니다. 성급한 독자들"
"을 위한 간단한 설명은 다음과 같습니다:"

#: src/types/literals.md:33
msgid ""
"`std::mem::size_of_val` is a function, but called with its _full path_. Code "
"can be split in logical units called _modules_. In this case, the "
"`size_of_val` function is defined in the `mem` module, and the `mem` module "
"is defined in the `std` _crate_. For more details, see [modules](../mod.md) "
"and [crates](../crates.md)."
msgstr ""
"`std::mem::size_of_val`은 함수이지만, _전체 경로(full path)_를 사용하여 호출"
"되었습니다. 코드는 _모듈_이라고 불리는 논리적 단위로 나뉠 수 있습니다. 이 경"
"우, `size_of_val` 함수는 `mem` 모듈에 정의되어 있고, `mem` 모듈은 `std` _크레"
"이트_에 정의되어 있습니다. 자세한 내용은 [모듈](../mod.md) 및 [크레이트](../"
"crates.md)를 참조하세요."

#: src/types/inference.md:3
msgid ""
"The type inference engine is pretty smart. It does more than looking at the "
"type of the value expression during an initialization. It also looks at how "
"the variable is used afterwards to infer its type. Here's an advanced "
"example of type inference:"
msgstr ""
"타입 추론 엔진은 꽤 똑똑합니다. 초기화 중에 값 표현식의 타입을 살펴보는 것 이"
"상의 일을 합니다. 또한 변수가 이후에 어떻게 사용되는지를 보고 타입을 추론합니"
"다. 다음은 타입 추론의 심화 예시입니다:"

#: src/types/inference.md:10
msgid ""
"// Because of the annotation, the compiler knows that `elem` has type u8.\n"
msgstr "// 어노테이션 덕분에 컴파일러는 `elem`이 u8 타입임을 압니다.\n"

#: src/types/inference.md:13
msgid "// Create an empty vector (a growable array).\n"
msgstr "// 빈 벡터(가변 크기 배열)를 생성합니다.\n"

#: src/types/inference.md:15
msgid ""
"// At this point the compiler doesn't know the exact type of `vec`, it\n"
"    // just knows that it's a vector of something (`Vec<_>`).\n"
msgstr ""
"// 이 시점에서 컴파일러는 `vec`의 정확한 타입을 알지 못하며,\n"
"    // 단지 무언가의 벡터(`Vec<_>`)라는 것만 압니다.\n"

#: src/types/inference.md:18
msgid "// Insert `elem` in the vector.\n"
msgstr "// 벡터에 `elem`을 삽입합니다.\n"

#: src/types/inference.md:20
msgid ""
"// Aha! Now the compiler knows that `vec` is a vector of `u8`s (`Vec<u8>`)\n"
"    // TODO ^ Try commenting out the `vec.push(elem)` line\n"
msgstr ""
"// 아하! 이제 컴파일러는 `vec`이 `u8`들의 벡터(`Vec<u8>`)임을 압니다.\n"
"    // TODO ^ `vec.push(elem)` 줄을 주석 처리해 보세요\n"

#: src/types/inference.md:27
msgid ""
"No type annotation of variables was needed, the compiler is happy and so is "
"the programmer!"
msgstr ""
"변수의 타입 어노테이션이 필요하지 않았습니다. 컴파일러도 만족하고 프로그래머"
"도 행복합니다!"

#: src/types/alias.md:3
msgid ""
"The `type` statement can be used to give a new name to an existing type. "
"Types must have `UpperCamelCase` names, or the compiler will raise a "
"warning. The exception to this rule are the primitive types: `usize`, `f32`, "
"etc."
msgstr ""
"`type` 문을 사용하면 기존 타입에 새로운 이름을 부여할 수 있습니다. 타입 이름"
"은 `UpperCamelCase`여야 하며, 그렇지 않으면 컴파일러가 경고를 보냅니다. 이 규"
"칙의 예외는 기본 타입인 `usize`, `f32` 등입니다."

#: src/types/alias.md:8
msgid "// `NanoSecond`, `Inch`, and `U64` are new names for `u64`.\n"
msgstr "// `NanoSecond`, `Inch`, `U64`는 `u64`를 가리키는 새로운 이름입니다.\n"

#: src/types/alias.md:14
msgid "// `NanoSecond` = `Inch` = `U64` = `u64`.\n"
msgstr "// `NanoSecond` = `Inch` = `U64` = `u64`입니다.\n"

#: src/types/alias.md:18
msgid ""
"// Note that type aliases *don't* provide any extra type safety, because\n"
"    // aliases are *not* new types\n"
msgstr ""
"// 타입 별칭은 새로운 타입이 아니기 때문에, 추가적인 타입 안전성을\n"
"    // 제공하지 않는다는 점에 유의하세요.\n"

#: src/types/alias.md:20
msgid "\"{} nanoseconds + {} inches = {} unit?\""
msgstr "\"{} 나노초 + {} 인치 = {} 유닛?\""

#: src/types/alias.md:27
msgid ""
"The main use of aliases is to reduce boilerplate; for example the "
"`io::Result<T>` type is an alias for the `Result<T, io::Error>` type."
msgstr ""
"별칭의 주요 용도는 보일러플레이트(boilerplate)를 줄이는 것입니다. 예를 들어 "
"`io::Result<T>` 타입은 `Result<T, io::Error>` 타입의 별칭입니다."

#: src/types/alias.md:32
msgid "[Attributes](../attribute.md)"
msgstr "[속성](../attribute.md)"

#: src/conversion.md:3
msgid ""
"Primitive types can be converted to each other through [casting](types/"
"cast.md)."
msgstr ""
"기본 타입들은 [캐스팅(casting)](types/cast.md)을 통해 서로 변환될 수 있습니"
"다."

#: src/conversion.md:5
msgid ""
"Rust addresses conversion between custom types (i.e., `struct` and `enum`) "
"by the use of [traits](trait.md). The generic conversions will use the "
"[`From`](https://doc.rust-lang.org/std/convert/trait.From.html) and [`Into`]"
"(https://doc.rust-lang.org/std/convert/trait.Into.html) traits. However "
"there are more specific ones for the more common cases, in particular when "
"converting to and from `String`s."
msgstr ""
"Rust는 [트레이트(traits)](trait.md)를 사용하여 사용자 정의 타입(예: "
"`struct`, `enum`) 간의 변환을 처리합니다. 범용 변환에는 [`From`](https://"
"doc.rust-lang.org/std/convert/trait.From.html)과 [`Into`](https://doc.rust-"
"lang.org/std/convert/trait.Into.html) 트레이트를 사용합니다. 하지만 더 흔한 "
"경우, 특히 `String`과의 상호 변환을 위한 더 구체적인 트레이트들이 존재합니다."

#: src/conversion/from_into.md:3
msgid ""
"The [`From`](https://doc.rust-lang.org/std/convert/trait.From.html) and "
"[`Into`](https://doc.rust-lang.org/std/convert/trait.Into.html) traits are "
"inherently linked, and this is actually part of its implementation. If you "
"are able to convert type A from type B, then it should be easy to believe "
"that we should be able to convert type B to type A."
msgstr ""
"[`From`](https://doc.rust-lang.org/std/convert/trait.From.html)과 [`Into`]"
"(https://doc.rust-lang.org/std/convert/trait.Into.html) 트레이트는 본질적으"
"로 연결되어 있으며, 이는 실제로 구현의 일부입니다. 만약 타입 B로부터 타입 A"
"를 만들 수 있다면(`From`), 타입 B를 타입 A로 변환할 수 있다(`Into`)는 것을 쉽"
"게 알 수 있습니다."

#: src/conversion/from_into.md:7
msgid "`From`"
msgstr "`From`"

#: src/conversion/from_into.md:9
msgid ""
"The [`From`](https://doc.rust-lang.org/std/convert/trait.From.html) trait "
"allows for a type to define how to create itself from another type, hence "
"providing a very simple mechanism for converting between several types. "
"There are numerous implementations of this trait within the standard library "
"for conversion of primitive and common types."
msgstr ""
"[`From`](https://doc.rust-lang.org/std/convert/trait.From.html) 트레이트는 "
"한 타입이 다른 타입으로부터 자신을 생성하는 방법을 정의할 수 있게 하여, 여러 "
"타입 간의 변환을 위한 매우 단순한 메커니즘을 제공합니다. 표준 라이브러리에는 "
"기본 타입 및 일반적인 타입의 변환을 위해 이 트레이트가 수없이 많이 구현되어 "
"있습니다."

#: src/conversion/from_into.md:14
msgid "For example we can easily convert a `str` into a `String`"
msgstr "예를 들어, `str`을 `String`으로 쉽게 변환할 수 있습니다."

#: src/conversion/from_into.md:21
msgid "We can do something similar for defining a conversion for our own type."
msgstr ""
"우리는 자신의 타입에 대한 변환을 정의하기 위해 유사한 작업을 수행할 수 있습니"
"다."

#: src/conversion/from_into.md:39 src/conversion/from_into.md:68
#: src/conversion/from_into.md:98
msgid "\"My number is {:?}\""
msgstr "\"제 숫자는 {:?}입니다\""

#: src/conversion/from_into.md:43
msgid "`Into`"
msgstr "`Into`"

#: src/conversion/from_into.md:45
msgid ""
"The [`Into`](https://doc.rust-lang.org/std/convert/trait.Into.html) trait is "
"simply the reciprocal of the `From` trait. It defines how to convert a type "
"into another type."
msgstr ""
"[`Into`](https://doc.rust-lang.org/std/convert/trait.Into.html) 트레이트는 단"
"순히 `From` 트레이트의 반대입니다. 이는 한 타입을 다른 타입으로 변환하는 방법"
"을 정의합니다."

#: src/conversion/from_into.md:48
msgid ""
"Calling `into()` typically requires us to specify the result type as the "
"compiler is unable to determine this most of the time."
msgstr ""
"`into()`를 호출할 때는 일반적으로 결과 타입을 지정해야 합니다. 대부분의 경우 "
"컴파일러가 이를 결정할 수 없기 때문입니다."

#: src/conversion/from_into.md:66
msgid "// Try removing the type annotation\n"
msgstr "// 타입 어노테이션을 제거해 보세요\n"

#: src/conversion/from_into.md:72
msgid "`From` and `Into` are interchangeable"
msgstr "`From`과 `Into`는 상호 교환 가능합니다"

#: src/conversion/from_into.md:74
msgid ""
"`From` and `Into` are designed to be complementary. We do not need to "
"provide an implementation for both traits. If you have implemented the "
"`From` trait for your type, `Into` will call it when necessary. Note, "
"however, that the converse is not true: implementing `Into` for your type "
"will not automatically provide it with an implementation of `From`."
msgstr ""
"`From`과 `Into`는 상호 보완적으로 설계되었습니다. 두 트레이트 모두에 대해 구"
"현을 제공할 필요는 없습니다. 만약 자신의 타입에 대해 `From` 트레이트를 구현했"
"다면, `Into`는 필요할 때 이를 호출할 것입니다. 하지만 그 반대는 성립하지 않음"
"에 유의하세요. 즉, 자신의 타입에 대해 `Into`를 구현한다고 해서 `From` 구현이 "
"자동으로 제공되지는 않습니다."

#: src/conversion/from_into.md:86
msgid "// Define `From`\n"
msgstr "// `From` 정의\n"

#: src/conversion/from_into.md:96
msgid "// use `Into`\n"
msgstr "// `Into` 사용\n"

#: src/conversion/try_from_try_into.md:3
msgid ""
"Similar to [`From` and `Into`](from_into.html), [`TryFrom`](https://doc.rust-"
"lang.org/std/convert/trait.TryFrom.html) and [`TryInto`](https://doc.rust-"
"lang.org/std/convert/trait.TryInto.html) are generic traits for converting "
"between types. Unlike `From`/`Into`, the `TryFrom`/`TryInto` traits are used "
"for fallible conversions, and as such, return [`Result`](https://doc.rust-"
"lang.org/std/result/enum.Result.html)s."
msgstr ""
"[`From`과 `Into`](from_into.html)와 유사하게, [`TryFrom`](https://doc.rust-"
"lang.org/std/convert/trait.TryFrom.html)과 [`TryInto`](https://doc.rust-"
"lang.org/std/convert/trait.TryInto.html)는 타입 간 변환을 위한 제네릭 트레이"
"트입니다. `From`/`Into`와 달리, `TryFrom`/`TryInto` 트레이트는 실패할 가능성"
"이 있는 변환에 사용되며, 따라서 [`Result`](https://doc.rust-lang.org/std/"
"result/enum.Result.html)를 반환합니다."

#: src/conversion/try_from_try_into.md:33
msgid "// TryFrom\n"
msgstr "// TryFrom\n"

#: src/conversion/try_from_try_into.md:38
msgid "// TryInto\n"
msgstr "// TryInto\n"

#: src/conversion/string.md:1
msgid "To and from Strings"
msgstr "문자열 상호 변환"

#: src/conversion/string.md:3
msgid "Converting to String"
msgstr "문자열로 변환하기"

#: src/conversion/string.md:5
msgid ""
"To convert any type to a `String` is as simple as implementing the "
"[`ToString`](https://doc.rust-lang.org/std/string/trait.ToString.html) trait "
"for the type. Rather than doing so directly, you should implement the "
"[`fmt::Display`](https://doc.rust-lang.org/std/fmt/trait.Display.html) trait "
"which automatically provides [`ToString`](https://doc.rust-lang.org/std/"
"string/trait.ToString.html) and also allows printing the type as discussed "
"in the section on [`print!`](../hello/print.md)."
msgstr ""
"어떤 타입을 `String`으로 변환하는 것은 해당 타입에 대해 [`ToString`](https://"
"doc.rust-lang.org/std/string/trait.ToString.html) 트레이트를 구현하는 것만큼 "
"간단합니다. 직접 구현하기보다는 [`fmt::Display`](https://doc.rust-lang.org/"
"std/fmt/trait.Display.html) 트레이트를 구현하는 것이 좋습니다. 이는 자동으로 "
"[`ToString`](https://doc.rust-lang.org/std/string/trait.ToString.html)을 제공"
"할 뿐만 아니라, [`print!`](../hello/print.md) 섹션에서 다룬 것처럼 해당 타입"
"을 출력할 수 있게 해줍니다."

#: src/conversion/string.md:19
msgid "\"Circle of radius {}\""
msgstr "\"반지름이 {}인 원\""

#: src/conversion/string.md:29
msgid "Parsing a String"
msgstr "문자열 파싱하기"

#: src/conversion/string.md:31
msgid ""
"It's useful to convert strings into many types, but one of the more common "
"string operations is to convert them from string to number. The idiomatic "
"approach to this is to use the [`parse`](https://doc.rust-lang.org/std/"
"primitive.str.html#method.parse) function and either to arrange for type "
"inference or to specify the type to parse using the 'turbofish' syntax. Both "
"alternatives are shown in the following example."
msgstr ""
"문자열을 여러 타입으로 변환하는 것은 유용하지만, 가장 흔한 작업 중 하나는 문"
"자열을 숫자로 변환하는 것입니다. 이에 대한 관용적인 방법은 [`parse`](https://"
"doc.rust-lang.org/std/primitive.str.html#method.parse) 함수를 사용하는 것이"
"며, 타입 추론을 이용하거나 'turbofish' 구문을 사용하여 파싱할 타입을 지정할 "
"수 있습니다. 다음 예제에 두 가지 방식이 모두 나와 있습니다."

#: src/conversion/string.md:37
msgid ""
"This will convert the string into the type specified as long as the "
"[`FromStr`](https://doc.rust-lang.org/std/str/trait.FromStr.html) trait is "
"implemented for that type. This is implemented for numerous types within the "
"standard library."
msgstr ""
"해당 타입에 대해 [`FromStr`](https://doc.rust-lang.org/std/str/"
"trait.FromStr.html) 트레이트가 구현되어 있다면 문자열을 지정된 타입으로 변환"
"합니다. 표준 라이브러리의 수많은 타입에 대해 이 트레이트가 구현되어 있습니다."

#: src/conversion/string.md:43 src/std_misc/process/wait.md:10
msgid "\"5\""
msgstr "\"5\""

#: src/conversion/string.md:44 src/error/result.md:33 src/error/result.md:68
#: src/error/result/result_map.md:42 src/error/result/result_map.md:75
#: src/error/result/result_alias.md:36 src/error/result/early_returns.md:36
#: src/error/result/enter_question_mark.md:34
#: src/error/result/enter_question_mark.md:67
msgid "\"10\""
msgstr "\"10\""

#: src/conversion/string.md:47
msgid "\"Sum: {:?}\""
msgstr "\"합계: {:?}\""

#: src/conversion/string.md:51
msgid ""
"To obtain this functionality on a user defined type simply implement the "
"[`FromStr`](https://doc.rust-lang.org/std/str/trait.FromStr.html) trait for "
"that type."
msgstr ""
"사용자 정의 타입에서 이 기능을 사용하려면 해당 타입에 대해 [`FromStr`]"
"(https://doc.rust-lang.org/std/str/trait.FromStr.html) 트레이트를 구현하기만 "
"하면 됩니다."

#: src/conversion/string.md:74
msgid "\"    3 \""
msgstr "\"    3 \""

#: src/expression.md:3
msgid "A Rust program is (mostly) made up of a series of statements:"
msgstr "Rust 프로그램은 (대부분) 일련의 문장(statements)으로 구성됩니다:"

#: src/expression.md:7
msgid ""
"// statement\n"
"    // statement\n"
"    // statement\n"
msgstr ""
"// 문장\n"
"    // 문장\n"
"    // 문장\n"

#: src/expression.md:13
msgid ""
"There are a few kinds of statements in Rust. The most common two are "
"declaring a variable binding, and using a `;` with an expression:"
msgstr ""
"Rust에는 몇 가지 종류의 문장이 있습니다. 가장 흔한 두 가지는 변수 바인딩을 선"
"언하는 것과 표현식에 `;`를 사용하는 것입니다:"

#: src/expression.md:18
msgid "// variable binding\n"
msgstr "// 변수 바인딩\n"

#: src/expression.md:21
msgid "// expression;\n"
msgstr "// 표현식;\n"

#: src/expression.md:28
msgid ""
"Blocks are expressions too, so they can be used as values in assignments. "
"The last expression in the block will be assigned to the place expression "
"such as a local variable. However, if the last expression of the block ends "
"with a semicolon, the return value will be `()`."
msgstr ""
"블록도 표현식이므로 할당 시 값으로 사용될 수 있습니다. 블록의 마지막 표현식"
"은 로컬 변수와 같은 장소 표현식(place expression)에 할당됩니다. 하지만 블록"
"의 마지막 표현식이 세미콜론으로 끝나면 반환 값은 `()`가 됩니다."

#: src/expression.md:41
msgid "// This expression will be assigned to `y`\n"
msgstr "// 이 표현식은 `y`에 할당됩니다\n"

#: src/expression.md:46
msgid ""
"// The semicolon suppresses this expression and `()` is assigned to `z`\n"
msgstr "// 세미콜론이 이 표현식을 억제하여 `z`에는 `()`가 할당됩니다\n"

#: src/expression.md:50
msgid "\"x is {:?}\""
msgstr "\"x는 {:?}입니다\""

#: src/expression.md:51
msgid "\"y is {:?}\""
msgstr "\"y는 {:?}입니다\""

#: src/expression.md:52
msgid "\"z is {:?}\""
msgstr "\"z는 {:?}입니다\""

#: src/flow_control.md:3
msgid ""
"An integral part of any programming language are ways to modify control "
"flow: `if`/`else`, `for`, and others. Let's talk about them in Rust."
msgstr ""
"모든 프로그래밍 언어의 필수적인 부분은 제어 흐름을 수정하는 방법입니다: `if`/"
"`else`, `for` 등. Rust에서의 제어 흐름에 대해 이야기해 봅시다."

#: src/flow_control/if_else.md:3
msgid ""
"Branching with `if`\\-`else` is similar to other languages. Unlike many of "
"them, the boolean condition doesn't need to be surrounded by parentheses, "
"and each condition is followed by a block. `if`\\-`else` conditionals are "
"expressions, and, all branches must return the same type."
msgstr ""
"`if`\\-`else`를 사용한 분기는 다른 언어와 유사합니다. 많은 언어와 달리 불리"
"언 조건은 괄호로 둘러쌀 필요가 없으며, 각 조건 뒤에는 블록이 옵니다. `if`\\-"
"`else` 조건문은 표현식이며, 모든 분기는 동일한 타입을 반환해야 합니다."

#: src/flow_control/if_else.md:13
msgid "\"{} is negative\""
msgstr "\"{}은(는) 음수입니다\""

#: src/flow_control/if_else.md:15
msgid "\"{} is positive\""
msgstr "\"{}은(는) 양수입니다\""

#: src/flow_control/if_else.md:17
msgid "\"{} is zero\""
msgstr "\"{}은(는) 0입니다\""

#: src/flow_control/if_else.md:22
msgid "\", and is a small number, increase ten-fold\""
msgstr "\", 그리고 작은 수이므로 10배 증가시킵니다\""

#: src/flow_control/if_else.md:24
msgid "// This expression returns an `i32`.\n"
msgstr "// 이 표현식은 `i32`를 반환합니다.\n"

#: src/flow_control/if_else.md:27
msgid "\", and is a big number, halve the number\""
msgstr "\", 그리고 큰 수이므로 반으로 나눕니다\""

#: src/flow_control/if_else.md:29
msgid "// This expression must return an `i32` as well.\n"
msgstr "// 이 표현식 또한 `i32`를 반환해야 합니다.\n"

#: src/flow_control/if_else.md:31
msgid "// TODO ^ Try suppressing this expression with a semicolon.\n"
msgstr "// TODO ^ 세미콜론을 사용하여 이 표현식을 억제해 보세요.\n"

#: src/flow_control/if_else.md:33
msgid ""
"//   ^ Don't forget to put a semicolon here! All `let` bindings need it.\n"
msgstr ""
"//   ^ 여기에 세미콜론을 넣는 것을 잊지 마세요! 모든 `let` 바인딩에 필요합니"
"다.\n"

#: src/flow_control/if_else.md:35 src/flow_control/match.md:35
msgid "\"{} -> {}\""
msgstr "\"{} -> {}\""

#: src/flow_control/loop.md:3
msgid "Rust provides a `loop` keyword to indicate an infinite loop."
msgstr "Rust는 무한 루프를 나타내기 위해 `loop` 키워드를 제공합니다."

#: src/flow_control/loop.md:5
msgid ""
"The `break` statement can be used to exit a loop at anytime, whereas the "
"`continue` statement can be used to skip the rest of the iteration and start "
"a new one."
msgstr ""
"`break` 문은 언제든지 루프를 종료하는 데 사용할 수 있으며, `continue` 문은 나"
"머지 반복을 건너뛰고 새로운 반복을 시작하는 데 사용될 수 있습니다."

#: src/flow_control/loop.md:13
msgid "\"Let's count until infinity!\""
msgstr "\"무한대까지 세어봅시다!\""

#: src/flow_control/loop.md:15
msgid "// Infinite loop\n"
msgstr "// 무한 루프\n"

#: src/flow_control/loop.md:20
msgid "\"three\""
msgstr "\"3\""

#: src/flow_control/loop.md:22
msgid "// Skip the rest of this iteration\n"
msgstr "// 이번 반복의 나머지를 건너뜁니다\n"

#: src/flow_control/loop.md:29
msgid "\"OK, that's enough\""
msgstr "\"좋아요, 그만하면 됐습니다\""

#: src/flow_control/loop.md:31
msgid "// Exit this loop\n"
msgstr "// 이 루프를 종료합니다\n"

#: src/flow_control/loop/nested.md:3
msgid ""
"It's possible to `break` or `continue` outer loops when dealing with nested "
"loops. In these cases, the loops must be annotated with some `'label`, and "
"the label must be passed to the `break`/`continue` statement."
msgstr ""
"중첩 루프를 다룰 때 외부 루프를 `break`하거나 `continue`하는 것이 가능합니"
"다. 이 경우 루프에는 어떤 `'label`을 붙여야 하며, 해당 레이블은 `break`/"
"`continue` 문에 전달되어야 합니다."

#: src/flow_control/loop/nested.md:12
msgid "\"Entered the outer loop\""
msgstr "\"외부 루프에 진입했습니다\""

#: src/flow_control/loop/nested.md:15
msgid "\"Entered the inner loop\""
msgstr "\"내부 루프에 진입했습니다\""

#: src/flow_control/loop/nested.md:17
msgid ""
"// This would break only the inner loop\n"
"            //break;\n"
msgstr ""
"// 이것은 내부 루프만 종료시킵니다\n"
"            //break;\n"

#: src/flow_control/loop/nested.md:20
msgid "// This breaks the outer loop\n"
msgstr "// 이것은 외부 루프를 종료시킵니다\n"

#: src/flow_control/loop/nested.md:24
msgid "\"This point will never be reached\""
msgstr "\"이 지점에는 결코 도달하지 않습니다\""

#: src/flow_control/loop/nested.md:27
msgid "\"Exited the outer loop\""
msgstr "\"외부 루프에서 나갔습니다\""

#: src/flow_control/loop/return.md:3
msgid ""
"One of the uses of a `loop` is to retry an operation until it succeeds. If "
"the operation returns a value though, you might need to pass it to the rest "
"of the code: put it after the `break`, and it will be returned by the `loop` "
"expression."
msgstr ""
"성공할 때까지 작업을 재시도하는 것이 `loop`의 용도 중 하나입니다. 만약 작업"
"이 값을 반환한다면, 이를 코드의 나머지 부분으로 전달해야 할 수도 있습니다. "
"`break` 뒤에 값을 넣으면 `loop` 표현식에 의해 그 값이 반환됩니다."

#: src/flow_control/while.md:3
msgid ""
"The `while` keyword can be used to run a loop while a condition is true."
msgstr ""
"`while` 키워드는 조건이 참(true)인 동안 루프를 실행하는 데 사용될 수 있습니"
"다."

#: src/flow_control/while.md:5
msgid ""
"Let's write the infamous [FizzBuzz](https://en.wikipedia.org/wiki/Fizz_buzz) "
"using a `while` loop."
msgstr ""
"악명 높은 [FizzBuzz](https://en.wikipedia.org/wiki/Fizz_buzz)를 `while` 루프"
"를 사용하여 작성해 봅시다."

#: src/flow_control/while.md:9
msgid "// A counter variable\n"
msgstr "// 카운터 변수\n"

#: src/flow_control/while.md:12
msgid "// Loop while `n` is less than 101\n"
msgstr "// `n`이 101보다 작은 동안 루프 실행\n"

#: src/flow_control/while.md:15 src/flow_control/for.md:17
#: src/flow_control/for.md:37 src/fn.md:34
msgid "\"fizzbuzz\""
msgstr "\"fizzbuzz\""

#: src/flow_control/while.md:17 src/flow_control/for.md:19
#: src/flow_control/for.md:39 src/fn.md:36
msgid "\"fizz\""
msgstr "\"fizz\""

#: src/flow_control/while.md:19 src/flow_control/for.md:21
#: src/flow_control/for.md:41 src/fn.md:38
msgid "\"buzz\""
msgstr "\"buzz\""

#: src/flow_control/while.md:24
msgid "// Increment counter\n"
msgstr "// 카운터 증가\n"

#: src/flow_control/for.md:1
msgid "for loops"
msgstr "for 루프"

#: src/flow_control/for.md:5
msgid ""
"The `for in` construct can be used to iterate through an `Iterator`. One of "
"the easiest ways to create an iterator is to use the range notation `a..b`. "
"This yields values from `a` (inclusive) to `b` (exclusive) in steps of one."
msgstr ""
"`for in` 구문은 `Iterator`를 통해 반복하는 데 사용될 수 있습니다. 이터레이터"
"를 만드는 가장 쉬운 방법 중 하나는 범위 표기법 `a..b`를 사용하는 것입니다. 이"
"는 `a`(포함)부터 `b`(미포함)까지의 값을 1씩 증가시키며 생성합니다."

#: src/flow_control/for.md:10
msgid "Let's write FizzBuzz using `for` instead of `while`."
msgstr "`while` 대신 `for`를 사용하여 FizzBuzz를 작성해 봅시다."

#: src/flow_control/for.md:14 src/flow_control/for.md:34
msgid "// `n` will take the values: 1, 2, ..., 100 in each iteration\n"
msgstr "// 각 반복에서 `n`은 1, 2, ..., 100의 값을 갖게 됩니다.\n"

#: src/flow_control/for.md:29
msgid ""
"Alternatively, `a..=b` can be used for a range that is inclusive on both "
"ends. The above can be written as:"
msgstr ""
"또는 양쪽 끝을 모두 포함하는 범위에는 `a..=b`를 사용할 수 있습니다. 위의 코드"
"는 다음과 같이 작성될 수 있습니다:"

#: src/flow_control/for.md:49
msgid "for and iterators"
msgstr "for와 이터레이터"

#: src/flow_control/for.md:51
msgid ""
"The `for in` construct is able to interact with an `Iterator` in several "
"ways. As discussed in the section on the [Iterator](../trait/iter.md) trait, "
"by default the `for` loop will apply the `into_iter` function to the "
"collection. However, this is not the only means of converting collections "
"into iterators."
msgstr ""
"`for in` 구문은 여러 방식으로 `Iterator`와 상호작용할 수 있습니다. [Iterator]"
"(../trait/iter.md) 트레이트 섹션에서 다룬 것처럼, 기본적으로 `for` 루프는 컬"
"렉션에 `into_iter` 함수를 적용합니다. 하지만 이것이 컬렉션을 이터레이터로 변"
"환하는 유일한 방법은 아닙니다."

#: src/flow_control/for.md:56
msgid ""
"`into_iter`, `iter` and `iter_mut` all handle the conversion of a collection "
"into an iterator in different ways, by providing different views on the data "
"within."
msgstr ""
"`into_iter`, `iter`, `iter_mut`은 모두 내부 데이터에 대해 서로 다른 뷰를 제공"
"함으로써 컬렉션을 이터레이터로 변환하는 작업을 서로 다른 방식으로 처리합니다."

#: src/flow_control/for.md:60
msgid ""
"`iter` - This borrows each element of the collection through each iteration. "
"Thus leaving the collection untouched and available for reuse after the loop."
msgstr ""
"`iter` - 매 반복마다 컬렉션의 각 요소를 빌려옵니다. 따라서 컬렉션은 수정되지 "
"않은 상태로 유지되며 루프 이후에도 재사용할 수 있습니다."

#: src/flow_control/for.md:65 src/flow_control/for.md:85
#: src/flow_control/for.md:104
msgid "\"Frank\""
msgstr "\"프랭크\""

#: src/flow_control/for.md:65 src/flow_control/for.md:69
#: src/flow_control/for.md:85 src/flow_control/for.md:89
#: src/flow_control/for.md:104 src/flow_control/for.md:108
msgid "\"Ferris\""
msgstr "\"페리스\""

#: src/flow_control/for.md:69 src/flow_control/for.md:89
#: src/flow_control/for.md:108
msgid "\"There is a rustacean among us!\""
msgstr "\"우리 중에 러스타시안(rustacean)이 있습니다!\""

#: src/flow_control/for.md:70
msgid "// TODO ^ Try deleting the & and matching just \"Ferris\"\n"
msgstr "// TODO ^ &를 삭제하고 그냥 \"Ferris\"와 매칭해 보세요\n"

#: src/flow_control/for.md:71 src/flow_control/for.md:90
msgid "\"Hello {}\""
msgstr "\"안녕 {}\""

#: src/flow_control/for.md:75 src/flow_control/for.md:94
#: src/flow_control/for.md:113
msgid "\"names: {:?}\""
msgstr "\"이름들: {:?}\""

#: src/flow_control/for.md:79
msgid ""
"`into_iter` - This consumes the collection so that on each iteration the "
"exact data is provided. Once the collection has been consumed it is no "
"longer available for reuse as it has been 'moved' within the loop."
msgstr ""
"`into_iter` - 컬렉션을 소비(consume)하여 각 반복마다 실제 데이터를 제공합니"
"다. 컬렉션이 소비되면 루프 내에서 '이동(moved)'된 것이므로 더 이상 재사용할 "
"수 없습니다."

#: src/flow_control/for.md:99
msgid ""
"`iter_mut` - This mutably borrows each element of the collection, allowing "
"for the collection to be modified in place."
msgstr ""
"`iter_mut` - 컬렉션의 각 요소를 가변적으로 빌려와서, 컬렉션을 제자리에서 수정"
"할 수 있게 합니다."

#: src/flow_control/for.md:109
msgid "\"Hello\""
msgstr "\"안녕\""

#: src/flow_control/for.md:117
msgid ""
"In the above snippets note the type of `match` branch, that is the key "
"difference in the types of iteration. The difference in type then of course "
"implies differing actions that are able to be performed."
msgstr ""
"위의 스니펫에서 `match` 분기의 타입에 주목하세요. 이것이 반복 방식의 핵심적"
"인 차이점입니다. 타입의 차이는 물론 수행할 수 있는 작업의 차이를 의미합니다."

#: src/flow_control/for.md:123
msgid "[Iterator](../trait/iter.md)"
msgstr "[Iterator](../trait/iter.md)"

#: src/flow_control/match.md:3
msgid ""
"Rust provides pattern matching via the `match` keyword, which can be used "
"like a C `switch`. The first matching arm is evaluated and all possible "
"values must be covered."
msgstr ""
"Rust는 `match` 키워드를 통해 패턴 매칭을 제공하며, 이는 C의 `switch`처럼 사용"
"될 수 있습니다. 첫 번째로 매칭되는 팔(arm)이 실행되며, 가능한 모든 값을 다뤄"
"야 합니다."

#: src/flow_control/match.md:10
msgid "// TODO ^ Try different values for `number`\n"
msgstr "// TODO ^ `number`에 다른 값을 넣어보세요\n"

#: src/flow_control/match.md:12
msgid "\"Tell me about {}\""
msgstr "\"{}에 대해 알려주세요\""

#: src/flow_control/match.md:14
msgid "// Match a single value\n"
msgstr "// 단일 값 매칭\n"

#: src/flow_control/match.md:15
msgid "\"One!\""
msgstr "\"1입니다!\""

#: src/flow_control/match.md:16
msgid "// Match several values\n"
msgstr "// 여러 값 매칭\n"

#: src/flow_control/match.md:17
msgid "\"This is a prime\""
msgstr "\"이것은 소수입니다\""

#: src/flow_control/match.md:18
msgid ""
"// TODO ^ Try adding 13 to the list of prime values\n"
"        // Match an inclusive range\n"
msgstr ""
"// TODO ^ 소수 목록에 13을 추가해 보세요\n"
"        // 포함 범위를 매칭\n"

#: src/flow_control/match.md:20
msgid "\"A teen\""
msgstr "\"10대입니다\""

#: src/flow_control/match.md:21
msgid "// Handle the rest of cases\n"
msgstr "// 나머지 경우 처리\n"

#: src/flow_control/match.md:22
msgid "\"Ain't special\""
msgstr "\"특별할 것 없습니다\""

#: src/flow_control/match.md:23
msgid "// TODO ^ Try commenting out this catch-all arm\n"
msgstr ""
"// TODO ^ 이 모든 경우를 처리하는 팔(catch-all arm)을 주석 처리해 보세요\n"

#: src/flow_control/match.md:27
msgid "// Match is an expression too\n"
msgstr "// Match도 표현식입니다\n"

#: src/flow_control/match.md:29
msgid "// The arms of a match must cover all the possible values\n"
msgstr "// match의 팔들은 가능한 모든 값을 다뤄야 합니다\n"

#: src/flow_control/match.md:32
msgid "// TODO ^ Try commenting out one of these arms\n"
msgstr "// TODO ^ 이 팔들 중 하나를 주석 처리해 보세요\n"

#: src/flow_control/match/destructuring.md:3
msgid "A `match` block can destructure items in a variety of ways."
msgstr ""
"`match` 블록은 다양한 방식으로 아이템을 구조 분해(destructure)할 수 있습니다."

#: src/flow_control/match/destructuring.md:5
msgid "[Destructuring Tuples](destructuring/destructure_tuple.md)"
msgstr "[튜플 구조 분해](destructuring/destructure_tuple.md)"

#: src/flow_control/match/destructuring.md:6
msgid "[Destructuring Arrays and Slices](destructuring/destructure_slice.md)"
msgstr "[배열과 슬라이스 구조 분해](destructuring/destructure_slice.md)"

#: src/flow_control/match/destructuring.md:7
msgid "[Destructuring Enums](destructuring/destructure_enum.md)"
msgstr "[열거형 구조 분해](destructuring/destructure_enum.md)"

#: src/flow_control/match/destructuring.md:8
msgid "[Destructuring Pointers](destructuring/destructure_pointers.md)"
msgstr "[포인터 구조 분해](destructuring/destructure_pointers.md)"

#: src/flow_control/match/destructuring.md:9
msgid "[Destructuring Structures](destructuring/destructure_structures.md)"
msgstr "[구조체 구조 분해](destructuring/destructure_structures.md)"

#: src/flow_control/match/destructuring.md:19
msgid ""
"[The Rust Reference for Destructuring](https://doc.rust-lang.org/reference/"
"patterns.html#r-patterns.destructure)"
msgstr ""
"[구조 분해에 관한 Rust 레퍼런스](https://doc.rust-lang.org/reference/"
"patterns.html#r-patterns.destructure)"

#: src/flow_control/match/destructuring/destructure_tuple.md:3
msgid "Tuples can be destructured in a `match` as follows:"
msgstr "튜플은 `match`에서 다음과 같이 구조 분해될 수 있습니다:"

#: src/flow_control/match/destructuring/destructure_tuple.md:8
msgid "// TODO ^ Try different values for `triple`\n"
msgstr "// TODO ^ `triple`에 다른 값을 넣어보세요\n"

#: src/flow_control/match/destructuring/destructure_tuple.md:10
msgid "\"Tell me about {:?}\""
msgstr "\"{:?}에 대해 알려주세요\""

#: src/flow_control/match/destructuring/destructure_tuple.md:11
msgid "// Match can be used to destructure a tuple\n"
msgstr "// match를 사용하여 튜플을 구조 분해할 수 있습니다\n"

#: src/flow_control/match/destructuring/destructure_tuple.md:13
msgid "// Destructure the second and third elements\n"
msgstr "// 두 번째와 세 번째 요소를 구조 분해합니다\n"

#: src/flow_control/match/destructuring/destructure_tuple.md:14
msgid "\"First is `0`, `y` is {:?}, and `z` is {:?}\""
msgstr "\"첫 번째는 `0`이고, `y`는 {:?}, `z`는 {:?}입니다\""

#: src/flow_control/match/destructuring/destructure_tuple.md:15
msgid "\"First is `1` and the rest doesn't matter\""
msgstr "\"첫 번째는 `1`이고 나머지는 상관없습니다\""

#: src/flow_control/match/destructuring/destructure_tuple.md:16
msgid "\"last is `2` and the rest doesn't matter\""
msgstr "\"마지막은 `2`이고 나머지는 상관없습니다\""

#: src/flow_control/match/destructuring/destructure_tuple.md:17
msgid "\"First is `3`, last is `4`, and the rest doesn't matter\""
msgstr "\"첫 번째는 `3`, 마지막은 `4`이며 나머지는 상관없습니다\""

#: src/flow_control/match/destructuring/destructure_tuple.md:18
msgid "// `..` can be used to ignore the rest of the tuple\n"
msgstr "// `..`을 사용하여 튜플의 나머지를 무시할 수 있습니다\n"

#: src/flow_control/match/destructuring/destructure_tuple.md:19
msgid "\"It doesn't matter what they are\""
msgstr "\"그것들이 무엇이든 상관없습니다\""

#: src/flow_control/match/destructuring/destructure_tuple.md:20
msgid "// `_` means don't bind the value to a variable\n"
msgstr "// `_`는 값을 변수에 바인딩하지 않음을 의미합니다\n"

#: src/flow_control/match/destructuring/destructure_tuple.md:27
msgid "[Tuples](../../../primitives/tuples.md)"
msgstr "[튜플](../../../primitives/tuples.md)"

#: src/flow_control/match/destructuring/destructure_slice.md:3
msgid "Like tuples, arrays and slices can be destructured this way:"
msgstr ""
"튜플과 마찬가지로, 배열과 슬라이스도 다음과 같은 방식으로 구조 분해될 수 있습"
"니다:"

#: src/flow_control/match/destructuring/destructure_slice.md:7
msgid "// Try changing the values in the array, or make it a slice!\n"
msgstr "// 배열의 값을 변경하거나 슬라이스로 만들어 보세요!\n"

#: src/flow_control/match/destructuring/destructure_slice.md:11
msgid ""
"// Binds the second and the third elements to the respective variables\n"
msgstr "// 두 번째와 세 번째 요소를 각각의 변수에 바인딩합니다\n"

#: src/flow_control/match/destructuring/destructure_slice.md:13
msgid "\"array[0] = 0, array[1] = {}, array[2] = {}\""
msgstr "\"array[0] = 0, array[1] = {}, array[2] = {}\""

#: src/flow_control/match/destructuring/destructure_slice.md:15
msgid "// Single values can be ignored with _\n"
msgstr "// 단일 값은 _로 무시할 수 있습니다\n"

#: src/flow_control/match/destructuring/destructure_slice.md:17
msgid "\"array[0] = 1, array[2] = {} and array[1] was ignored\""
msgstr "\"array[0] = 1, array[2] = {} 이고 array[1]은 무시되었습니다\""

#: src/flow_control/match/destructuring/destructure_slice.md:21
msgid "// You can also bind some and ignore the rest\n"
msgstr "// 일부만 바인딩하고 나머지는 무시할 수도 있습니다\n"

#: src/flow_control/match/destructuring/destructure_slice.md:23
msgid "\"array[0] = -1, array[1] = {} and all the other ones were ignored\""
msgstr "\"array[0] = -1, array[1] = {} 이고 다른 모든 것들은 무시되었습니다\""

#: src/flow_control/match/destructuring/destructure_slice.md:26
msgid ""
"// The code below would not compile\n"
"        // [-1, second] => ...\n"
msgstr ""
"// 아래 코드는 컴파일되지 않습니다\n"
"        // [-1, second] => ...\n"

#: src/flow_control/match/destructuring/destructure_slice.md:29
msgid ""
"// Or store them in another array/slice (the type depends on\n"
"        // that of the value that is being matched against)\n"
msgstr ""
"// 또는 다른 배열/슬라이스에 저장할 수도 있습니다 (타입은 매칭되는 값의 타입"
"에 따라 달라집니다)\n"

#: src/flow_control/match/destructuring/destructure_slice.md:32
msgid "\"array[0] = 3, array[1] = {} and the other elements were {:?}\""
msgstr "\"array[0] = 3, array[1] = {} 이고 다른 요소들은 {:?}입니다\""

#: src/flow_control/match/destructuring/destructure_slice.md:36
msgid ""
"// Combining these patterns, we can, for example, bind the first and\n"
"        // last values, and store the rest of them in a single array\n"
msgstr ""
"// 이러한 패턴들을 결합하여, 예를 들어 첫 번째와 마지막 값을 바인딩하고 나머"
"지는 하나의 배열에 저장할 수 있습니다\n"

#: src/flow_control/match/destructuring/destructure_slice.md:39
msgid "\"array[0] = {}, middle = {:?}, array[2] = {}\""
msgstr "\"array[0] = {}, middle = {:?}, array[2] = {}\""

#: src/flow_control/match/destructuring/destructure_slice.md:48
msgid ""
"[Arrays and Slices](../../../primitives/array.md) and [Binding](../"
"binding.md) for `@` sigil"
msgstr ""
"[배열과 슬라이스](../../../primitives/array.md) 그리고 `@` 기호를 사용한 [바"
"인딩](../binding.md)"

#: src/flow_control/match/destructuring/destructure_enum.md:3
msgid "An `enum` is destructured similarly:"
msgstr "`enum`도 비슷하게 구조 분해됩니다:"

#: src/flow_control/match/destructuring/destructure_enum.md:6
msgid ""
"// `allow` required to silence warnings because only\n"
"// one variant is used.\n"
msgstr ""
"// 단 하나의 변체만 사용되므로 경고를 억제하기 위해 `allow`가 필요합니다.\n"

#: src/flow_control/match/destructuring/destructure_enum.md:10
msgid "// These 3 are specified solely by their name.\n"
msgstr "// 이 세 가지는 오직 이름으로만 지정됩니다.\n"

#: src/flow_control/match/destructuring/destructure_enum.md:14
msgid "// These likewise tie `u32` tuples to different names: color models.\n"
msgstr ""
"// 이들은 마찬가지로 `u32` 튜플을 서로 다른 이름(컬러 모델)에 연결합니다.\n"

#: src/flow_control/match/destructuring/destructure_enum.md:24
msgid "// TODO ^ Try different variants for `color`\n"
msgstr "// TODO ^ `color`에 다른 변체들을 넣어보세요\n"

#: src/flow_control/match/destructuring/destructure_enum.md:26
msgid "\"What color is it?\""
msgstr "\"이것은 무슨 색인가요?\""

#: src/flow_control/match/destructuring/destructure_enum.md:27
msgid "// An `enum` can be destructured using a `match`.\n"
msgstr "// `match`를 사용하여 `enum`을 구조 분해할 수 있습니다.\n"

#: src/flow_control/match/destructuring/destructure_enum.md:29
msgid "\"The color is Red!\""
msgstr "\"빨간색입니다!\""

#: src/flow_control/match/destructuring/destructure_enum.md:30
msgid "\"The color is Blue!\""
msgstr "\"파란색입니다!\""

#: src/flow_control/match/destructuring/destructure_enum.md:31
msgid "\"The color is Green!\""
msgstr "\"초록색입니다!\""

#: src/flow_control/match/destructuring/destructure_enum.md:33
msgid "\"Red: {}, green: {}, and blue: {}!\""
msgstr "\"빨강: {}, 초록: {}, 파랑: {}!\""

#: src/flow_control/match/destructuring/destructure_enum.md:35
msgid "\"Hue: {}, saturation: {}, value: {}!\""
msgstr "\"색상: {}, 채도: {}, 명도: {}!\""

#: src/flow_control/match/destructuring/destructure_enum.md:37
msgid "\"Hue: {}, saturation: {}, lightness: {}!\""
msgstr "\"색상: {}, 채도: {}, 밝기: {}!\""

#: src/flow_control/match/destructuring/destructure_enum.md:39
msgid "\"Cyan: {}, magenta: {}, yellow: {}!\""
msgstr "\"청록: {}, 자주: {}, 노랑: {}!\""

#: src/flow_control/match/destructuring/destructure_enum.md:41
msgid "\"Cyan: {}, magenta: {}, yellow: {}, key (black): {}!\""
msgstr "\"청록: {}, 자주: {}, 노랑: {}, 검정: {}!\""

#: src/flow_control/match/destructuring/destructure_enum.md:43
msgid "// Don't need another arm because all variants have been examined\n"
msgstr "// 모든 변체를 검사했으므로 다른 팔(arm)은 필요하지 않습니다.\n"

#: src/flow_control/match/destructuring/destructure_enum.md:50
msgid ""
"[`#[allow(...)]`](../../../attribute/unused.md), [color models](https://"
"en.wikipedia.org/wiki/Color_model) and [`enum`](../../../custom_types/"
"enum.md)"
msgstr ""
"[`#[allow(...)]`](../../../attribute/unused.md), [컬러 모델](https://"
"en.wikipedia.org/wiki/Color_model) 및 [`enum`](../../../custom_types/enum.md)"

#: src/flow_control/match/destructuring/destructure_pointers.md:3
msgid ""
"For pointers, a distinction needs to be made between destructuring and "
"dereferencing as they are different concepts which are used differently from "
"languages like C/C++."
msgstr ""
"포인터의 경우, 구조 분해(destructuring)와 역참조(dereferencing)를 구분해야 합"
"니다. 이들은 C/C++와 같은 언어와는 다르게 사용되는 서로 다른 개념이기 때문입"
"니다."

#: src/flow_control/match/destructuring/destructure_pointers.md:7
msgid "Dereferencing uses `*`"
msgstr "역참조는 `*`를 사용합니다"

#: src/flow_control/match/destructuring/destructure_pointers.md:8
msgid "Destructuring uses `&`, `ref`, and `ref mut`"
msgstr "구조 분해는 `&`, `ref`, `ref mut`을 사용합니다"

#: src/flow_control/match/destructuring/destructure_pointers.md:12
msgid ""
"// Assign a reference of type `i32`. The `&` signifies there\n"
"    // is a reference being assigned.\n"
msgstr ""
"// `i32` 타입의 참조를 할당합니다. `&`는 참조가 할당되고 있음을 나타냅니다.\n"

#: src/flow_control/match/destructuring/destructure_pointers.md:17
msgid ""
"// If `reference` is pattern matched against `&val`, it results\n"
"        // in a comparison like:\n"
"        // `&i32`\n"
"        // `&val`\n"
"        // ^ We see that if the matching `&`s are dropped, then the `i32`\n"
"        // should be assigned to `val`.\n"
msgstr ""
"// 만약 `reference`를 `&val`에 대해 패턴 매칭하면, 다음과 같은 비교 결과가 됩"
"니다:\n"
"// `&i32`\n"
"// `&val`\n"
"// ^ 매칭되는 `&`들을 떼어내면, `i32`가 `val`에 할당되어야 함을 알 수 있습니"
"다.\n"

#: src/flow_control/match/destructuring/destructure_pointers.md:23
msgid "\"Got a value via destructuring: {:?}\""
msgstr "\"구조 분해를 통해 값을 얻었습니다: {:?}\""

#: src/flow_control/match/destructuring/destructure_pointers.md:26
msgid "// To avoid the `&`, you dereference before matching.\n"
msgstr "// `&`를 피하려면, 매칭하기 전에 역참조를 수행합니다.\n"

#: src/flow_control/match/destructuring/destructure_pointers.md:28
msgid "\"Got a value via dereferencing: {:?}\""
msgstr "\"역참조를 통해 값을 얻었습니다: {:?}\""

#: src/flow_control/match/destructuring/destructure_pointers.md:31
msgid ""
"// What if you don't start with a reference? `reference` was a `&`\n"
"    // because the right side was already a reference. This is not\n"
"    // a reference because the right side is not one.\n"
msgstr ""
"// 참조로 시작하지 않는다면 어떨까요? `reference`는 오른쪽이 이미\n"
"// 참조였기 때문에 `&`였습니다. 이것은 오른쪽이 참조가 아니기 때문에\n"
"// 참조가 아닙니다.\n"

#: src/flow_control/match/destructuring/destructure_pointers.md:36
msgid ""
"// Rust provides `ref` for exactly this purpose. It modifies the\n"
"    // assignment so that a reference is created for the element; this\n"
"    // reference is assigned.\n"
msgstr ""
"// Rust는 정확히 이 목적을 위해 `ref`를 제공합니다. 이는 할당 방식을\n"
"// 수정하여 요소에 대한 참조가 생성되도록 하며, 이 참조가 할당됩니다.\n"

#: src/flow_control/match/destructuring/destructure_pointers.md:41
msgid ""
"// Accordingly, by defining 2 values without references, references\n"
"    // can be retrieved via `ref` and `ref mut`.\n"
msgstr ""
"// 따라서, 참조가 없는 두 값을 정의함으로써, `ref`와 `ref mut`를 통해 참조를 "
"가져올 수 있습니다.\n"

#: src/flow_control/match/destructuring/destructure_pointers.md:46
msgid "// Use `ref` keyword to create a reference.\n"
msgstr "// 참조를 생성하려면 `ref` 키워드를 사용합니다.\n"

#: src/flow_control/match/destructuring/destructure_pointers.md:48
msgid "\"Got a reference to a value: {:?}\""
msgstr "\"값에 대한 참조를 얻었습니다: {:?}\""

#: src/flow_control/match/destructuring/destructure_pointers.md:51
msgid "// Use `ref mut` similarly.\n"
msgstr "// `ref mut`도 비슷하게 사용합니다.\n"

#: src/flow_control/match/destructuring/destructure_pointers.md:54
msgid ""
"// Got a reference. Gotta dereference it before we can\n"
"            // add anything to it.\n"
msgstr ""
"// 참조를 얻었습니다. 여기에 무언가를 더하기 전에\n"
"// 역참조를 해야 합니다.\n"

#: src/flow_control/match/destructuring/destructure_pointers.md:57
msgid "\"We added 10. `mut_value`: {:?}\""
msgstr "\"10을 더했습니다. `mut_value`: {:?}\""

#: src/flow_control/match/destructuring/destructure_pointers.md:65
msgid "[The ref pattern](../../../scope/borrow/ref.md)"
msgstr "[ref 패턴](../../../scope/borrow/ref.md)"

#: src/flow_control/match/destructuring/destructure_structures.md:3
msgid "Similarly, a `struct` can be destructured as shown:"
msgstr "마찬가지로, `struct`는 다음과 같이 구조 분해될 수 있습니다:"

#: src/flow_control/match/destructuring/destructure_structures.md:12
msgid "// Try changing the values in the struct to see what happens\n"
msgstr "// 구조체의 값을 변경하여 어떤 일이 일어나는지 확인해 보세요\n"

#: src/flow_control/match/destructuring/destructure_structures.md:16
msgid "\"First of x is 1, b = {},  y = {} \""
msgstr "\"x의 첫 번째는 1이고, b = {}, y = {} 입니다\""

#: src/flow_control/match/destructuring/destructure_structures.md:18
msgid ""
"// you can destructure structs and rename the variables,\n"
"        // the order is not important\n"
msgstr ""
"// 구조체를 구조 분해하고 변수 이름을 바꿀 수 있으며, 순서는 중요하지 않습니"
"다\n"

#: src/flow_control/match/destructuring/destructure_structures.md:20
msgid "\"y is 2, i = {:?}\""
msgstr "\"y는 2이고, i = {:?}입니다\""

#: src/flow_control/match/destructuring/destructure_structures.md:22
msgid "// and you can also ignore some variables:\n"
msgstr "// 그리고 일부 변수를 무시할 수도 있습니다:\n"

#: src/flow_control/match/destructuring/destructure_structures.md:23
msgid "\"y = {}, we don't care about x\""
msgstr "\"y = {}이며, x는 신경 쓰지 않습니다\""

#: src/flow_control/match/destructuring/destructure_structures.md:24
msgid ""
"// this will give an error: pattern does not mention field `x`\n"
"        //Foo { y } => println!(\"y = {}\", y),\n"
msgstr ""
"// 이것은 에러를 발생시킵니다: 패턴에 `x` 필드가 언급되지 않았습니다\n"
"//Foo { y } => println!(\"y = {}\", y),\n"

#: src/flow_control/match/destructuring/destructure_structures.md:30
msgid "// You do not need a match block to destructure structs:\n"
msgstr ""
"// 구조체를 구조 분해하기 위해 반드시 match 블록이 필요한 것은 아닙니다:\n"

#: src/flow_control/match/destructuring/destructure_structures.md:32
msgid "\"Outside: x0 = {x0:?}, y0 = {y0}\""
msgstr "\"외부: x0 = {x0:?}, y0 = {y0}\""

#: src/flow_control/match/destructuring/destructure_structures.md:34
msgid "// Destructuring works with nested structs as well:\n"
msgstr "// 구조 분해는 중첩된 구조체에서도 작동합니다:\n"

#: src/flow_control/match/destructuring/destructure_structures.md:41
msgid "\"Nested: nested_x = {nested_x:?}, nested_y = {nested_y:?}\""
msgstr "\"중첩됨: nested_x = {nested_x:?}, nested_y = {nested_y:?}\""

#: src/flow_control/match/destructuring/destructure_structures.md:47
msgid "[Structs](../../../custom_types/structs.md)"
msgstr "[구조체](../../../custom_types/structs.md)"

#: src/flow_control/match/guard.md:3
msgid "A `match` _guard_ can be added to filter the arm."
msgstr ""
"매치 팔(arm)을 필터링하기 위해 `match` _가드(guard)_를 추가할 수 있습니다."

#: src/flow_control/match/guard.md:14
msgid "// ^ TODO try different values for `temperature`\n"
msgstr "// ^ TODO `temperature`에 다른 값을 시도해 보세요\n"

#: src/flow_control/match/guard.md:17
msgid "\"{}C is above 30 Celsius\""
msgstr "\"{}C는 섭씨 30도 초과입니다\""

#: src/flow_control/match/guard.md:18
msgid "// The `if condition` part ^ is a guard\n"
msgstr "// `if 조건` 부분 ^ 이 가드입니다\n"

#: src/flow_control/match/guard.md:19
msgid "\"{}C is equal to or below 30 Celsius\""
msgstr "\"{}C는 섭씨 30도 이하입니다\""

#: src/flow_control/match/guard.md:21
msgid "\"{}F is above 86 Fahrenheit\""
msgstr "\"{}F는 화씨 86도 초과입니다\""

#: src/flow_control/match/guard.md:22
msgid "\"{}F is equal to or below 86 Fahrenheit\""
msgstr "\"{}F는 화씨 86도 이하입니다\""

#: src/flow_control/match/guard.md:27
msgid ""
"Note that the compiler won't take guard conditions into account when "
"checking if all patterns are covered by the match expression."
msgstr ""
"컴파일러는 매치 표현식이 모든 패턴을 다루고 있는지 확인할 때 가드 조건을 고려"
"하지 않는다는 점에 유의하세요."

#: src/flow_control/match/guard.md:35
msgid "\"Zero\""
msgstr "\"0\""

#: src/flow_control/match/guard.md:36
msgid "\"Greater than zero\""
msgstr "\"0보다 큼\""

#: src/flow_control/match/guard.md:37
msgid ""
"// _ => unreachable!(\"Should never happen.\"),\n"
"        // TODO ^ uncomment to fix compilation\n"
msgstr ""
"// _ => unreachable!(\"절대 일어날 수 없는 일입니다.\"),\n"
"// TODO ^ 컴파일을 수정하려면 주석을 해제하세요\n"

#: src/flow_control/match/guard.md:45
msgid ""
"[Tuples](../../primitives/tuples.md) [Enums](../../custom_types/enum.md)"
msgstr ""
"[튜플](../../primitives/tuples.md) [열거형](../../custom_types/enum.md)"

#: src/flow_control/match/binding.md:3
msgid ""
"Indirectly accessing a variable makes it impossible to branch and use that "
"variable without re-binding. `match` provides the `@` sigil for binding "
"values to names:"
msgstr ""
"변수에 간접적으로 접근하면 재바인딩 없이 해당 변수를 분기하고 사용하는 것이 "
"불가능합니다. `match`는 값을 이름에 바인딩하기 위한 `@` 기호를 제공합니다:"

#: src/flow_control/match/binding.md:8
msgid "// A function `age` which returns a `u32`.\n"
msgstr "// `u32`를 반환하는 `age` 함수.\n"

#: src/flow_control/match/binding.md:14
msgid "\"Tell me what type of person you are\""
msgstr "\"당신이 어떤 종류의 사람인지 말해주세요\""

#: src/flow_control/match/binding.md:17
msgid "\"I haven't celebrated my first birthday yet\""
msgstr "\"아직 첫 번째 생일을 맞이하지 않았습니다\""

#: src/flow_control/match/binding.md:18
msgid ""
"// Could `match` 1 ..= 12 directly but then what age\n"
"        // would the child be?\n"
"        // Could `match` n and use an `if` guard, but would\n"
"        // not contribute to exhaustiveness checks.\n"
"        // (Although in this case that would not matter since\n"
"        // a \"catch-all\" pattern is present at the bottom)\n"
"        // Instead, bind to `n` for the sequence of 1 ..= 12.\n"
"        // Now the age can be reported.\n"
msgstr ""
"// 1 ..= 12를 직접 `match`할 수 있지만, 그러면\n"
"// 아이의 나이가 몇 살인지 알 수 있을까요?\n"
"// n을 `match`하고 `if` 가드를 사용할 수 있지만,\n"
"// 이는 철저함(exhaustiveness) 검사에 기여하지 않습니다.\n"
"// (비록 이 경우에는 하단에 \"catch-all\" 패턴이 있어 상관없지만요)\n"
"// 대신, 1 ..= 12 시퀀스에 대해 `n`에 바인딩합니다.\n"
"// 이제 나이를 보고할 수 있습니다.\n"

#: src/flow_control/match/binding.md:26
msgid "\"I'm a child of age {:?}\""
msgstr "\"저는 {:?}살인 어린이입니다\""

#: src/flow_control/match/binding.md:27 src/flow_control/match/binding.md:29
msgid "\"I'm a teen of age {:?}\""
msgstr "\"저는 {:?}살인 청소년입니다\""

#: src/flow_control/match/binding.md:28
msgid "// A similar binding can be done when matching several values.\n"
msgstr "// 여러 값을 매칭할 때도 유사한 바인딩을 수행할 수 있습니다.\n"

#: src/flow_control/match/binding.md:30
msgid "// Nothing bound. Return the result.\n"
msgstr "// 바인딩된 것이 없습니다. 결과를 반환합니다.\n"

#: src/flow_control/match/binding.md:31
msgid "\"I'm an old person of age {:?}\""
msgstr "\"저는 {:?}살인 어르신입니다\""

#: src/flow_control/match/binding.md:36
msgid ""
"You can also use binding to \"destructure\" `enum` variants, such as "
"`Option`:"
msgstr ""
"또한 `Option`과 같은 `enum` 변체를 \"구조 분해\"하기 위해 바인딩을 사용할 수 "
"있습니다:"

#: src/flow_control/match/binding.md:45
msgid ""
"// Got `Some` variant, match if its value, bound to `n`,\n"
"        // is equal to 42.\n"
"        // Could also use `Some(42)` and print `\"The Answer: 42!\"`\n"
"        // but that would require changing `42` in 2 spots should\n"
"        // you ever wish to change it.\n"
"        // Could also use `Some(n) if n == 42` and print `\"The Answer: {n}!"
"\"`\n"
"        // but that would not contribute to exhaustiveness checks.\n"
"        // (Although in this case that would not matter since\n"
"        // the next arm is a \"catch-all\" pattern)\n"
msgstr ""
"// `Some` 변체를 얻었을 때, `n`에 바인딩된 그 값이\n"
"// 42와 같은지 매칭합니다.\n"
"// `Some(42)`를 사용하여 `\"정답: 42!\"`를 출력할 수도 있지만,\n"
"// 그러면 나중에 값을 바꾸고 싶을 때 두 군데를 수정해야 합니다.\n"
"// `Some(n) if n == 42`를 사용하여 `\"정답: {n}!\"`를 출력할 수도 있지만,\n"
"// 이는 철저함 검사에 기여하지 않습니다.\n"
"// (비록 이 경우에는 다음 팔이 \"catch-all\" 패턴이라 상관없지만요)\n"

#: src/flow_control/match/binding.md:54
msgid "\"The Answer: {}!\""
msgstr "\"정답: {}!\""

#: src/flow_control/match/binding.md:55
msgid "// Match any other number.\n"
msgstr "// 다른 모든 숫자 매칭.\n"

#: src/flow_control/match/binding.md:56
msgid "\"Not interesting... {}\""
msgstr "\"흥미롭지 않네요... {}\""

#: src/flow_control/match/binding.md:57
msgid "// Match anything else (`None` variant).\n"
msgstr "// 그 외의 모든 경우(`None` 변체) 매칭.\n"

#: src/flow_control/match/binding.md:65
msgid ""
"[`functions`](../../fn.md), [`enums`](../../custom_types/enum.md) and "
"[`Option`](../../std/option.md)"
msgstr ""
"[`함수`](../../fn.md), [`열거형`](../../custom_types/enum.md) 그리고 "
"[`Option`](../../std/option.md)"

#: src/flow_control/if_let.md:3
msgid ""
"For some use cases, when matching enums, `match` is awkward. For example:"
msgstr ""
"어떤 경우에는 열거형을 매칭할 때 `match`가 어색할 수 있습니다. 예를 들어:"

#: src/flow_control/if_let.md:6 src/flow_control/while_let.md:7
#: src/flow_control/while_let.md:35
msgid "// Make `optional` of type `Option<i32>`\n"
msgstr "// `Option<i32>` 타입의 `optional` 생성\n"

#: src/flow_control/if_let.md:10
msgid "\"This is a really long string and `{:?}`\""
msgstr "\"이것은 정말 긴 문자열이며 `{:?}`입니다\""

#: src/flow_control/if_let.md:12
msgid ""
"// ^ Required because `match` is exhaustive. Doesn't it seem\n"
"    // like wasted space?\n"
msgstr ""
"// ^ `match`는 철저해야(exhaustive) 하기 때문에 필요합니다. 공간 낭비처럼\n"
"// 보이진 않나요?\n"

#: src/flow_control/if_let.md:18
msgid ""
"`if let` is cleaner for this use case and in addition allows various failure "
"options to be specified:"
msgstr ""
"이런 경우 `if let`이 더 깔끔하며, 추가로 다양한 실패 옵션을 지정할 수 있습니"
"다:"

#: src/flow_control/if_let.md:23
msgid "// All have type `Option<i32>`\n"
msgstr "// 모두 `Option<i32>` 타입입니다\n"

#: src/flow_control/if_let.md:28
msgid ""
"// The `if let` construct reads: \"if `let` destructures `number` into\n"
"    // `Some(i)`, evaluate the block (`{}`).\n"
msgstr ""
"// `if let` 구문은 다음과 같이 읽힙니다: \"만약 `let`이 `number`를\n"
"// `Some(i)`로 구조 분해한다면, 블록(`{}`)을 실행하라.\"\n"

#: src/flow_control/if_let.md:31 src/flow_control/if_let.md:36
#: src/flow_control/if_let.md:46
msgid "\"Matched {:?}!\""
msgstr "\"{:?}가 매칭되었습니다!\""

#: src/flow_control/if_let.md:34
msgid "// If you need to specify a failure, use an else:\n"
msgstr "// 실패한 경우를 지정해야 한다면, else를 사용하세요:\n"

#: src/flow_control/if_let.md:38
msgid "// Destructure failed. Change to the failure case.\n"
msgstr "// 구조 분해에 실패했습니다. 실패 사례로 전환합니다.\n"

#: src/flow_control/if_let.md:39 src/flow_control/if_let.md:50
msgid "\"Didn't match a number. Let's go with a letter!\""
msgstr "\"숫자와 매칭되지 않았습니다. 문자로 해봅시다!\""

#: src/flow_control/if_let.md:42
msgid "// Provide an altered failing condition.\n"
msgstr "// 변경된 실패 조건을 제공합니다.\n"

#: src/flow_control/if_let.md:47
msgid ""
"// Destructure failed. Evaluate an `else if` condition to see if the\n"
"    // alternate failure branch should be taken:\n"
msgstr ""
"// 구조 분해에 실패했습니다. 다른 실패 분기를 타야 하는지\n"
"// `else if` 조건을 평가합니다:\n"

#: src/flow_control/if_let.md:52
msgid "// The condition evaluated false. This branch is the default:\n"
msgstr "// 조건이 거짓(false)으로 평가되었습니다. 이 분기가 기본입니다:\n"

#: src/flow_control/if_let.md:53
msgid "\"I don't like letters. Let's go with an emoticon :)!\""
msgstr "\"문자는 별로예요. 이모티콘 :)으로 가봅시다!\""

#: src/flow_control/if_let.md:58
msgid "In the same way, `if let` can be used to match any enum value:"
msgstr ""
"같은 방식으로, `if let`은 모든 열거형 값을 매칭하는 데 사용될 수 있습니다:"

#: src/flow_control/if_let.md:61
msgid "// Our example enum\n"
msgstr "// 예제 열거형\n"

#: src/flow_control/if_let.md:69
msgid "// Create example variables\n"
msgstr "// 예제 변수 생성\n"

#: src/flow_control/if_let.md:74 src/flow_control/if_let.md:110
msgid "// Variable a matches Foo::Bar\n"
msgstr "// 변수 a는 Foo::Bar와 매칭됩니다\n"

#: src/flow_control/if_let.md:76 src/flow_control/if_let.md:113
msgid "\"a is foobar\""
msgstr "\"a는 foobar입니다\""

#: src/flow_control/if_let.md:79
msgid ""
"// Variable b does not match Foo::Bar\n"
"    // So this will print nothing\n"
msgstr ""
"// 변수 b는 Foo::Bar와 매칭되지 않습니다\n"
"// 따라서 아무것도 출력되지 않습니다\n"

#: src/flow_control/if_let.md:82
msgid "\"b is foobar\""
msgstr "\"b는 foobar입니다\""

#: src/flow_control/if_let.md:85
msgid ""
"// Variable c matches Foo::Qux which has a value\n"
"    // Similar to Some() in the previous example\n"
msgstr ""
"// 변수 c는 값을 가진 Foo::Qux와 매칭됩니다\n"
"// 앞선 예제의 Some()과 유사합니다\n"

#: src/flow_control/if_let.md:88
msgid "\"c is {}\""
msgstr "\"c는 {}입니다\""

#: src/flow_control/if_let.md:91
msgid "// Binding also works with `if let`\n"
msgstr "// 바인딩은 `if let`에서도 작동합니다\n"

#: src/flow_control/if_let.md:93
msgid "\"c is one hundred\""
msgstr "\"c는 100입니다\""

#: src/flow_control/if_let.md:98
msgid ""
"Another benefit is that `if let` allows us to match non-parameterized enum "
"variants. This is true even in cases where the enum doesn't implement or "
"derive `PartialEq`. In such cases `if Foo::Bar == a` would fail to compile, "
"because instances of the enum cannot be equated, however `if let` will "
"continue to work."
msgstr ""
"또 다른 장점은 `if let`을 사용하면 파라미터가 없는 열거형 변체도 매칭할 수 있"
"다는 점입니다. 이는 열거형이 `PartialEq`를 구현하거나 유도하지 않는 경우에도 "
"마찬가지입니다. 이러한 경우 `if Foo::Bar == a`는 열거형 인스턴스를 비교할 수 "
"없기 때문에 컴파일에 실패하지만, `if let`은 계속 작동합니다."

#: src/flow_control/if_let.md:100
msgid "Would you like a challenge? Fix the following example to use `if let`:"
msgstr "도전해 보시겠습니까? 다음 예제를 `if let`을 사용하도록 수정해 보세요:"

#: src/flow_control/if_let.md:103
msgid ""
"// This enum purposely neither implements nor derives PartialEq.\n"
"// That is why comparing Foo::Bar == a fails below.\n"
msgstr ""
"// 이 열거형은 의도적으로 PartialEq를 구현하거나 유도(derive)하지 않았습니"
"다.\n"
"// 그래서 아래에서 Foo::Bar == a 를 비교하는 것이 실패합니다.\n"

#: src/flow_control/if_let.md:112
msgid "// ^-- this causes a compile-time error. Use `if let` instead.\n"
msgstr ""
"// ^-- 이것은 컴파일 타임 에러를 발생시킵니다. 대신 `if let`을 사용하세요.\n"

#: src/flow_control/if_let.md:120
msgid ""
"[`enum`](../custom_types/enum.md), [`Option`](../std/option.md), and the "
"[RFC](https://github.com/rust-lang/rfcs/pull/160)"
msgstr ""
"[`enum`](../custom_types/enum.md), [`Option`](../std/option.md), 그리고 [RFC]"
"(https://github.com/rust-lang/rfcs/pull/160)"

#: src/flow_control/let_else.md:3
msgid "🛈 stable since: rust 1.65"
msgstr "🛈 안정화 버전: rust 1.65"

#: src/flow_control/let_else.md:5
msgid ""
"🛈 you can target specific edition by compiling like this `rustc --"
"edition=2021 main.rs`"
msgstr ""
"🛈 다음과 같이 컴파일하여 특정 에디션을 타겟팅할 수 있습니다: `rustc --"
"edition=2021 main.rs`"

#: src/flow_control/let_else.md:8
msgid ""
"With `let`\\-`else`, a refutable pattern can match and bind variables in the "
"surrounding scope like a normal `let`, or else diverge (e.g. `break`, "
"`return`, `panic!`) when the pattern doesn't match."
msgstr ""
"`let`\\-`else`를 사용하면, 일반적인 `let`처럼 주변 스코프에서 변수를 매칭하"
"고 바인딩할 수 있으며, 패턴이 매칭되지 않을 경우 분기(예: `break`, `return`, "
"`panic!`)할 수 있습니다."

#: src/flow_control/let_else.md:16 src/flow_control/let_else.md:39
#: src/std/str.md:41
msgid "' '"
msgstr "' '"

#: src/flow_control/let_else.md:18 src/flow_control/let_else.md:42
msgid "\"Can't segment count item pair: '{s}'\""
msgstr "\"카운트 아이템 쌍을 분리할 수 없습니다: '{s}'\""

#: src/flow_control/let_else.md:21 src/flow_control/let_else.md:47
msgid "\"Can't parse integer: '{count_str}'\""
msgstr "\"정수를 파싱할 수 없습니다: '{count_str}'\""

#: src/flow_control/let_else.md:27 src/flow_control/let_else.md:52
msgid "\"3 chairs\""
msgstr "\"3 chairs\""

#: src/flow_control/let_else.md:27 src/flow_control/let_else.md:52
msgid "\"chairs\""
msgstr "\"chairs\""

#: src/flow_control/let_else.md:31
msgid ""
"The scope of name bindings is the main thing that makes this different from "
"`match` or `if let`\\-`else` expressions. You could previously approximate "
"these patterns with an unfortunate bit of repetition and an outer `let`:"
msgstr ""
"이름 바인딩의 스코프는 이것이 `match`나 `if let`\\-`else` 표현식과 다른 주요 "
"점입니다. 이전에는 외부 `let`과 약간의 반복을 통해 이러한 패턴을 흉내 낼 수 "
"있었습니다:"

#: src/flow_control/let_else.md:57
msgid ""
"[option](../std/option.md), [match](./match.md), [if let](./if_let.md) and "
"the [let-else RFC](https://rust-lang.github.io/rfcs/3137-let-else.html)."
msgstr ""
"[option](../std/option.md), [match](./match.md), [if let](./if_let.md) 그리"
"고 [let-else RFC](https://rust-lang.github.io/rfcs/3137-let-else.html)."

#: src/flow_control/while_let.md:3
msgid ""
"Similar to `if let`, `while let` can make awkward `match` sequences more "
"tolerable. Consider the following sequence that increments `i`:"
msgstr ""
"`if let`과 유사하게, `while let`은 어색한 `match` 시퀀스를 더 견딜만하게 만들"
"어 줍니다. `i`를 증가시키는 다음 시퀀스를 고려해 보세요:"

#: src/flow_control/while_let.md:9
msgid "// Repeatedly try this test.\n"
msgstr "// 이 테스트를 반복해서 시도합니다.\n"

#: src/flow_control/while_let.md:13
msgid "// If `optional` destructures, evaluate the block.\n"
msgstr "// 만약 `optional`이 구조 분해된다면, 블록을 평가합니다.\n"

#: src/flow_control/while_let.md:16 src/flow_control/while_let.md:42
msgid "\"Greater than 9, quit!\""
msgstr "\"9보다 큽니다, 종료!\""

#: src/flow_control/while_let.md:19 src/flow_control/while_let.md:45
msgid "\"`i` is `{:?}`. Try again.\""
msgstr "\"`i`는 `{:?}`입니다. 다시 시도하세요.\""

#: src/flow_control/while_let.md:22
msgid "// ^ Requires 3 indentations!\n"
msgstr "// ^ 3단계의 들여쓰기가 필요합니다!\n"

#: src/flow_control/while_let.md:24
msgid "// Quit the loop when the destructure fails:\n"
msgstr "// 구조 분해에 실패하면 루프를 종료합니다:\n"

#: src/flow_control/while_let.md:26
msgid "// ^ Why should this be required? There must be a better way!\n"
msgstr "// ^ 왜 이것이 필요할까요? 분명 더 좋은 방법이 있을 것입니다!\n"

#: src/flow_control/while_let.md:31
msgid "Using `while let` makes this sequence much nicer:"
msgstr "`while let`을 사용하면 이 시퀀스가 훨씬 깔끔해집니다:"

#: src/flow_control/while_let.md:38
msgid ""
"// This reads: \"while `let` destructures `optional` into\n"
"    // `Some(i)`, evaluate the block (`{}`). Else `break`.\n"
msgstr ""
"// 다음과 같이 읽힙니다: \"`let`이 `optional`을 `Some(i)`로\n"
"// 구조 분해하는 동안, 블록(`{}`)을 실행하라. 그 외에는 `break` 하라.\"\n"

#: src/flow_control/while_let.md:48
msgid ""
"// ^ Less rightward drift and doesn't require\n"
"        // explicitly handling the failing case.\n"
msgstr ""
"// ^ 오른쪽으로의 들여쓰기가 줄어들었으며 실패 사례를\n"
"// 명시적으로 처리할 필요가 없습니다.\n"

#: src/flow_control/while_let.md:51
msgid ""
"// ^ `if let` had additional optional `else`/`else if`\n"
"    // clauses. `while let` does not have these.\n"
msgstr ""
"// ^ `if let`에는 추가적인 선택 사항인 `else`/`else if` 절이\n"
"// 있었지만, `while let`에는 이러한 것들이 없습니다.\n"

#: src/flow_control/while_let.md:58
msgid ""
"[`enum`](../custom_types/enum.md), [`Option`](../std/option.md), and the "
"[RFC](https://github.com/rust-lang/rfcs/pull/214)"
msgstr ""
"[`enum`](../custom_types/enum.md), [`Option`](../std/option.md), 그리고 [RFC]"
"(https://github.com/rust-lang/rfcs/pull/214)"

#: src/fn.md:3
msgid ""
"Functions are declared using the `fn` keyword. Its arguments are type "
"annotated, just like variables, and, if the function returns a value, the "
"return type must be specified after an arrow `->`."
msgstr ""
"함수는 `fn` 키워드를 사용하여 선언됩니다. 인자는 변수와 마찬가지로 타입 어노"
"테이션이 필요하며, 함수가 값을 반환하는 경우 반환 타입은 화살표 `->` 뒤에 지"
"정해야 합니다."

#: src/fn.md:7
msgid ""
"The final expression in the function will be used as return value. "
"Alternatively, the `return` statement can be used to return a value earlier "
"from within the function, even from inside loops or `if` statements."
msgstr ""
"함수의 마지막 표현식은 반환 값으로 사용됩니다. 또는 `return` 문을 사용하여 루"
"프나 `if` 문 내부를 포함하여 함수 내에서 더 일찍 값을 반환할 수 있습니다."

#: src/fn.md:11
msgid "Let's rewrite FizzBuzz using functions!"
msgstr "함수를 사용하여 FizzBuzz를 다시 작성해 봅시다!"

#: src/fn.md:14
msgid ""
"// Unlike C/C++, there's no restriction on the order of function "
"definitions\n"
msgstr "// C/C++와 달리, 함수 정의 순서에는 제한이 없습니다.\n"

#: src/fn.md:16
msgid "// We can use this function here, and define it somewhere later\n"
msgstr "// 여기서 이 함수를 사용하고, 나중에 어딘가에서 정의할 수 있습니다.\n"

#: src/fn.md:19
msgid "// Function that returns a boolean value\n"
msgstr "// 불리언 값을 반환하는 함수\n"

#: src/fn.md:22
msgid "// Corner case, early return\n"
msgstr "// 예외 케이스, 조기 반환\n"

#: src/fn.md:27
msgid "// This is an expression, the `return` keyword is not necessary here\n"
msgstr "// 이것은 표현식이며, 여기서는 `return` 키워드가 필요하지 않습니다.\n"

#: src/fn.md:30
msgid ""
"// Functions that \"don't\" return a value, actually return the unit type "
"`()`\n"
msgstr ""
"// 값을 반환하지 \"않는\" 함수는 실제로는 유닛 타입 `()`를 반환합니다.\n"

#: src/fn.md:43
msgid ""
"// When a function returns `()`, the return type can be omitted from the\n"
"// signature\n"
msgstr ""
"// 함수가 `()`를 반환할 때, 시그니처에서 반환 타입을 생략할 수 있습니다.\n"

#: src/fn/methods.md:1
msgid "Associated functions & Methods"
msgstr "연관 함수와 메서드"

#: src/fn/methods.md:3
msgid ""
"Some functions are connected to a particular type. These come in two forms: "
"associated functions, and methods. Associated functions are functions that "
"are defined on a type generally, while methods are associated functions that "
"are called on a particular instance of a type."
msgstr ""
"일부 함수는 특정 타입과 연결되어 있습니다. 이들은 연관 함수와 메서드라는 두 "
"가지 형태로 제공됩니다. 연관 함수는 일반적으로 타입 상에 정의된 함수인 반면, "
"메서드는 특정 타입의 인스턴스에서 호출되는 연관 함수입니다."

#: src/fn/methods.md:13
msgid ""
"// Implementation block, all `Point` associated functions & methods go in "
"here\n"
msgstr ""
"// 구현(Implementation) 블록으로, 모든 `Point` 연관 함수와 메서드가 여기에 들"
"어갑니다.\n"

#: src/fn/methods.md:16
msgid ""
"// This is an \"associated function\" because this function is associated "
"with\n"
"    // a particular type, that is, Point.\n"
"    //\n"
"    // Associated functions don't need to be called with an instance.\n"
"    // These functions are generally used like constructors.\n"
msgstr ""
"// 이것은 이 함수가 특정 타입인 Point와 연관되어 있기 때문에\n"
"// \"연관 함수\"라고 불립니다.\n"
"//\n"
"// 연관 함수는 인스턴스를 통해 호출될 필요가 없습니다.\n"
"// 이러한 함수들은 일반적으로 생성자처럼 사용됩니다.\n"

#: src/fn/methods.md:25
msgid "// Another associated function, taking two arguments:\n"
msgstr "// 두 개의 인자를 받는 또 다른 연관 함수:\n"

#: src/fn/methods.md:37
msgid ""
"// This is a method\n"
"    // `&self` is sugar for `self: &Self`, where `Self` is the type of the\n"
"    // caller object. In this case `Self` = `Rectangle`\n"
msgstr ""
"// 이것은 메서드입니다\n"
"// `&self`는 `self: &Self`를 줄여 쓴 것인데, 여기서 `Self`는\n"
"// 호출 객체의 타입을 의미합니다. 이 경우 `Self` = `Rectangle`입니다.\n"

#: src/fn/methods.md:41
msgid "// `self` gives access to the struct fields via the dot operator\n"
msgstr ""
"// `self`는 점(dot) 연산자를 통해 구조체 필드에 대한 접근을 제공합니다.\n"

#: src/fn/methods.md:45
msgid ""
"// `abs` is a `f64` method that returns the absolute value of the\n"
"        // caller\n"
msgstr "// `abs`는 호출자의 절댓값을 반환하는 `f64` 메서드입니다.\n"

#: src/fn/methods.md:57
msgid ""
"// This method requires the caller object to be mutable\n"
"    // `&mut self` desugars to `self: &mut Self`\n"
msgstr ""
"// 이 메서드는 호출 객체가 가변적일 것을 요구합니다\n"
"// `&mut self`는 `self: &mut Self`로 풀어서 쓸 수 있습니다.\n"

#: src/fn/methods.md:67
msgid "// `Pair` owns resources: two heap allocated integers\n"
msgstr "// `Pair`는 리소스를 소유합니다: 힙에 할당된 두 개의 정수\n"

#: src/fn/methods.md:72
msgid ""
"// This method \"consumes\" the resources of the caller object\n"
"    // `self` desugars to `self: Self`\n"
msgstr ""
"// 이 메서드는 호출 객체의 리소스를 \"소비\"합니다\n"
"// `self`는 `self: Self`로 풀어서 쓸 수 있습니다.\n"

#: src/fn/methods.md:75
msgid "// Destructure `self`\n"
msgstr "// `self` 구조 분해\n"

#: src/fn/methods.md:78
msgid "\"Destroying Pair({}, {})\""
msgstr "\"Pair({}, {}) 파괴 중\""

#: src/fn/methods.md:80
msgid "// `first` and `second` go out of scope and get freed\n"
msgstr "// `first`와 `second`는 스코프를 벗어나며 해제됩니다.\n"

#: src/fn/methods.md:86
msgid "// Associated functions are called using double colons\n"
msgstr "// 연관 함수는 이중 콜론을 사용하여 호출됩니다.\n"

#: src/fn/methods.md:91
msgid ""
"// Methods are called using the dot operator\n"
"    // Note that the first argument `&self` is implicitly passed, i.e.\n"
"    // `rectangle.perimeter()` === `Rectangle::perimeter(&rectangle)`\n"
msgstr ""
"// 메서드는 점 연산자를 사용하여 호출됩니다.\n"
"// 첫 번째 인자인 `&self`는 암시적으로 전달됩니다. 즉,\n"
"// `rectangle.perimeter()`는 `Rectangle::perimeter(&rectangle)`와 동일합니"
"다.\n"

#: src/fn/methods.md:94
msgid "\"Rectangle perimeter: {}\""
msgstr "\"사각형 둘레: {}\""

#: src/fn/methods.md:95
msgid "\"Rectangle area: {}\""
msgstr "\"사각형 넓이: {}\""

#: src/fn/methods.md:102
msgid ""
"// Error! `rectangle` is immutable, but this method requires a mutable\n"
"    // object\n"
"    //rectangle.translate(1.0, 0.0);\n"
"    // TODO ^ Try uncommenting this line\n"
msgstr ""
"// 에러! `rectangle`은 불변이지만, 이 메서드는 가변 객체를 요구합니다.\n"
"// rectangle.translate(1.0, 0.0);\n"
"// TODO ^ 이 줄의 주석을 해제해 보세요\n"

#: src/fn/methods.md:107
msgid "// Okay! Mutable objects can call mutable methods\n"
msgstr "// 좋습니다! 가변 객체는 가변 메서드를 호출할 수 있습니다\n"

#: src/fn/methods.md:114
msgid ""
"// Error! Previous `destroy` call \"consumed\" `pair`\n"
"    //pair.destroy();\n"
"    // TODO ^ Try uncommenting this line\n"
msgstr ""
"// 에러! 이전의 `destroy` 호출이 `pair`를 \"소비\"했습니다\n"
"// pair.destroy();\n"
"// TODO ^ 이 줄의 주석을 해제해 보세요\n"

#: src/fn/closures.md:3
msgid ""
"Closures are functions that can capture the enclosing environment. For "
"example, a closure that captures the `x` variable:"
msgstr ""
"클로저는 감싸고 있는 환경을 캡처할 수 있는 함수입니다. 예를 들어, `x` 변수를 "
"캡처하는 클로저는 다음과 같습니다:"

#: src/fn/closures.md:10
msgid ""
"The syntax and capabilities of closures make them very convenient for on the "
"fly usage. Calling a closure is exactly like calling a function. However, "
"both input and return types _can_ be inferred and input variable names "
"_must_ be specified."
msgstr ""
"클로저의 구문과 기능은 즉석에서 사용하기에 매우 편리합니다. 클로저를 호출하"
"는 것은 함수를 호출하는 것과 똑같습니다. 하지만 입력 및 반환 타입은 추론될 "
"수 있으며, 입력 변수 이름은 반드시 지정되어야 합니다."

#: src/fn/closures.md:15
msgid "Other characteristics of closures include:"
msgstr "클로저의 다른 특징들은 다음과 같습니다:"

#: src/fn/closures.md:17
msgid "using `||` instead of `()` around input variables."
msgstr "입력 변수 주위에 `()` 대신 `||`를 사용합니다."

#: src/fn/closures.md:18
msgid ""
"optional body delimitation (`{}`) for a single line expression (mandatory "
"otherwise)."
msgstr ""
"한 줄 표현식의 경우 본문 구분 기호(`{}`)는 선택 사항입니다 (그 외의 경우는 필"
"수)."

#: src/fn/closures.md:19
msgid "the ability to capture the outer environment variables."
msgstr "외부 환경 변수를 캡처하는 능력."

#: src/fn/closures.md:25
msgid ""
"// A regular function can't refer to variables in the enclosing environment\n"
"    //fn function(i: i32) -> i32 { i + outer_var }\n"
"    // TODO: uncomment the line above and see the compiler error. The "
"compiler\n"
"    // suggests that we define a closure instead.\n"
msgstr ""
"// 일반 함수는 자신을 감싸고 있는 환경의 변수를 참조할 수 없습니다\n"
"// fn function(i: i32) -> i32 { i + outer_var }\n"
"// TODO: 위의 줄의 주석을 해제하고 컴파일 에러를 확인해 보세요. 컴파일러는\n"
"// 대신 클로저를 정의할 것을 제안합니다.\n"

#: src/fn/closures.md:30
msgid ""
"// Closures are anonymous, here we are binding them to references.\n"
"    // Annotation is identical to function annotation but is optional\n"
"    // as are the `{}` wrapping the body. These nameless functions\n"
"    // are assigned to appropriately named variables.\n"
msgstr ""
"// 클로저는 익명이며, 여기서는 참조에 바인딩하고 있습니다.\n"
"// 어노테이션은 함수의 어노테이션과 동일하지만 선택 사항이며,\n"
"// 본문을 감싸는 `{}` 역시 선택 사항입니다. 이 이름 없는 함수들은\n"
"// 적절하게 이름 붙여진 변수들에 할당됩니다.\n"

#: src/fn/closures.md:37
msgid "// Call the closures.\n"
msgstr "// 클로저를 호출합니다.\n"

#: src/fn/closures.md:38
msgid "\"closure_annotated: {}\""
msgstr "\"어노테이션된 클로저: {}\""

#: src/fn/closures.md:39
msgid "\"closure_inferred: {}\""
msgstr "\"추론된 클로저: {}\""

#: src/fn/closures.md:40
msgid ""
"// Once closure's type has been inferred, it cannot be inferred again with "
"another type.\n"
"    //println!(\"cannot reuse closure_inferred with another type: {}\", "
"closure_inferred(42i64));\n"
"    // TODO: uncomment the line above and see the compiler error.\n"
msgstr ""
"// 클로저의 타입이 한 번 추론되면, 다른 타입으로 다시 추론될 수 없습니다.\n"
"// println!(\"다른 타입으로 closure_inferred를 재사용할 수 없습니다: {}\", "
"closure_inferred(42i64));\n"
"// TODO: 위의 줄의 주석을 해제하고 컴파일 에러를 확인해 보세요.\n"

#: src/fn/closures.md:44
msgid ""
"// A closure taking no arguments which returns an `i32`.\n"
"    // The return type is inferred.\n"
msgstr ""
"// 인자를 받지 않고 `i32`를 반환하는 클로저입니다.\n"
"// 반환 타입은 추론됩니다.\n"

#: src/fn/closures.md:47
msgid "\"closure returning one: {}\""
msgstr "\"1을 반환하는 클로저: {}\""

#: src/fn/closures/capture.md:3
msgid ""
"Closures are inherently flexible and will do what the functionality requires "
"to make the closure work without annotation. This allows capturing to "
"flexibly adapt to the use case, sometimes moving and sometimes borrowing. "
"Closures can capture variables:"
msgstr ""
"클로저는 본질적으로 유연하며, 어노테이션 없이도 클로저가 작동하는 데 필요한 "
"기능을 수행합니다. 이를 통해 캡처 방식이 사용 사례에 따라 유연하게 적응할 수 "
"있으며, 때로는 이동(move)하고 때로는 빌림(borrow)을 수행합니다. 클로저는 다음"
"과 같은 방식으로 변수를 캡처할 수 있습니다:"

#: src/fn/closures/capture.md:8
msgid "by reference: `&T`"
msgstr "참조에 의한 방식: `&T`"

#: src/fn/closures/capture.md:9
msgid "by mutable reference: `&mut T`"
msgstr "가변 참조에 의한 방식: `&mut T`"

#: src/fn/closures/capture.md:10
msgid "by value: `T`"
msgstr "값에 의한 방식: `T`"

#: src/fn/closures/capture.md:12
msgid ""
"They preferentially capture variables by reference and only go lower when "
"required."
msgstr ""
"클로저는 가급적 참조로 변수를 캡처하며, 필요한 경우에만 더 낮은 수준(이동 등)"
"으로 내려갑니다."

#: src/fn/closures/capture.md:19
msgid "\"green\""
msgstr "\"초록\""

#: src/fn/closures/capture.md:21
msgid ""
"// A closure to print `color` which immediately borrows (`&`) `color` and\n"
"    // stores the borrow and closure in the `print` variable. It will "
"remain\n"
"    // borrowed until `print` is used the last time.\n"
"    //\n"
"    // `println!` only requires arguments by immutable reference so it "
"doesn't\n"
"    // impose anything more restrictive.\n"
msgstr ""
"// `color`를 출력하는 클로저입니다. 이 클로저는 즉시 `color`를 빌리고(`&`)\n"
"// 그 빌림과 클로저를 `print` 변수에 저장합니다. `print`가 마지막으로\n"
"// 사용될 때까지 빌린 상태가 유지됩니다.\n"
"//\n"
"// `println!`은 인자로 불변 참조만 요구하므로 더 이상의 제약을\n"
"// 가하지 않습니다.\n"

#: src/fn/closures/capture.md:27
msgid "\"`color`: {}\""
msgstr "\"`color`: {}\""

#: src/fn/closures/capture.md:29
msgid "// Call the closure using the borrow.\n"
msgstr "// 빌림을 사용하여 클로저를 호출합니다.\n"

#: src/fn/closures/capture.md:32
msgid ""
"// `color` can be borrowed immutably again, because the closure only holds\n"
"    // an immutable reference to `color`.\n"
msgstr ""
"// 클로저가 `color`에 대한 불변 참조만 가지고 있기 때문에,\n"
"// `color`를 다시 불변으로 빌릴 수 있습니다.\n"

#: src/fn/closures/capture.md:37
msgid "// A move or reborrow is allowed after the final use of `print`\n"
msgstr ""
"// `print`를 마지막으로 사용한 후에는 이동(move)이나 다시 빌리는 것이 허용됩"
"니다\n"

#: src/fn/closures/capture.md:42
msgid ""
"// A closure to increment `count` could take either `&mut count` or `count`\n"
"    // but `&mut count` is less restrictive so it takes that. Immediately\n"
"    // borrows `count`.\n"
"    //\n"
"    // A `mut` is required on `inc` because a `&mut` is stored inside. "
"Thus,\n"
"    // calling the closure mutates `count` which requires a `mut`.\n"
msgstr ""
"// `count`를 증가시키는 클로저는 `&mut count`나 `count` 중 하나를 취할 수 있"
"지만,\n"
"// `&mut count`가 덜 제한적이므로 이를 취합니다. 즉시 `count`를 빌립니다.\n"
"//\n"
"// 내부에 `&mut`가 저장되어 있기 때문에 `inc`에 `mut`가 필요합니다. 따라서\n"
"// 클로저를 호출하면 `count`가 수정되며, 이를 위해 `mut`가 필요합니다.\n"

#: src/fn/closures/capture.md:50
msgid "\"`count`: {}\""
msgstr "\"`count`: {}\""

#: src/fn/closures/capture.md:53
msgid "// Call the closure using a mutable borrow.\n"
msgstr "// 가변 빌림을 사용하여 클로저를 호출합니다.\n"

#: src/fn/closures/capture.md:56
msgid ""
"// The closure still mutably borrows `count` because it is called later.\n"
"    // An attempt to reborrow will lead to an error.\n"
"    // let _reborrow = &count;\n"
"    // ^ TODO: try uncommenting this line.\n"
msgstr ""
"// 클로저가 나중에 호출되기 때문에 여전히 `count`를 가변적으로 빌리고 있습니"
"다.\n"
"// 다시 빌리려는 시도는 에러를 발생시킵니다.\n"
"// let _reborrow = &count;\n"
"// ^ TODO: 이 줄의 주석을 해제해 보세요.\n"

#: src/fn/closures/capture.md:62
msgid ""
"// The closure no longer needs to borrow `&mut count`. Therefore, it is\n"
"    // possible to reborrow without an error\n"
msgstr ""
"// 클로저가 더 이상 `&mut count`를 빌릴 필요가 없습니다. 따라서\n"
"// 에러 없이 다시 빌리는 것이 가능합니다.\n"

#: src/fn/closures/capture.md:67
msgid "// A non-copy type.\n"
msgstr "// 복사(copy)되지 않는 타입.\n"

#: src/fn/closures/capture.md:70
msgid ""
"// `mem::drop` requires `T` so this must take by value. A copy type\n"
"    // would copy into the closure leaving the original untouched.\n"
"    // A non-copy must move and so `movable` immediately moves into\n"
"    // the closure.\n"
msgstr ""
"// `mem::drop`은 `T`를 요구하므로 값을 가져와야 합니다. 복사 타입은\n"
"// 원본을 그대로 둔 채 클로저 내부로 복사될 것입니다.\n"
"// 복사되지 않는 타입은 이동(move)해야 하므로 `movable`은 즉시\n"
"// 클로저 내부로 이동됩니다.\n"

#: src/fn/closures/capture.md:75
msgid "\"`movable`: {:?}\""
msgstr "\"`movable`: {:?}\""

#: src/fn/closures/capture.md:79
msgid "// `consume` consumes the variable so this can only be called once.\n"
msgstr "// `consume`은 변수를 소비하므로 한 번만 호출될 수 있습니다.\n"

#: src/fn/closures/capture.md:81
msgid ""
"// consume();\n"
"    // ^ TODO: Try uncommenting this line.\n"
msgstr ""
"// consume();\n"
"// ^ TODO: 이 줄의 주석을 해제해 보세요.\n"

#: src/fn/closures/capture.md:86
msgid ""
"Using `move` before vertical pipes forces closure to take ownership of "
"captured variables:"
msgstr ""
"수직 바(`||`) 앞에 `move`를 사용하면 클로저가 캡처된 변수의 소유권을 강제로 "
"갖게 됩니다:"

#: src/fn/closures/capture.md:91
msgid "// `Vec` has non-copy semantics.\n"
msgstr "// `Vec`은 복사되지 않는 세맨틱을 가집니다.\n"

#: src/fn/closures/capture.md:99
msgid ""
"// println!(\"There're {} elements in vec\", haystack.len());\n"
"    // ^ Uncommenting above line will result in compile-time error\n"
"    // because borrow checker doesn't allow re-using variable after it\n"
"    // has been moved.\n"
msgstr ""
"// println!(\"vec에는 {}개의 요소가 있습니다\", haystack.len());\n"
"// ^ 위의 줄의 주석을 해제하면 컴파일 타임 에러가 발생합니다.\n"
"// 빌림 검사기(borrow checker)가 이동된 후의 변수 재사용을 허용하지 않기 때문"
"입니다.\n"

#: src/fn/closures/capture.md:104
msgid ""
"// Removing `move` from closure's signature will cause closure\n"
"    // to borrow _haystack_ variable immutably, hence _haystack_ is still\n"
"    // available and uncommenting above line will not cause an error.\n"
msgstr ""
"// 클로저의 시그니처에서 `move`를 제거하면 클로저가 `haystack` 변수를\n"
"// 불변으로 빌리게 되므로, `haystack`을 여전히 사용할 수 있고\n"
"// 위의 줄의 주석을 해제해도 에러가 발생하지 않습니다.\n"

#: src/fn/closures/capture.md:112
msgid ""
"[`Box`](../../std/box.md) and [`std::mem::drop`](https://doc.rust-lang.org/"
"std/mem/fn.drop.html)"
msgstr ""
"[`Box`](../../std/box.md)와 [`std::mem::drop`](https://doc.rust-lang.org/std/"
"mem/fn.drop.html)"

#: src/fn/closures/input_parameters.md:3
msgid ""
"While Rust chooses how to capture variables on the fly mostly without type "
"annotation, this ambiguity is not allowed when writing functions. When "
"taking a closure as an input parameter, the closure's complete type must be "
"annotated using one of a few `traits`, and they're determined by what the "
"closure does with captured value. In order of decreasing restriction, they "
"are:"
msgstr ""
"Rust는 대부분 타입 어노테이션 없이 즉석에서 변수를 캡처하는 방식을 선택하지"
"만, 함수를 작성할 때는 이러한 모호함이 허용되지 않습니다. 클로저를 입력 파라"
"미터로 받을 때, 클로저의 전체 타입은 몇 가지 `트레이트` 중 하나를 사용하여 어"
"노테이션되어야 하며, 이는 클로저가 캡처된 값으로 무엇을 하는지에 따라 결정됩"
"니다. 제약이 강한 순서대로 나열하면 다음과 같습니다:"

#: src/fn/closures/input_parameters.md:10
msgid "`Fn`: the closure uses the captured value by reference (`&T`)"
msgstr "`Fn`: 클로저가 캡처된 값을 참조(`&T`)로 사용합니다"

#: src/fn/closures/input_parameters.md:11
msgid ""
"`FnMut`: the closure uses the captured value by mutable reference (`&mut T`)"
msgstr "`FnMut`: 클로저가 캡처된 값을 가변 참조(`&mut T`)로 사용합니다"

#: src/fn/closures/input_parameters.md:12
msgid "`FnOnce`: the closure uses the captured value by value (`T`)"
msgstr "`FnOnce`: 클로저가 캡처된 값을 값(`T`)으로 사용합니다"

#: src/fn/closures/input_parameters.md:14
msgid ""
"On a variable-by-variable basis, the compiler will capture variables in the "
"least restrictive manner possible."
msgstr ""
"변수별로 컴파일러는 가능한 가장 제약이 적은 방식으로 변수를 캡처합니다."

#: src/fn/closures/input_parameters.md:17
msgid ""
"For instance, consider a parameter annotated as `FnOnce`. This specifies "
"that the closure _may_ capture by `&T`, `&mut T`, or `T`, but the compiler "
"will ultimately choose based on how the captured variables are used in the "
"closure."
msgstr ""
"예를 들어, `FnOnce`로 어노테이션된 파라미터를 생각해 보세요. 이는 클로저가 "
"`&T`, `&mut T`, 또는 `T`로 캡처할 수 있음을 나타내지만, 컴파일러는 최종적으"
"로 클로저 내에서 캡처된 변수가 어떻게 사용되는지에 따라 선택합니다."

#: src/fn/closures/input_parameters.md:22
msgid ""
"This is because if a move is possible, then any type of borrow should also "
"be possible. Note that the reverse is not true. If the parameter is "
"annotated as `Fn`, then capturing variables by `&mut T` or `T` are not "
"allowed. However, `&T` is allowed."
msgstr ""
"이동(move)이 가능하다면 어떤 유형의 빌림(borrow)도 가능해야 하기 때문입니다. "
"그 반대는 성립하지 않음에 유의하세요. 파라미터가 `Fn`으로 어노테이션된 경우, "
"`&mut T`나 `T`로 변수를 캡처하는 것은 허용되지 않습니다. 하지만 `&T`는 허용됩"
"니다."

#: src/fn/closures/input_parameters.md:27
msgid ""
"In the following example, try swapping the usage of `Fn`, `FnMut`, and "
"`FnOnce` to see what happens:"
msgstr ""
"다음 예제에서 `Fn`, `FnMut`, `FnOnce`의 사용을 서로 바꿔보며 어떤 일이 일어나"
"는지 확인해 보세요:"

#: src/fn/closures/input_parameters.md:31
msgid ""
"// A function which takes a closure as an argument and calls it.\n"
"// <F> denotes that F is a \"Generic type parameter\"\n"
msgstr ""
"// 클로저를 인자로 받아 호출하는 함수입니다.\n"
"// <F>는 F가 \"제네릭 타입 파라미터\"임을 나타냅니다.\n"

#: src/fn/closures/input_parameters.md:34
msgid "// The closure takes no input and returns nothing.\n"
msgstr "// 이 클로저는 입력을 받지 않고 아무것도 반환하지 않습니다.\n"

#: src/fn/closures/input_parameters.md:36
msgid "// ^ TODO: Try changing this to `Fn` or `FnMut`.\n"
msgstr "// ^ TODO: 이를 `Fn`이나 `FnMut`로 변경해 보세요.\n"

#: src/fn/closures/input_parameters.md:40
msgid "// A function which takes a closure and returns an `i32`.\n"
msgstr "// 클로저를 받아 `i32`를 반환하는 함수입니다.\n"

#: src/fn/closures/input_parameters.md:43
msgid "// The closure takes an `i32` and returns an `i32`.\n"
msgstr "// 이 클로저는 `i32`를 받아 `i32`를 반환합니다.\n"

#: src/fn/closures/input_parameters.md:53
msgid ""
"// A non-copy type.\n"
"    // `to_owned` creates owned data from borrowed one\n"
msgstr ""
"// 복사되지 않는 타입.\n"
"// `to_owned`는 빌려온 데이터로부터 소유권이 있는 데이터를 생성합니다.\n"

#: src/fn/closures/input_parameters.md:55
msgid "\"goodbye\""
msgstr "\"잘 가요\""

#: src/fn/closures/input_parameters.md:57
msgid ""
"// Capture 2 variables: `greeting` by reference and\n"
"    // `farewell` by value.\n"
msgstr ""
"// 두 개의 변수를 캡처합니다: `greeting`은 참조로, `farewell`은 값으로.\n"

#: src/fn/closures/input_parameters.md:60
msgid "// `greeting` is by reference: requires `Fn`.\n"
msgstr "// `greeting`은 참조에 의한 방식입니다: `Fn`이 필요합니다.\n"

#: src/fn/closures/input_parameters.md:61
msgid "\"I said {}.\""
msgstr "\"저는 {}라고 말했습니다.\""

#: src/fn/closures/input_parameters.md:63
msgid ""
"// Mutation forces `farewell` to be captured by\n"
"        // mutable reference. Now requires `FnMut`.\n"
msgstr ""
"// 수정을 위해 `farewell`을 가변 참조로 캡처해야 합니다.\n"
"// 이제 `FnMut`가 필요합니다.\n"

#: src/fn/closures/input_parameters.md:65
msgid "\"!!!\""
msgstr "\"!!!\""

#: src/fn/closures/input_parameters.md:66
msgid "\"Then I screamed {}.\""
msgstr "\"그러고 나서 저는 {}라고 소리쳤습니다.\""

#: src/fn/closures/input_parameters.md:67
msgid "\"Now I can sleep. zzzzz\""
msgstr "\"이제 잘 수 있겠네요. zzzzz\""

#: src/fn/closures/input_parameters.md:69
msgid ""
"// Manually calling drop forces `farewell` to\n"
"        // be captured by value. Now requires `FnOnce`.\n"
msgstr ""
"// 수동으로 drop을 호출하면 `farewell`을 값으로\n"
"// 캡처해야 합니다. 이제 `FnOnce`가 필요합니다.\n"

#: src/fn/closures/input_parameters.md:74
msgid "// Call the function which applies the closure.\n"
msgstr "// 클로저를 적용하는 함수를 호출합니다.\n"

#: src/fn/closures/input_parameters.md:77
msgid "// `double` satisfies `apply_to_3`'s trait bound\n"
msgstr "// `double`은 `apply_to_3`의 트레이트 바운드를 만족합니다\n"

#: src/fn/closures/input_parameters.md:80
msgid "\"3 doubled: {}\""
msgstr "\"3의 두 배: {}\""

#: src/fn/closures/input_parameters.md:86
msgid ""
"[`std::mem::drop`](https://doc.rust-lang.org/std/mem/fn.drop.html), [`Fn`]"
"(https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://"
"doc.rust-lang.org/std/ops/trait.FnMut.html), [Generics](../../generics.md), "
"[where](../../generics/where.md) and [`FnOnce`](https://doc.rust-lang.org/"
"std/ops/trait.FnOnce.html)"
msgstr ""
"[`std::mem::drop`](https://doc.rust-lang.org/std/mem/fn.drop.html), [`Fn`]"
"(https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://"
"doc.rust-lang.org/std/ops/trait.FnMut.html), [제네릭](../../generics.md), "
"[where](../../generics/where.md) 및 [`FnOnce`](https://doc.rust-lang.org/std/"
"ops/trait.FnOnce.html)"

#: src/fn/closures/anonymity.md:3
msgid ""
"Closures succinctly capture variables from enclosing scopes. Does this have "
"any consequences? It surely does. Observe how using a closure as a function "
"parameter requires [generics](../../generics.md), which is necessary because "
"of how they are defined:"
msgstr ""
"클로저는 자신을 감싸고 있는 스코프에서 변수를 간결하게 캡처합니다. 이것이 어"
"떤 결과를 초래할까요? 분명히 결과가 있습니다. 클로저를 함수 파라미터로 사용"
"할 때 [제네릭](../../generics.md)이 왜 필요한지, 클로저가 어떻게 정의되는지"
"를 통해 살펴보세요:"

#: src/fn/closures/anonymity.md:9
msgid "// `F` must be generic.\n"
msgstr "// `F`는 제네릭이어야 합니다.\n"

#: src/fn/closures/anonymity.md:16
msgid ""
"When a closure is defined, the compiler implicitly creates a new anonymous "
"structure to store the captured variables inside, meanwhile implementing the "
"functionality via one of the `traits`: `Fn`, `FnMut`, or `FnOnce` for this "
"unknown type. This type is assigned to the variable which is stored until "
"calling."
msgstr ""
"클로저가 정의될 때, 컴파일러는 내부에 캡처된 변수를 저장하기 위해 새로운 익"
"명 구조체를 암시적으로 생성하며, 동시에 이 알 수 없는 타입에 대해 `Fn`, "
"`FnMut`, 또는 `FnOnce` 트레이트 중 하나를 통해 기능을 구현합니다. 이 타입은 "
"변수에 할당되어 호출될 때까지 저장됩니다."

#: src/fn/closures/anonymity.md:22
msgid ""
"Since this new type is of unknown type, any usage in a function will require "
"generics. However, an unbounded type parameter `<T>` would still be "
"ambiguous and not be allowed. Thus, bounding by one of the `traits`: `Fn`, "
"`FnMut`, or `FnOnce` (which it implements) is sufficient to specify its type."
msgstr ""
"이 새로운 타입은 알 수 없는 타입이므로, 함수에서 사용할 때는 제네릭이 필요합"
"니다. 하지만 제약이 없는 타입 파라미터 `<T>`는 여전히 모호하므로 허용되지 않"
"습니다. 따라서 클로저가 구현하는 `Fn`, `FnMut`, 또는 `FnOnce` 트레이트 중 하"
"나로 바운딩하는 것이 그 타입을 지정하기에 충분합니다."

#: src/fn/closures/anonymity.md:28
msgid ""
"// `F` must implement `Fn` for a closure which takes no\n"
"// inputs and returns nothing - exactly what is required\n"
"// for `print`.\n"
msgstr ""
"// `F`는 입력이 없고 아무것도 반환하지 않는 클로저를 위해\n"
"// `Fn`을 구현해야 합니다. 이는 정확히 `print`에 요구되는 사항입니다.\n"

#: src/fn/closures/anonymity.md:39
msgid ""
"// Capture `x` into an anonymous type and implement\n"
"    // `Fn` for it. Store it in `print`.\n"
msgstr ""
"// `x`를 익명 타입으로 캡처하고 그에 대해 `Fn`을 구현합니다.\n"
"// 이를 `print`에 저장합니다.\n"

#: src/fn/closures/anonymity.md:49
msgid ""
"[A thorough analysis](https://huonw.github.io/blog/2015/05/finding-closure-"
"in-rust/), [`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`]"
"(https://doc.rust-lang.org/std/ops/trait.FnMut.html), and [`FnOnce`](https://"
"doc.rust-lang.org/std/ops/trait.FnOnce.html)"
msgstr ""
"[철저한 분석](https://huonw.github.io/blog/2015/05/finding-closure-in-"
"rust/), [`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/fn/closures/input_functions.md:3
msgid ""
"Since closures may be used as arguments, you might wonder if the same can be "
"said about functions. And indeed they can! If you declare a function that "
"takes a closure as parameter, then any function that satisfies the trait "
"bound of that closure can be passed as a parameter."
msgstr ""
"클로저가 인자로 사용될 수 있으므로, 함수에 대해서도 똑같이 말할 수 있는지 궁"
"금할 것입니다. 실제로 가능합니다! 클로저를 파라미터로 받는 함수를 선언하면, "
"해당 클로저의 트레이트 바운드를 만족하는 모든 함수를 파라미터로 전달할 수 있"
"습니다."

#: src/fn/closures/input_functions.md:9
msgid ""
"// Define a function which takes a generic `F` argument\n"
"// bounded by `Fn`, and calls it\n"
msgstr ""
"// `Fn`으로 바운딩된 제네릭 `F` 인자를 받아\n"
"// 호출하는 함수를 정의합니다\n"

#: src/fn/closures/input_functions.md:14
msgid "// Define a wrapper function satisfying the `Fn` bound\n"
msgstr "// `Fn` 바운드를 만족하는 래퍼 함수를 정의합니다\n"

#: src/fn/closures/input_functions.md:17
msgid "\"I'm a function!\""
msgstr "\"저는 함수입니다!\""

#: src/fn/closures/input_functions.md:21
msgid "// Define a closure satisfying the `Fn` bound\n"
msgstr "// `Fn` 바운드를 만족하는 클로저를 정의합니다\n"

#: src/fn/closures/input_functions.md:22
msgid "\"I'm a closure!\""
msgstr "\"저는 클로저입니다!\""

#: src/fn/closures/input_functions.md:29
msgid ""
"As an additional note, the `Fn`, `FnMut`, and `FnOnce` `traits` dictate how "
"a closure captures variables from the enclosing scope."
msgstr ""
"추가로, `Fn`, `FnMut`, `FnOnce` 트레이트는 클로저가 주변 스코프에서 변수를 캡"
"처하는 방식을 결정합니다."

#: src/fn/closures/input_functions.md:34
msgid ""
"[`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://"
"doc.rust-lang.org/std/ops/trait.FnMut.html), and [`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/fn/closures/output_parameters.md:3
msgid ""
"Closures as input parameters are possible, so returning closures as output "
"parameters should also be possible. However, anonymous closure types are, by "
"definition, unknown, so we have to use `impl Trait` to return them."
msgstr ""
"클로저를 입력 파라미터로 사용하는 것이 가능하므로, 클로저를 출력 파라미터로 "
"반환하는 것도 가능해야 합니다. 하지만 익명 클로저 타입은 정의상 알 수 없으므"
"로, 이를 반환하려면 `impl Trait`를 사용해야 합니다."

#: src/fn/closures/output_parameters.md:8
msgid "The valid traits for returning a closure are:"
msgstr "클로저를 반환하기 위해 유효한 트레이트들은 다음과 같습니다:"

#: src/fn/closures/output_parameters.md:10
msgid "`Fn`"
msgstr "`Fn`"

#: src/fn/closures/output_parameters.md:11
msgid "`FnMut`"
msgstr "`FnMut`"

#: src/fn/closures/output_parameters.md:12
msgid "`FnOnce`"
msgstr "`FnOnce`"

#: src/fn/closures/output_parameters.md:14
msgid ""
"Beyond this, the `move` keyword must be used, which signals that all "
"captures occur by value. This is required because any captures by reference "
"would be dropped as soon as the function exited, leaving invalid references "
"in the closure."
msgstr ""
"이 외에도, 모든 캡처가 값에 의해 발생함을 나타내는 `move` 키워드를 반드시 사"
"용해야 합니다. 이는 참조에 의한 캡처가 함수가 종료되는 즉시 드롭되어 클로저"
"에 유효하지 않은 참조를 남기기 때문에 필요합니다."

#: src/fn/closures/output_parameters.md:21
msgid "\"Fn\""
msgstr "\"Fn\""

#: src/fn/closures/output_parameters.md:23
#: src/fn/closures/output_parameters.md:29
#: src/fn/closures/output_parameters.md:35
msgid "\"This is a: {}\""
msgstr "\"이것은 {}입니다\""

#: src/fn/closures/output_parameters.md:27
msgid "\"FnMut\""
msgstr "\"FnMut\""

#: src/fn/closures/output_parameters.md:33
msgid "\"FnOnce\""
msgstr "\"FnOnce\""

#: src/fn/closures/output_parameters.md:51
msgid ""
"[`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://"
"doc.rust-lang.org/std/ops/trait.FnMut.html), [Generics](../../generics.md) "
"and [impl Trait](../../trait/impl_trait.md)."
msgstr ""
"[`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html), [`FnMut`](https://"
"doc.rust-lang.org/std/ops/trait.FnMut.html), [제네릭](../../generics.md) 및 "
"[impl Trait](../../trait/impl_trait.md)."

#: src/fn/closures/closure_examples.md:3
msgid ""
"This section contains a few examples of using closures from the `std` "
"library."
msgstr ""
"이 섹션에는 `std` 라이브러리의 클로저를 사용하는 몇 가지 예제가 포함되어 있습"
"니다."

#: src/fn/closures/closure_examples/iter_any.md:3
msgid ""
"`Iterator::any` is a function which when passed an iterator, will return "
"`true` if any element satisfies the predicate. Otherwise `false`. Its "
"signature:"
msgstr ""
"`Iterator::any`는 이터레이터가 주어졌을 때, 어떤 요소라도 서술어(predicate)"
"를 만족하면 `true`를 반환하는 함수입니다. 그렇지 않으면 `false`를 반환합니"
"다. 시그니처는 다음과 같습니다:"

#: src/fn/closures/closure_examples/iter_any.md:9
#: src/fn/closures/closure_examples/iter_find.md:9
msgid "// The type being iterated over.\n"
msgstr "// 반복되는 요소의 타입.\n"

#: src/fn/closures/closure_examples/iter_any.md:12
msgid ""
"// `any` takes `&mut self` meaning the caller may be borrowed\n"
"    // and modified, but not consumed.\n"
msgstr ""
"// `any`는 `&mut self`를 취하므로 호출자는 빌려지거나\n"
"// 수정될 수 있지만, 소비(consume)되지는 않습니다.\n"

#: src/fn/closures/closure_examples/iter_any.md:15
msgid ""
"// `FnMut` meaning any captured variable may at most be\n"
"        // modified, not consumed. `Self::Item` is the closure parameter "
"type,\n"
"        // which is determined by the iterator (e.g., `&T` for `.iter()`,\n"
"        // `T` for `.into_iter()`).\n"
msgstr ""
"// `FnMut`는 캡처된 변수가 최대 수정될 수 있지만 소비되지는 않음을 의미합니"
"다.\n"
"// `Self::Item`은 클로저 파라미터 타입으로, 이터레이터에 의해 결정됩니다\n"
"// (예: `.iter()`의 경우 `&T`, `.into_iter()`의 경우 `T`).\n"

#: src/fn/closures/closure_examples/iter_any.md:28
msgid "// `iter()` for vecs yields `&i32`. Destructure to `i32`.\n"
msgstr ""
"// 벡터에 대한 `iter()`는 `&i32`를 생성합니다. `i32`로 구조 분해합니다.\n"

#: src/fn/closures/closure_examples/iter_any.md:29
msgid "\"2 in vec1: {}\""
msgstr "\"vec1에 2가 있음: {}\""

#: src/fn/closures/closure_examples/iter_any.md:30
msgid "// `into_iter()` for vecs yields `i32`. No destructuring required.\n"
msgstr ""
"// 벡터에 대한 `into_iter()`는 `i32`를 생성합니다. 구조 분해가 필요 없습니"
"다.\n"

#: src/fn/closures/closure_examples/iter_any.md:31
msgid "\"2 in vec2: {}\""
msgstr "\"vec2에 2가 있음: {}\""

#: src/fn/closures/closure_examples/iter_any.md:33
msgid ""
"// `iter()` only borrows `vec1` and its elements, so they can be used again\n"
msgstr ""
"// `iter()`는 오직 `vec1`과 그 요소들을 빌리기만 하므로, 다시 사용할 수 있습"
"니다.\n"

#: src/fn/closures/closure_examples/iter_any.md:34
msgid "\"vec1 len: {}\""
msgstr "\"vec1 길이: {}\""

#: src/fn/closures/closure_examples/iter_any.md:35
msgid "\"First element of vec1 is: {}\""
msgstr "\"vec1의 첫 번째 요소: {}\""

#: src/fn/closures/closure_examples/iter_any.md:36
msgid ""
"// `into_iter()` does move `vec2` and its elements, so they cannot be used "
"again\n"
"    // println!(\"First element of vec2 is: {}\", vec2[0]);\n"
"    // println!(\"vec2 len: {}\", vec2.len());\n"
"    // TODO: uncomment two lines above and see compiler errors.\n"
msgstr ""
"// `into_iter()`는 `vec2`와 그 요소들을 이동(move)시키므로, 다시 사용할 수 없"
"습니다.\n"
"// println!(\"vec2의 첫 번째 요소: {}\", vec2[0]);\n"
"// println!(\"vec2 길이: {}\", vec2.len());\n"
"// TODO: 위의 두 줄의 주석을 해제하고 컴파일 에러를 확인해 보세요.\n"

#: src/fn/closures/closure_examples/iter_any.md:44
msgid "// `iter()` for arrays yields `&i32`.\n"
msgstr "// 배열에 대한 `iter()`는 `&i32`를 생성합니다.\n"

#: src/fn/closures/closure_examples/iter_any.md:45
msgid "\"2 in array1: {}\""
msgstr "\"array1에 2가 있음: {}\""

#: src/fn/closures/closure_examples/iter_any.md:46
msgid "// `into_iter()` for arrays yields `i32`.\n"
msgstr "// 배열에 대한 `into_iter()`는 `i32`를 생성합니다.\n"

#: src/fn/closures/closure_examples/iter_any.md:47
msgid "\"2 in array2: {}\""
msgstr "\"array2에 2가 있음: {}\""

#: src/fn/closures/closure_examples/iter_any.md:53
msgid ""
"[`std::iter::Iterator::any`](https://doc.rust-lang.org/std/iter/"
"trait.Iterator.html#method.any)"
msgstr ""
"[`std::iter::Iterator::any`](https://doc.rust-lang.org/std/iter/"
"trait.Iterator.html#method.any)"

#: src/fn/closures/closure_examples/iter_find.md:3
msgid ""
"`Iterator::find` is a function which iterates over an iterator and searches "
"for the first value which satisfies some condition. If none of the values "
"satisfy the condition, it returns `None`. Its signature:"
msgstr ""
"`Iterator::find`는 이터레이터를 순회하며 어떤 조건을 만족하는 첫 번째 값을 찾"
"는 함수입니다. 조건을 만족하는 값이 없으면 `None`을 반환합니다. 시그니처는 다"
"음과 같습니다:"

#: src/fn/closures/closure_examples/iter_find.md:12
msgid ""
"// `find` takes `&mut self` meaning the caller may be borrowed\n"
"    // and modified, but not consumed.\n"
msgstr ""
"// `find`는 `&mut self`를 취하므로 호출자는 빌려지거나\n"
"// 수정될 수 있지만, 소비(consume)되지는 않습니다.\n"

#: src/fn/closures/closure_examples/iter_find.md:15
msgid ""
"// `FnMut` meaning any captured variable may at most be\n"
"        // modified, not consumed. `&Self::Item` states it takes\n"
"        // arguments to the closure by reference.\n"
msgstr ""
"// `FnMut`는 캡처된 변수가 최대 수정될 수 있지만 소비되지는 않음을 의미합니"
"다.\n"
"// `&Self::Item`은 클로저에 대한 인자를 참조로 취함을 나타냅니다.\n"

#: src/fn/closures/closure_examples/iter_find.md:27
msgid "// `vec1.iter()` yields `&i32`.\n"
msgstr "// `vec1.iter()`는 `&i32`를 생성합니다.\n"

#: src/fn/closures/closure_examples/iter_find.md:29
msgid "// `vec2.into_iter()` yields `i32`.\n"
msgstr "// `vec2.into_iter()`는 `i32`를 생성합니다.\n"

#: src/fn/closures/closure_examples/iter_find.md:32
msgid ""
"// `iter()` yields `&i32`, and `find` passes `&Item` to the predicate.\n"
"    // Since `Item = &i32`, the closure argument has type `&&i32`,\n"
"    // which we pattern-match to dereference down to `i32`.\n"
msgstr ""
"// `iter()`는 `&i32`를 생성하고, `find`는 서술어(predicate)에 `&Item`을 전달"
"합니다.\n"
"// `Item = &i32`이므로 클로저 인자는 `&&i32` 타입을 가지며,\n"
"// 우리는 이를 패턴 매칭하여 `i32`로 역참조합니다.\n"

#: src/fn/closures/closure_examples/iter_find.md:35
msgid "\"Find 2 in vec1: {:?}\""
msgstr "\"vec1에서 2 찾기: {:?}\""

#: src/fn/closures/closure_examples/iter_find.md:37
msgid ""
"// `into_iter()` yields `i32`, and `find` passes `&Item` to the predicate.\n"
"    // Since `Item = i32`, the closure argument has type `&i32`,\n"
"    // which we pattern-match to dereference down to `i32`.\n"
msgstr ""
"// `into_iter()`는 `i32`를 생성하고, `find`는 서술어에 `&Item`을 전달합니"
"다.\n"
"// `Item = i32`이므로 클로저 인자는 `&i32` 타입을 가지며,\n"
"// 우리는 이를 패턴 매칭하여 `i32`로 역참조합니다.\n"

#: src/fn/closures/closure_examples/iter_find.md:40
msgid "\"Find 2 in vec2: {:?}\""
msgstr "\"vec2에서 2 찾기: {:?}\""

#: src/fn/closures/closure_examples/iter_find.md:45
msgid "// `array1.iter()` yields `&i32`\n"
msgstr "// `array1.iter()`는 `&i32`를 생성합니다\n"

#: src/fn/closures/closure_examples/iter_find.md:46
msgid "\"Find 2 in array1: {:?}\""
msgstr "\"array1에서 2 찾기: {:?}\""

#: src/fn/closures/closure_examples/iter_find.md:47
msgid "// `array2.into_iter()` yields `i32`\n"
msgstr "// `array2.into_iter()`는 `i32`를 생성합니다\n"

#: src/fn/closures/closure_examples/iter_find.md:48
msgid "\"Find 2 in array2: {:?}\""
msgstr "\"array2에서 2 찾기: {:?}\""

#: src/fn/closures/closure_examples/iter_find.md:52
msgid ""
"`Iterator::find` gives you a reference to the item. But if you want the "
"_index_ of the item, use `Iterator::position`."
msgstr ""
"`Iterator::find`는 아이템에 대한 참조를 제공합니다. 하지만 아이템의 인덱스를 "
"원한다면 `Iterator::position`을 사용하세요."

#: src/fn/closures/closure_examples/iter_find.md:59
msgid ""
"// `position` passes the iterator’s `Item` by value to the predicate.\n"
"    // `vec.iter()` yields `&i32`, so the predicate receives `&i32`,\n"
"    // which we pattern-match to dereference to `i32`.\n"
msgstr ""
"// `position`은 이터레이터의 `Item`을 값으로 서술어에 전달합니다.\n"
"// `vec.iter()`는 `&i32`를 생성하므로 서술어는 `&i32`를 받으며,\n"
"// 우리는 이를 패턴 매칭하여 `i32`로 역참조합니다.\n"

#: src/fn/closures/closure_examples/iter_find.md:65
msgid ""
"// `vec.into_iter()` yields `i32`, so the predicate receives `i32` "
"directly.\n"
msgstr ""
"// `vec.into_iter()`는 `i32`를 생성하므로 서술어는 `i32`를 직접 받습니다.\n"

#: src/fn/closures/closure_examples/iter_find.md:73
msgid ""
"[`std::iter::Iterator::find`](https://doc.rust-lang.org/std/iter/"
"trait.Iterator.html#method.find)"
msgstr ""
"[`std::iter::Iterator::find`](https://doc.rust-lang.org/std/iter/"
"trait.Iterator.html#method.find)"

#: src/fn/closures/closure_examples/iter_find.md:75
msgid ""
"[`std::iter::Iterator::find_map`](https://doc.rust-lang.org/std/iter/"
"trait.Iterator.html#method.find_map)"
msgstr ""
"[`std::iter::Iterator::find_map`](https://doc.rust-lang.org/std/iter/"
"trait.Iterator.html#method.find_map)"

#: src/fn/closures/closure_examples/iter_find.md:77
msgid ""
"[`std::iter::Iterator::position`](https://doc.rust-lang.org/std/iter/"
"trait.Iterator.html#method.position)"
msgstr ""
"[`std::iter::Iterator::position`](https://doc.rust-lang.org/std/iter/"
"trait.Iterator.html#method.position)"

#: src/fn/closures/closure_examples/iter_find.md:79
msgid ""
"[`std::iter::Iterator::rposition`](https://doc.rust-lang.org/std/iter/"
"trait.Iterator.html#method.rposition)"
msgstr ""
"[`std::iter::Iterator::rposition`](https://doc.rust-lang.org/std/iter/"
"trait.Iterator.html#method.rposition)"

#: src/fn/hof.md:3
msgid ""
"Rust provides Higher Order Functions (HOF). These are functions that take "
"one or more functions and/or produce a more useful function. HOFs and lazy "
"iterators give Rust its functional flavor."
msgstr ""
"Rust는 고차 함수(Higher Order Functions, HOF)를 제공합니다. 이들은 하나 이상"
"의 함수를 인자로 받거나 더 유용한 함수를 만들어내는 함수들입니다. HOF와 게으"
"른(lazy) 이터레이터는 Rust에 함수형 프로그래밍의 풍미를 더해줍니다."

#: src/fn/hof.md:13
msgid "\"Find the sum of all the numbers with odd squares under 1000\""
msgstr "\"1000 미만의 홀수 제곱값들의 합 찾기\""

#: src/fn/hof.md:16
msgid ""
"// Imperative approach\n"
"    // Declare accumulator variable\n"
msgstr ""
"// 명령형 접근 방식\n"
"// 누적 변수 선언\n"

#: src/fn/hof.md:19
msgid "// Iterate: 0, 1, 2, ... to infinity\n"
msgstr "// 반복: 0, 1, 2, ... 무한대까지\n"

#: src/fn/hof.md:21
msgid "// Square the number\n"
msgstr "// 숫자를 제곱합니다\n"

#: src/fn/hof.md:25
msgid "// Break loop if exceeded the upper limit\n"
msgstr "// 상한을 초과하면 루프를 종료합니다\n"

#: src/fn/hof.md:28
msgid "// Accumulate value, if it's odd\n"
msgstr "// 홀수라면 값을 누적합니다\n"

#: src/fn/hof.md:32
msgid "\"imperative style: {}\""
msgstr "\"명령형 스타일: {}\""

#: src/fn/hof.md:34
msgid "// Functional approach\n"
msgstr "// 함수형 접근 방식\n"

#: src/fn/hof.md:36
msgid "// Below upper limit\n"
msgstr "// 상한 미만\n"

#: src/fn/hof.md:37
msgid "// That are odd\n"
msgstr "// 홀수인 것들\n"

#: src/fn/hof.md:38
msgid "// Sum them\n"
msgstr "// 합계를 구함\n"

#: src/fn/hof.md:39
msgid "\"functional style: {}\""
msgstr "\"함수형 스타일: {}\""

#: src/fn/hof.md:43
msgid ""
"[Option](https://doc.rust-lang.org/core/option/enum.Option.html) and "
"[Iterator](https://doc.rust-lang.org/core/iter/trait.Iterator.html) "
"implement their fair share of HOFs."
msgstr ""
"[Option](https://doc.rust-lang.org/core/option/enum.Option.html)과 [Iterator]"
"(https://doc.rust-lang.org/core/iter/trait.Iterator.html)는 상당수의 HOF를 구"
"현하고 있습니다."

#: src/fn/diverging.md:3
msgid ""
"Diverging functions never return. They are marked using `!`, which is an "
"empty type."
msgstr ""
"발산 함수(Diverging functions)는 절대 반환되지 않습니다. 이들은 빈 타입인 `!`"
"를 사용하여 표시됩니다."

#: src/fn/diverging.md:7 src/fn/diverging.md:35
msgid "\"This call never returns.\""
msgstr "\"이 호출은 절대 반환되지 않습니다.\""

#: src/fn/diverging.md:11
msgid ""
"As opposed to all the other types, this one cannot be instantiated, because "
"the set of all possible values this type can have is empty. Note that, it is "
"different from the `()` type, which has exactly one possible value."
msgstr ""
"다른 모든 타입들과 달리, 이 타입은 인스턴스화할 수 없습니다. 이 타입이 가질 "
"수 있는 모든 가능한 값의 집합이 비어 있기 때문입니다. 이는 정확히 하나의 가능"
"한 값을 갖는 `()` 타입과는 다르다는 점에 유의하세요."

#: src/fn/diverging.md:15
msgid ""
"For example, this function returns as usual, although there is no "
"information in the return value."
msgstr "예를 들어, 이 함수는 반환 값에 정보가 없더라도 평소와 같이 반환됩니다."

#: src/fn/diverging.md:25
msgid "\"This function returns and you can see this line.\""
msgstr "\"이 함수는 반환되며 당신은 이 줄을 볼 수 있습니다.\""

#: src/fn/diverging.md:29
msgid ""
"As opposed to this function, which will never return the control back to the "
"caller."
msgstr "반면 이 함수는 호출자에게 제어권을 절대 반환하지 않습니다."

#: src/fn/diverging.md:36
msgid "\"You will never see this line!\""
msgstr "\"당신은 결코 이 줄을 볼 수 없을 것입니다!\""

#: src/fn/diverging.md:40
msgid ""
"Although this might seem like an abstract concept, it is actually very "
"useful and often handy. The main advantage of this type is that it can be "
"cast to any other type, making it versatile in situations where an exact "
"type is required, such as in match branches. This flexibility allows us to "
"write code like this:"
msgstr ""
"이것이 추상적인 개념처럼 보일 수 있지만, 실제로는 매우 유용하며 종종 편리하"
"게 사용됩니다. 이 타입의 주요 장점은 다른 어떤 타입으로도 형변환될 수 있다는 "
"것이며, 이는 match 분기와 같이 정확한 타입이 요구되는 상황에서 다재다능하게 "
"만들어줍니다. 이러한 유연성 덕분에 다음과 같은 코드를 작성할 수 있습니다:"

#: src/fn/diverging.md:50
msgid ""
"// Notice that the return type of this match expression must be u32\n"
"            // because of the type of the \"addition\" variable.\n"
msgstr ""
"// 이 match 표현식의 반환 타입은 \"addition\" 변수의 타입 때문에\n"
"// 반드시 u32여야 함에 주목하세요.\n"

#: src/fn/diverging.md:53
msgid "// The \"i\" variable is of type u32, which is perfectly fine.\n"
msgstr "// \"i\" 변수는 u32 타입이며, 이는 완벽하게 괜찮습니다.\n"

#: src/fn/diverging.md:55
msgid ""
"// On the other hand, the \"continue\" expression does not return\n"
"                // u32, but it is still fine, because it never returns and "
"therefore\n"
"                // does not violate the type requirements of the match "
"expression.\n"
msgstr ""
"// 반면에 \"continue\" 표현식은 u32를 반환하지 않지만,\n"
"// 결코 반환되지 않으므로 match 표현식의 타입 요구 사항을\n"
"// 위반하지 않으며 여전히 괜찮습니다.\n"

#: src/fn/diverging.md:64
msgid "\"Sum of odd numbers up to 9 (excluding): {}\""
msgstr "\"9 미만의 홀수들의 합: {}\""

#: src/fn/diverging.md:68
msgid ""
"It is also the return type of functions that loop forever (e.g. `loop {}`) "
"like network servers or functions that terminate the process (e.g. `exit()`)."
msgstr ""
"또한 네트워크 서버처럼 영원히 루프를 도는 함수(예: `loop {}`)나 프로세스를 종"
"료하는 함수(예: `exit()`)의 반환 타입이기도 합니다."

#: src/mod.md:3
msgid ""
"Rust provides a powerful module system that can be used to hierarchically "
"split code in logical units (modules), and manage visibility (public/"
"private) between them."
msgstr ""
"Rust는 코드를 논리적 단위(모듈)로 계층적으로 나누고, 그들 사이의 가시성"
"(public/private)을 관리하는 데 사용할 수 있는 강력한 모듈 시스템을 제공합니"
"다."

#: src/mod.md:7
msgid ""
"A module is a collection of items: functions, structs, traits, `impl` "
"blocks, and even other modules."
msgstr ""
"모듈은 함수, 구조체, 트레이트, `impl` 블록, 그리고 다른 모듈까지 포함하는 아"
"이템들의 모음입니다."

#: src/mod/visibility.md:3
msgid ""
"By default, the items in a module have private visibility, but this can be "
"overridden with the `pub` modifier. Only the public items of a module can be "
"accessed from outside the module scope."
msgstr ""
"기본적으로 모듈 내의 아이템들은 비공개(private) 가시성을 가지지만, `pub` 수식"
"어를 사용하여 이를 재정의할 수 있습니다. 모듈 스코프 외부에서는 모듈의 공개"
"(public) 아이템만 접근할 수 있습니다."

#: src/mod/visibility.md:8
msgid "// A module named `my_mod`\n"
msgstr "// `my_mod`라는 이름의 모듈\n"

#: src/mod/visibility.md:10
msgid "// Items in modules default to private visibility.\n"
msgstr "// 모듈 내의 아이템들은 기본적으로 비공개 가시성을 가집니다.\n"

#: src/mod/visibility.md:12
msgid "\"called `my_mod::private_function()`\""
msgstr "\"`my_mod::private_function()` 호출됨\""

#: src/mod/visibility.md:15
msgid "// Use the `pub` modifier to override default visibility.\n"
msgstr "// 기본 가시성을 재정의하려면 `pub` 수식어를 사용하세요.\n"

#: src/mod/visibility.md:17
msgid "\"called `my_mod::function()`\""
msgstr "\"`my_mod::function()` 호출됨\""

#: src/mod/visibility.md:20
msgid ""
"// Items can access other items in the same module,\n"
"    // even when private.\n"
msgstr ""
"// 아이템들은 같은 모듈 내의 다른 아이템들에 접근할 수 있으며,\n"
"// 이는 비공개 아이템이라도 마찬가지입니다.\n"

#: src/mod/visibility.md:23
msgid "\"called `my_mod::indirect_access()`, that\\n> \""
msgstr "\"`my_mod::indirect_access()` 호출됨, 결과는\\n> \""

#: src/mod/visibility.md:27
msgid "// Modules can also be nested\n"
msgstr "// 모듈은 중첩될 수도 있습니다\n"

#: src/mod/visibility.md:30
msgid "\"called `my_mod::nested::function()`\""
msgstr "\"`my_mod::nested::function()` 호출됨\""

#: src/mod/visibility.md:35
msgid "\"called `my_mod::nested::private_function()`\""
msgstr "\"`my_mod::nested::private_function()` 호출됨\""

#: src/mod/visibility.md:38
msgid ""
"// Functions declared using `pub(in path)` syntax are only visible\n"
"        // within the given path. `path` must be a parent or ancestor "
"module\n"
msgstr ""
"// `pub(in path)` 구문을 사용하여 선언된 함수들은 오직 지정된\n"
"// 경로 내에서만 보입니다. `path`는 반드시 부모 또는 조상 모듈이어야 합니"
"다.\n"

#: src/mod/visibility.md:41
msgid "\"called `my_mod::nested::public_function_in_my_mod()`, that\\n> \""
msgstr "\"`my_mod::nested::public_function_in_my_mod()` 호출됨, 결과는\\n> \""

#: src/mod/visibility.md:45
msgid ""
"// Functions declared using `pub(self)` syntax are only visible within\n"
"        // the current module, which is the same as leaving them private\n"
msgstr ""
"// `pub(self)` 구문을 사용하여 선언된 함수들은 오직 현재 모듈\n"
"// 내에서만 보이며, 이는 비공개로 두는 것과 동일합니다.\n"

#: src/mod/visibility.md:48
msgid "\"called `my_mod::nested::public_function_in_nested()`\""
msgstr "\"`my_mod::nested::public_function_in_nested()` 호출됨\""

#: src/mod/visibility.md:51
msgid ""
"// Functions declared using `pub(super)` syntax are only visible within\n"
"        // the parent module\n"
msgstr ""
"// `pub(super)` 구문을 사용하여 선언된 함수들은 오직 부모 모듈\n"
"// 내에서만 보입니다.\n"

#: src/mod/visibility.md:54
msgid "\"called `my_mod::nested::public_function_in_super_mod()`\""
msgstr "\"`my_mod::nested::public_function_in_super_mod()` 호출됨\""

#: src/mod/visibility.md:59
msgid "\"called `my_mod::call_public_function_in_my_mod()`, that\\n> \""
msgstr "\"`my_mod::call_public_function_in_my_mod()` 호출됨, 결과는\\n> \""

#: src/mod/visibility.md:61
msgid "\"> \""
msgstr "\"> \""

#: src/mod/visibility.md:65
msgid "// pub(crate) makes functions visible only within the current crate\n"
msgstr "// pub(crate)는 함수를 오직 현재 크레이트 내에서만 보이게 만듭니다\n"

#: src/mod/visibility.md:67
msgid "\"called `my_mod::public_function_in_crate()`\""
msgstr "\"`my_mod::public_function_in_crate()` 호출됨\""

#: src/mod/visibility.md:70
msgid "// Nested modules follow the same rules for visibility\n"
msgstr "// 중첩된 모듈도 동일한 가시성 규칙을 따릅니다\n"

#: src/mod/visibility.md:74
msgid "\"called `my_mod::private_nested::function()`\""
msgstr "\"`my_mod::private_nested::function()` 호출됨\""

#: src/mod/visibility.md:77
msgid ""
"// Private parent items will still restrict the visibility of a child item,\n"
"        // even if it is declared as visible within a bigger scope.\n"
msgstr ""
"// 비공개 부모 아이템은 자식 아이템이 더 큰 스코프 내에서 보이도록\n"
"// 선언되어 있더라도 여전히 그 가시성을 제한합니다.\n"

#: src/mod/visibility.md:81
msgid "\"called `my_mod::private_nested::restricted_function()`\""
msgstr "\"`my_mod::private_nested::restricted_function()` 호출됨\""

#: src/mod/visibility.md:87 src/mod/use.md:25 src/mod/super.md:8
#: src/mod/split.md:24
msgid "\"called `function()`\""
msgstr "\"`function()` 호출됨\""

#: src/mod/visibility.md:91
msgid ""
"// Modules allow disambiguation between items that have the same name.\n"
msgstr ""
"// 모듈은 이름이 같은 아이템들 간의 모호함을 해소할 수 있게 해줍니다.\n"

#: src/mod/visibility.md:95
msgid ""
"// Public items, including those inside nested modules, can be\n"
"    // accessed from outside the parent module.\n"
msgstr ""
"// 중첩된 모듈 내부에 있는 아이템을 포함한 공개 아이템들은\n"
"// 부모 모듈 외부에서 접근할 수 있습니다.\n"

#: src/mod/visibility.md:101
msgid "// pub(crate) items can be called from anywhere in the same crate\n"
msgstr ""
"// pub(crate) 아이템은 같은 크레이트 내 어디에서나 호출될 수 있습니다\n"

#: src/mod/visibility.md:104
msgid ""
"// pub(in path) items can only be called from within the module specified\n"
"    // Error! function `public_function_in_my_mod` is private\n"
"    //my_mod::nested::public_function_in_my_mod();\n"
"    // TODO ^ Try uncommenting this line\n"
msgstr ""
"// `pub(in path)` 아이템은 오직 지정된 모듈 내에서만 호출될 수 있습니다\n"
"// 에러! `public_function_in_my_mod` 함수는 비공개입니다\n"
"// my_mod::nested::public_function_in_my_mod();\n"
"// TODO ^ 이 줄의 주석을 해제해 보세요\n"

#: src/mod/visibility.md:109
msgid ""
"// Private items of a module cannot be directly accessed, even if\n"
"    // nested in a public module:\n"
msgstr ""
"// 모듈의 비공개 아이템은 공개 모듈에 중첩되어 있더라도\n"
"// 직접 접근할 수 없습니다:\n"

#: src/mod/visibility.md:112
msgid ""
"// Error! `private_function` is private\n"
"    //my_mod::private_function();\n"
"    // TODO ^ Try uncommenting this line\n"
msgstr ""
"// 에러! `private_function`은 비공개입니다\n"
"// my_mod::private_function();\n"
"// TODO ^ 이 줄의 주석을 해제해 보세요\n"

#: src/mod/visibility.md:116
msgid ""
"// Error! `private_function` is private\n"
"    //my_mod::nested::private_function();\n"
"    // TODO ^ Try uncommenting this line\n"
msgstr ""
"// 에러! `private_function`은 비공개입니다\n"
"// my_mod::nested::private_function();\n"
"// TODO ^ 이 줄의 주석을 해제해 보세요\n"

#: src/mod/visibility.md:120
msgid ""
"// Error! `private_nested` is a private module\n"
"    //my_mod::private_nested::function();\n"
"    // TODO ^ Try uncommenting this line\n"
msgstr ""
"// 에러! `private_nested`는 비공개 모듈입니다\n"
"// my_mod::private_nested::function();\n"
"// TODO ^ 이 줄의 주석을 해제해 보세요\n"

#: src/mod/visibility.md:124
msgid ""
"// Error! `private_nested` is a private module\n"
"    //my_mod::private_nested::restricted_function();\n"
"    // TODO ^ Try uncommenting this line\n"
msgstr ""
"// 에러! `private_nested`는 비공개 모듈입니다\n"
"// my_mod::private_nested::restricted_function();\n"
"// TODO ^ 이 줄의 주석을 해제해 보세요\n"

#: src/mod/struct_visibility.md:3
msgid ""
"Structs have an extra level of visibility with their fields. The visibility "
"defaults to private, and can be overridden with the `pub` modifier. This "
"visibility only matters when a struct is accessed from outside the module "
"where it is defined, and has the goal of hiding information (encapsulation)."
msgstr ""
"구조체는 필드에 대해 추가적인 수준의 가시성을 가집니다. 가시성은 기본적으로 "
"비공개이며, `pub` 수식어로 재정의할 수 있습니다. 이 가시성은 구조체가 정의된 "
"모듈 외부에서 접근할 때만 의미가 있으며, 정보를 숨기는 것(캡슐화)이 목적입니"
"다."

#: src/mod/struct_visibility.md:10
msgid "// A public struct with a public field of generic type `T`\n"
msgstr "// 제네릭 타입 `T`의 공개 필드를 가진 공개 구조체\n"

#: src/mod/struct_visibility.md:15
msgid "// A public struct with a private field of generic type `T`\n"
msgstr "// 제네릭 타입 `T`의 비공개 필드를 가진 공개 구조체\n"

#: src/mod/struct_visibility.md:21
msgid "// A public constructor method\n"
msgstr "// 공개 생성자 메서드\n"

#: src/mod/struct_visibility.md:31
msgid "// Public structs with public fields can be constructed as usual\n"
msgstr "// 공개 필드를 가진 공개 구조체는 평소처럼 생성할 수 있습니다\n"

#: src/mod/struct_visibility.md:32
msgid "\"public information\""
msgstr "\"공개 정보\""

#: src/mod/struct_visibility.md:34
msgid "// and their fields can be normally accessed.\n"
msgstr "// 그리고 그 필드들에 정상적으로 접근할 수 있습니다.\n"

#: src/mod/struct_visibility.md:35
msgid "\"The open box contains: {}\""
msgstr "\"열린 박스 내용물: {}\""

#: src/mod/struct_visibility.md:37
msgid ""
"// Public structs with private fields cannot be constructed using field "
"names.\n"
"    // Error! `ClosedBox` has private fields\n"
"    //let closed_box = my::ClosedBox { contents: \"classified "
"information\" };\n"
"    // TODO ^ Try uncommenting this line\n"
msgstr ""
"// 비공개 필드를 가진 공개 구조체는 필드 이름을 사용하여 생성할 수 없습니"
"다.\n"
"// 에러! `ClosedBox`에 비공개 필드가 있습니다\n"
"// let closed_box = my::ClosedBox { contents: \"classified information\" };\n"
"// TODO ^ 이 줄의 주석을 해제해 보세요\n"

#: src/mod/struct_visibility.md:42
msgid ""
"// However, structs with private fields can be created using\n"
"    // public constructors\n"
msgstr ""
"// 하지만 비공개 필드를 가진 구조체는 공개 생성자를 통해 생성할 수 있습니다\n"

#: src/mod/struct_visibility.md:44
msgid "\"classified information\""
msgstr "\"기밀 정보\""

#: src/mod/struct_visibility.md:46
msgid ""
"// and the private fields of a public struct cannot be accessed.\n"
"    // Error! The `contents` field is private\n"
"    //println!(\"The closed box contains: {}\", _closed_box.contents);\n"
"    // TODO ^ Try uncommenting this line\n"
msgstr ""
"// 그리고 공개 구조체의 비공개 필드에는 접근할 수 없습니다.\n"
"// 에러! `contents` 필드는 비공개입니다\n"
"// println!(\"닫힌 박스 내용물: {}\", _closed_box.contents);\n"
"// TODO ^ 이 줄의 주석을 해제해 보세요\n"

#: src/mod/struct_visibility.md:55
msgid "[generics](../generics.md) and [methods](../fn/methods.md)"
msgstr "[제네릭](../generics.md) 및 [메서드](../fn/methods.md)"

#: src/mod/use.md:3
msgid ""
"The `use` declaration can be used to bind a full path to a new name, for "
"easier access. It is often used like this:"
msgstr ""
"`use` 선언을 사용하여 전체 경로를 새로운 이름에 바인딩하여 더 쉽게 접근할 수 "
"있습니다. 다음과 같이 자주 사용됩니다:"

#: src/mod/use.md:18
msgid "You can use the `as` keyword to bind imports to a different name:"
msgstr ""
"`as` 키워드를 사용하여 임포트(imports)를 다른 이름에 바인딩할 수 있습니다:"

#: src/mod/use.md:21
msgid "// Bind the `deeply::nested::function` path to `other_function`.\n"
msgstr ""
"// `deeply::nested::function` 경로를 `other_function`에 바인딩합니다.\n"

#: src/mod/use.md:31
msgid "\"called `deeply::nested::function()`\""
msgstr "\"`deeply::nested::function()` 호출됨\""

#: src/mod/use.md:37
msgid "// Easier access to `deeply::nested::function`\n"
msgstr "// `deeply::nested::function`에 더 쉽게 접근\n"

#: src/mod/use.md:40
msgid "\"Entering block\""
msgstr "\"블록 진입\""

#: src/mod/use.md:42
msgid ""
"// This is equivalent to `use deeply::nested::function as function`.\n"
"        // This `function()` will shadow the outer one.\n"
msgstr ""
"// 이는 `use deeply::nested::function as function`과 동일합니다.\n"
"// 이 `function()`은 외부의 것을 섀도잉합니다.\n"

#: src/mod/use.md:46
msgid ""
"// `use` bindings have a local scope. In this case, the\n"
"        // shadowing of `function()` is only in this block.\n"
msgstr ""
"// `use` 바인딩은 지역 스코프를 가집니다. 이 경우\n"
"// `function()`의 섀도잉은 이 블록 내에서만 유효합니다.\n"

#: src/mod/use.md:50
msgid "\"Leaving block\""
msgstr "\"블록 나감\""

#: src/mod/super.md:3
msgid ""
"The `super` and `self` keywords can be used in the path to remove ambiguity "
"when accessing items and to prevent unnecessary hardcoding of paths."
msgstr ""
"`super`와 `self` 키워드는 아이템에 접근할 때 모호함을 제거하고 경로의 불필요"
"한 하드코딩을 방지하기 위해 경로 내에서 사용될 수 있습니다."

#: src/mod/super.md:13
msgid "\"called `cool::function()`\""
msgstr "\"`cool::function()` 호출됨\""

#: src/mod/super.md:19 src/mod/split.md:49
msgid "\"called `my::function()`\""
msgstr "\"`my::function()` 호출됨\""

#: src/mod/super.md:24
msgid "\"called `my::cool::function()`\""
msgstr "\"`my::cool::function()` 호출됨\""

#: src/mod/super.md:29
msgid "// Let's access all the functions named `function` from this scope!\n"
msgstr "// 이 스코프에서 `function`이라는 이름의 모든 함수에 접근해 봅시다!\n"

#: src/mod/super.md:30
msgid "\"called `my::indirect_call()`, that\\n> \""
msgstr "\"`my::indirect_call()` 호출됨, 결과는\\n> \""

#: src/mod/super.md:32
msgid ""
"// The `self` keyword refers to the current module scope - in this case "
"`my`.\n"
"        // Calling `self::function()` and calling `function()` directly both "
"give\n"
"        // the same result, because they refer to the same function.\n"
msgstr ""
"// `self` 키워드는 현재 모듈 스코프를 가리킵니다. 이 경우 `my`입니다.\n"
"// `self::function()`을 호출하는 것과 `function()`을 직접 호출하는 것은\n"
"// 동일한 함수를 가리키기 때문에 같은 결과를 냅니다.\n"

#: src/mod/super.md:38
msgid "// We can also use `self` to access another module inside `my`:\n"
msgstr "// `self`를 사용하여 `my` 내부의 다른 모듈에 접근할 수도 있습니다:\n"

#: src/mod/super.md:41
msgid ""
"// The `super` keyword refers to the parent scope (outside the `my` "
"module).\n"
msgstr "// `super` 키워드는 부모 스코프(`my` 모듈 외부)를 가리킵니다.\n"

#: src/mod/super.md:44
msgid ""
"// This will bind to the `cool::function` in the *crate* scope.\n"
"        // In this case the crate scope is the outermost scope.\n"
msgstr ""
"// 이는 *크레이트* 스코프에 있는 `cool::function`에 바인딩됩니다.\n"
"// 이 경우 크레이트 스코프는 가장 바깥쪽 스코프입니다.\n"

#: src/mod/split.md:3
msgid ""
"Modules can be mapped to a file/directory hierarchy. Let's break down the "
"[visibility example](visibility.md) in files:"
msgstr ""
"모듈은 파일/디렉토리 계층 구조에 매핑될 수 있습니다. [가시성 예제]"
"(visibility.md)를 파일별로 나누어 봅시다:"

#: src/mod/split.md:16
msgid "In `split.rs`:"
msgstr "`split.rs`에서:"

#: src/mod/split.md:19
msgid ""
"// This declaration will look for a file named `my.rs` and will\n"
"// insert its contents inside a module named `my` under this scope\n"
msgstr ""
"// 이 선언은 `my.rs`라는 파일을 찾아 그 내용을\n"
"// 이 스코프 아래의 `my`라는 이름의 모듈로 삽입할 것입니다\n"

#: src/mod/split.md:39
msgid "In `my.rs`:"
msgstr "`my.rs`에서:"

#: src/mod/split.md:42
msgid ""
"// Similarly `mod inaccessible` and `mod nested` will locate the "
"`nested.rs`\n"
"// and `inaccessible.rs` files and insert them here under their respective\n"
"// modules\n"
msgstr ""
"// 마찬가지로 `mod inaccessible`과 `mod nested`는 `nested.rs`와\n"
"// `inaccessible.rs` 파일을 찾아 각각의 모듈 아래에\n"
"// 삽입할 것입니다\n"

#: src/mod/split.md:53
msgid "\"called `my::private_function()`\""
msgstr "\"`my::private_function()` 호출됨\""

#: src/mod/split.md:57
msgid "\"called `my::indirect_access()`, that\\n> \""
msgstr "\"`my::indirect_access()` 호출됨, 결과는\\n> \""

#: src/mod/split.md:63
msgid "In `my/nested.rs`:"
msgstr "`my/nested.rs`에서:"

#: src/mod/split.md:67
msgid "\"called `my::nested::function()`\""
msgstr "\"`my::nested::function()` 호출됨\""

#: src/mod/split.md:72
msgid "\"called `my::nested::private_function()`\""
msgstr "\"`my::nested::private_function()` 호출됨\""

#: src/mod/split.md:76
msgid "In `my/inaccessible.rs`:"
msgstr "`my/inaccessible.rs`에서:"

#: src/mod/split.md:81
msgid "\"called `my::inaccessible::public_function()`\""
msgstr "\"`my::inaccessible::public_function()` 호출됨\""

#: src/mod/split.md:85
msgid "Let's check that things still work as before:"
msgstr "모든 것이 이전과 같이 여전히 잘 작동하는지 확인해 봅시다:"

#: src/crates.md:3
msgid ""
"A crate is a compilation unit in Rust. Whenever `rustc some_file.rs` is "
"called, `some_file.rs` is treated as the _crate file_. If `some_file.rs` has "
"`mod` declarations in it, then the contents of the module files would be "
"inserted in places where `mod` declarations in the crate file are found, "
"_before_ running the compiler over it. In other words, modules do _not_ get "
"compiled individually, only crates get compiled."
msgstr ""
"크레이트(crate)는 Rust의 컴파일 단위입니다. `rustc some_file.rs`가 호출될 때"
"마다 `some_file.rs`는 _크레이트 파일_로 처리됩니다. 만약 `some_file.rs` 내부"
"에 `mod` 선언이 있다면, 컴파일러가 실행되기 _전_에 크레이트 파일에서 `mod` 선"
"언이 발견된 위치에 모듈 파일의 내용이 삽입됩니다. 즉, 모듈은 개별적으로 컴파"
"일되지 않으며 오직 크레이트만 컴파일됩니다."

#: src/crates.md:10
msgid ""
"A crate can be compiled into a binary or into a library. By default, `rustc` "
"will produce a binary from a crate. This behavior can be overridden by "
"passing the `--crate-type` flag to `lib`."
msgstr ""
"크레이트는 바이너리 또는 라이브러리로 컴파일될 수 있습니다. 기본적으로 "
"`rustc`는 크레이트로부터 바이너리를 생성합니다. 이 동작은 `--crate-type` 플래"
"그에 `lib`을 전달하여 재정의할 수 있습니다."

#: src/crates/lib.md:3
msgid "Let's create a library, and then see how to link it to another crate."
msgstr ""
"라이브러리를 만든 다음, 이를 다른 크레이트와 어떻게 연결하는지 살펴봅시다."

#: src/crates/lib.md:5
msgid "In `rary.rs`:"
msgstr "`rary.rs`에서:"

#: src/crates/lib.md:9 src/attribute/crate.md:19
msgid "\"called rary's `public_function()`\""
msgstr "rary의 `public_function()` 호출됨"

#: src/crates/lib.md:13 src/attribute/crate.md:23
msgid "\"called rary's `private_function()`\""
msgstr "rary의 `private_function()` 호출됨"

#: src/crates/lib.md:17 src/attribute/crate.md:27
msgid "\"called rary's `indirect_access()`, that\\n> \""
msgstr "rary의 `indirect_access()` 호출됨, 결과는\\n> \""

#: src/crates/lib.md:29
msgid ""
"Libraries get prefixed with \"lib\", and by default they get named after "
"their crate file, but this default name can be overridden by passing the `--"
"crate-name` option to `rustc` or by using the [`crate_name` attribute](../"
"attribute/crate.md)."
msgstr ""
"라이브러리에는 \"lib\" 접두사가 붙으며, 기본적으로 크레이트 파일의 이름을 따"
"서 명명되지만, 이 기본 이름은 `rustc`에 `--crate-name` 옵션을 전달하거나 "
"[`crate_name` 속성](../attribute/crate.md)을 사용하여 재정의할 수 있습니다."

#: src/crates/using_lib.md:3
msgid ""
"To link a crate to this new library you may use `rustc`'s `--extern` flag. "
"All of its items will then be imported under a module named the same as the "
"library. This module generally behaves the same way as any other module."
msgstr ""
"이 새로운 라이브러리에 크레이트를 연결하려면 `rustc`의 `--extern` 플래그를 사"
"용할 수 있습니다. 그러면 모든 아이템은 라이브러리와 동일한 이름을 가진 모듈 "
"아래로 임포트됩니다. 이 모듈은 일반적으로 다른 모듈과 동일하게 동작합니다."

#: src/crates/using_lib.md:8
msgid ""
"// extern crate rary; // May be required for Rust 2015 edition or earlier\n"
msgstr ""
"// extern crate rary; // Rust 2015 에디션 이하에서는 필요할 수 있습니다\n"

#: src/crates/using_lib.md:13
msgid ""
"// Error! `private_function` is private\n"
"    //rary::private_function();\n"
msgstr ""
"// 에러! `private_function`은 비공개입니다\n"
"// rary::private_function();\n"

#: src/cargo.md:3
msgid ""
"`cargo` is the official Rust package management tool. It has lots of really "
"useful features to improve code quality and developer velocity! These include"
msgstr ""
"`cargo`는 Rust 공식 패키지 관리 도구입니다. 코드 품질과 개발 속도를 향상시키"
"기 위한 정말 유용한 기능들을 많이 가지고 있습니다! 다음과 같은 기능들이 포함"
"됩니다:"

#: src/cargo.md:6
msgid ""
"Dependency management and integration with [crates.io](https://crates.io) "
"(the official Rust package registry)"
msgstr ""
"[crates.io](https://crates.io) (공식 Rust 패키지 레지스트리)와의 통합 및 의존"
"성 관리"

#: src/cargo.md:8
msgid "Awareness of unit tests"
msgstr "유닛 테스트 지원"

#: src/cargo.md:9
msgid "Awareness of benchmarks"
msgstr "벤치마크 지원"

#: src/cargo.md:11
msgid ""
"This chapter will go through some quick basics, but you can find the "
"comprehensive docs in [The Cargo Book](https://doc.rust-lang.org/cargo/)."
msgstr ""
"이 장에서는 기본적인 사항들을 빠르게 살펴볼 것입니다. 더 자세한 문서는 [The "
"Cargo Book](https://doc.rust-lang.org/cargo/)에서 찾을 수 있습니다."

#: src/cargo/deps.md:3
msgid ""
"Most programs have dependencies on some libraries. If you have ever managed "
"dependencies by hand, you know how much of a pain this can be. Luckily, the "
"Rust ecosystem comes standard with `cargo`! `cargo` can manage dependencies "
"for a project."
msgstr ""
"대부분의 프로그램은 일부 라이브러리에 의존성을 가집니다. 의존성을 수동으로 관"
"리해 본 적이 있다면 그것이 얼마나 고통스러운 일인지 알 것입니다. 다행히도 "
"Rust 생태계에는 `cargo`가 표준으로 포함되어 있습니다! `cargo`는 프로젝트의 의"
"존성을 관리할 수 있습니다."

#: src/cargo/deps.md:8
msgid "To create a new Rust project,"
msgstr "새로운 Rust 프로젝트를 만들려면,"

#: src/cargo/deps.md:11
msgid "# A binary\n"
msgstr "# 바이너리\n"

#: src/cargo/deps.md:13
msgid "# A library\n"
msgstr "# 라이브러리\n"

#: src/cargo/deps.md:18
msgid ""
"For the rest of this chapter, let's assume we are making a binary, rather "
"than a library, but all of the concepts are the same."
msgstr ""
"이 장의 나머지 부분에서는 라이브러리가 아닌 바이너리를 만든다고 가정하겠습니"
"다. 하지만 모든 개념은 동일합니다."

#: src/cargo/deps.md:21
msgid "After the above commands, you should see a file hierarchy like this:"
msgstr ""
"위의 명령어를 실행한 후에는 다음과 같은 파일 계층 구조를 보게 될 것입니다:"

#: src/cargo/deps.md:35
msgid ""
"The `main.rs` is the root source file for your new `foo` project -- nothing "
"new there. The `Cargo.toml` is the config file for `cargo` for this project. "
"If you look inside it, you should see something like this:"
msgstr ""
"`main.rs`는 새로운 `foo` 프로젝트의 루트 소스 파일입니다. 특별할 것은 없습니"
"다. `Cargo.toml`은 이 프로젝트에 대한 `cargo` 설정 파일입니다. 그 안을 들여다"
"보면 다음과 같은 내용을 볼 수 있을 것입니다:"

#: src/cargo/deps.md:39
msgid ""
"```toml\n"
"[package]\n"
"name = \"foo\"\n"
"version = \"0.1.0\"\n"
"authors = [\"mark\"]\n"
"\n"
"[dependencies]\n"
"```"
msgstr ""
"```toml\n"
"[package]\n"
"name = \"foo\"\n"
"version = \"0.1.0\"\n"
"authors = [\"mark\"]\n"
"\n"
"[dependencies]\n"
"```"

#: src/cargo/deps.md:48
msgid ""
"The `name` field under `[package]` determines the name of the project. This "
"is used by `crates.io` if you publish the crate (more later). It is also the "
"name of the output binary when you compile."
msgstr ""
"`[package]` 아래의 `name` 필드는 프로젝트의 이름을 결정합니다. 이는 크레이트"
"를 배포할 때(나중에 자세히 설명함) `crates.io`에서 사용됩니다. 또한 컴파일할 "
"때 생성되는 바이너리의 이름이기도 합니다."

#: src/cargo/deps.md:52
msgid ""
"The `version` field is a crate version number using [Semantic Versioning]"
"(http://semver.org/)."
msgstr ""
"`version` 필드는 [유의적 버전(Semantic Versioning)](http://semver.org/)을 사"
"용하는 크레이트 버전 번호입니다."

#: src/cargo/deps.md:55
msgid ""
"The `authors` field is a list of authors used when publishing the crate."
msgstr "`authors` 필드는 크레이트를 배포할 때 사용되는 작성자 목록입니다."

#: src/cargo/deps.md:57
msgid ""
"The `[dependencies]` section lets you add dependencies for your project."
msgstr ""
"`[dependencies]` 섹션에서는 프로젝트에 필요한 의존성을 추가할 수 있습니다."

#: src/cargo/deps.md:59
msgid ""
"For example, suppose that we want our program to have a great CLI. You can "
"find lots of great packages on [crates.io](https://crates.io) (the official "
"Rust package registry). One popular choice is [clap](https://crates.io/"
"crates/clap). As of this writing, the most recent published version of "
"`clap` is `2.27.1`. To add a dependency to our program, we can simply add "
"the following to our `Cargo.toml` under `[dependencies]`: `clap = "
"\"2.27.1\"`. And that's it! You can start using `clap` in your program."
msgstr ""
"예를 들어, 우리 프로그램이 멋진 CLI를 갖기를 원한다고 가정해 봅시다. "
"[crates.io](https://crates.io) (공식 Rust 패키지 레지스트리)에서 훌륭한 패키"
"지들을 많이 찾을 수 있습니다. 인기 있는 선택지 중 하나는 [clap](https://"
"crates.io/crates/clap)입니다. 이 글을 쓰는 시점에서 `clap`의 최신 버전은 "
"`2.27.1`입니다. 프로그램에 의존성을 추가하려면 `Cargo.toml`의 "
"`[dependencies]` 아래에 다음과 같이 추가하면 됩니다: `clap = \"2.27.1\"`. 이"
"것으로 끝입니다! 이제 프로그램에서 `clap`을 사용할 수 있습니다."

#: src/cargo/deps.md:67
msgid ""
"`cargo` also supports [other types of dependencies](https://doc.rust-"
"lang.org/cargo/reference/specifying-dependencies.html). Here is just a small "
"sampling:"
msgstr ""
"`cargo`는 [다른 유형의 의존성](https://doc.rust-lang.org/cargo/reference/"
"specifying-dependencies.html)도 지원합니다. 다음은 몇 가지 예시입니다:"

#: src/cargo/deps.md:70
msgid ""
"```toml\n"
"[package]\n"
"name = \"foo\"\n"
"version = \"0.1.0\"\n"
"authors = [\"mark\"]\n"
"\n"
"[dependencies]\n"
"clap = \"2.27.1\" # from crates.io\n"
"rand = { git = \"https://github.com/rust-lang-nursery/rand\" } # from online "
"repo\n"
"bar = { path = \"../bar\" } # from a path in the local filesystem\n"
"```"
msgstr ""
"```toml\n"
"[package]\n"
"name = \"foo\"\n"
"version = \"0.1.0\"\n"
"authors = [\"mark\"]\n"
"\n"
"[dependencies]\n"
"clap = \"2.27.1\" # crates.io에서\n"
"rand = { git = \"https://github.com/rust-lang-nursery/rand\" } # 온라인 저장"
"소에서\n"
"bar = { path = \"../bar\" } # 로컬 파일시스템의 경로에서\n"
"```"

#: src/cargo/deps.md:82
msgid ""
"`cargo` is more than a dependency manager. All of the available "
"configuration options are listed in the [format specification](https://"
"doc.rust-lang.org/cargo/reference/manifest.html) of `Cargo.toml`."
msgstr ""
"`cargo`는 단순한 의존성 관리자 그 이상입니다. 사용 가능한 모든 설정 옵션은 "
"`Cargo.toml`의 [형식 명세(format specification)](https://doc.rust-lang.org/"
"cargo/reference/manifest.html)에 나열되어 있습니다."

#: src/cargo/deps.md:86
msgid ""
"To build our project we can execute `cargo build` anywhere in the project "
"directory (including subdirectories!). We can also do `cargo run` to build "
"and run. Notice that these commands will resolve all dependencies, download "
"crates if needed, and build everything, including your crate. (Note that it "
"only rebuilds what it has not already built, similar to `make`)."
msgstr ""
"프로젝트를 빌드하려면 프로젝트 디렉토리 어디에서나(하위 디렉토리 포함!) "
"`cargo build`를 실행하면 됩니다. 또한 `cargo run`을 통해 빌드와 실행을 동시"
"에 할 수도 있습니다. 이 명령어들은 모든 의존성을 해결하고, 필요한 경우 크레이"
"트를 다운로드하며, 여러분의 크레이트를 포함한 모든 것을 빌드합니다. (이미 빌"
"드된 것은 다시 빌드하지 않으며, 이는 `make`와 유사합니다)."

#: src/cargo/deps.md:92
msgid "Voila! That's all there is to it!"
msgstr "보세요! 이게 전부입니다!"

#: src/cargo/conventions.md:3
msgid "In the previous chapter, we saw the following directory hierarchy:"
msgstr "이전 장에서 우리는 다음과 같은 디렉터리 계층 구조를 보았습니다."

#: src/cargo/conventions.md:12
msgid ""
"Suppose that we wanted to have two binaries in the same project, though. "
"What then?"
msgstr ""
"하지만 같은 프로젝트에 두 개의 바이너리를 두고 싶다면 어떨까요? 그럴 땐 어떻"
"게 해야 할까요?"

#: src/cargo/conventions.md:15
msgid ""
"It turns out that `cargo` supports this. The default binary name is `main`, "
"as we saw before, but you can add additional binaries by placing them in a "
"`bin/` directory:"
msgstr ""
"다행히 `cargo`는 이를 지원합니다. 이전에 보았듯이 기본 바이너리 이름은 `main`"
"이지만, `bin/` 디렉터리에 추가 바이너리를 배치하여 추가할 수 있습니다."

#: src/cargo/conventions.md:28
msgid ""
"To tell `cargo` to only compile or run this binary, we just pass `cargo` the "
"`--bin my_other_bin` flag, where `my_other_bin` is the name of the binary we "
"want to work with."
msgstr ""
"`cargo`에게 이 바이너리만 컴파일하거나 실행하도록 하려면, `cargo`에 `--bin "
"my_other_bin` 플래그를 전달하면 됩니다. 여기서 `my_other_bin`은 작업하려는 바"
"이너리의 이름입니다."

#: src/cargo/conventions.md:32
msgid ""
"In addition to extra binaries, `cargo` supports [more features](https://"
"doc.rust-lang.org/cargo/guide/project-layout.html) such as benchmarks, "
"tests, and examples."
msgstr ""
"추가 바이너리 외에도 `cargo`는 벤치마크, 테스트, 예제와 같은 [더 많은 기능]"
"(https://doc.rust-lang.org/cargo/guide/project-layout.html)을 지원합니다."

#: src/cargo/conventions.md:35
msgid "In the next chapter, we will look more closely at tests."
msgstr "다음 장에서는 테스트에 대해 더 자세히 살펴보겠습니다."

#: src/cargo/test.md:3
msgid ""
"As we know testing is integral to any piece of software! Rust has first-"
"class support for unit and integration testing ([see this chapter](https://"
"doc.rust-lang.org/book/ch11-00-testing.html) in TRPL)."
msgstr ""
"우리 모두 알다시피 테스트는 모든 소프트웨어의 필수적인 부분입니다! Rust는 유"
"닛 테스트와 통합 테스트를 위한 일류(first-class) 지원을 제공합니다(TRPL의 "
"[이 장](https://doc.rust-lang.org/book/ch11-00-testing.html)을 참조하세요)."

#: src/cargo/test.md:7
msgid ""
"From the testing chapters linked above, we see how to write unit tests and "
"integration tests. Organizationally, we can place unit tests in the modules "
"they test and integration tests in their own `tests/` directory:"
msgstr ""
"위에 링크된 테스트 장들에서 유닛 테스트와 통합 테스트를 작성하는 방법을 확인"
"할 수 있습니다. 구조적으로 유닛 테스트는 테스트 대상 모듈에 배치하고, 통합 테"
"스트는 별도의 `tests/` 디렉터리에 배치할 수 있습니다."

#: src/cargo/test.md:22
msgid ""
"Each file in `tests` is a separate [integration test](https://doc.rust-"
"lang.org/book/ch11-03-test-organization.html#integration-tests), i.e. a test "
"that is meant to test your library as if it were being called from a "
"dependent crate."
msgstr ""
"`tests` 내의 각 파일은 별도의 [통합 테스트](https://doc.rust-lang.org/book/"
"ch11-03-test-organization.html#integration-tests)입니다. 즉, 의존성 있는 크레"
"이트에서 호출되는 것처럼 라이브러리를 테스트하기 위한 것입니다."

#: src/cargo/test.md:27
msgid ""
"The [Testing](../testing.md) chapter elaborates on the three different "
"testing styles: [Unit](../testing/unit_testing.md), [Doc](../testing/"
"doc_testing.md), and [Integration](../testing/integration_testing.md)."
msgstr ""
"[테스트](../testing.md) 장에서는 [유닛(Unit)](../testing/unit_testing.md), "
"[문서(Doc)](../testing/doc_testing.md), [통합(Integration)](../testing/"
"integration_testing.md)의 세 가지 테스트 스타일에 대해 자세히 설명합니다."

#: src/cargo/test.md:30
msgid "`cargo` naturally provides an easy way to run all of your tests!"
msgstr "`cargo`는 당연히 모든 테스트를 실행할 수 있는 쉬운 방법을 제공합니다!"

#: src/cargo/test.md:36
msgid "You should see output like this:"
msgstr "다음과 같은 출력을 볼 수 있을 것입니다:"

#: src/cargo/test.md:38
msgid ""
"```shell\n"
"$ cargo test\n"
"   Compiling blah v0.1.0 (file:///nobackup/blah)\n"
"    Finished dev [unoptimized + debuginfo] target(s) in 0.89 secs\n"
"     Running target/debug/deps/blah-d3b32b97275ec472\n"
"\n"
"running 4 tests\n"
"test test_bar ... ok\n"
"test test_baz ... ok\n"
"test test_foo_bar ... ok\n"
"test test_foo ... ok\n"
"\n"
"test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out\n"
"```"
msgstr ""
"```shell\n"
"$ cargo test\n"
"   Compiling blah v0.1.0 (file:///nobackup/blah)\n"
"    Finished dev [unoptimized + debuginfo] target(s) in 0.89 secs\n"
"     Running target/debug/deps/blah-d3b32b97275ec472\n"
"\n"
"running 4 tests\n"
"test test_bar ... ok\n"
"test test_baz ... ok\n"
"test test_foo_bar ... ok\n"
"test test_foo ... ok\n"
"\n"
"test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out\n"
"``````shell\n"
"$ cargo test\n"
"   Compiling blah v0.1.0 (file:///nobackup/blah)\n"
"    Finished dev [unoptimized + debuginfo] target(s) in 0.89 secs\n"
"     Running target/debug/deps/blah-d3b32b97275ec472\n"
"\n"
"running 4 tests\n"
"test test_bar ... ok\n"
"test test_baz ... ok\n"
"test test_foo_bar ... ok\n"
"test test_foo ... ok\n"
"\n"
"test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out\n"
"```"

#: src/cargo/test.md:53
msgid "You can also run tests whose name matches a pattern:"
msgstr "이름이 패턴과 일치하는 테스트만 실행할 수도 있습니다:"

#: src/cargo/test.md:59
msgid ""
"```shell\n"
"$ cargo test test_foo\n"
"   Compiling blah v0.1.0 (file:///nobackup/blah)\n"
"    Finished dev [unoptimized + debuginfo] target(s) in 0.35 secs\n"
"     Running target/debug/deps/blah-d3b32b97275ec472\n"
"\n"
"running 2 tests\n"
"test test_foo ... ok\n"
"test test_foo_bar ... ok\n"
"\n"
"test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 2 filtered out\n"
"```"
msgstr ""
"```shell\n"
"$ cargo test test_foo\n"
"   Compiling blah v0.1.0 (file:///nobackup/blah)\n"
"    Finished dev [unoptimized + debuginfo] target(s) in 0.35 secs\n"
"     Running target/debug/deps/blah-d3b32b97275ec472\n"
"\n"
"running 2 tests\n"
"test test_foo ... ok\n"
"test test_foo_bar ... ok\n"
"\n"
"test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 2 filtered out\n"
"```"

#: src/cargo/test.md:72
msgid ""
"One word of caution: Cargo may run multiple tests concurrently, so make sure "
"that they don't race with each other."
msgstr ""
"한 가지 주의할 점: Cargo는 여러 테스트를 동시에 실행할 수 있으므로 서로 경쟁"
"(race)하지 않도록 확인해야 합니다."

#: src/cargo/test.md:75
msgid ""
"One example of this concurrency causing issues is if two tests output to a "
"file, such as below:"
msgstr ""
"이러한 동시성이 문제를 일으키는 한 가지 예는 아래와 같이 두 테스트가 하나의 "
"파일에 출력하는 경우입니다:"

#: src/cargo/test.md:81
msgid "// Import the necessary modules\n"
msgstr "// 필요한 모듈 가져오기\n"

#: src/cargo/test.md:85
msgid "// This test writes to a file\n"
msgstr "// 이 테스트는 파일에 씁니다\n"

#: src/cargo/test.md:88 src/cargo/test.md:105
msgid "// Opens the file ferris.txt or creates one if it doesn't exist.\n"
msgstr "// ferris.txt 파일을 열거나 없으면 생성합니다.\n"

#: src/cargo/test.md:92 src/cargo/test.md:109
msgid "\"ferris.txt\""
msgstr "\"ferris.txt\""

#: src/cargo/test.md:93 src/cargo/test.md:110
msgid "\"Failed to open ferris.txt\""
msgstr "\"ferris.txt를 여는 데 실패했습니다\""

#: src/cargo/test.md:95
msgid "// Print \"Ferris\" 5 times.\n"
msgstr "// \"Ferris\"를 5번 출력합니다.\n"

#: src/cargo/test.md:97
msgid "\"Ferris\\n\""
msgstr "\"Ferris\\n\""

#: src/cargo/test.md:98 src/cargo/test.md:115
msgid "\"Could not write to ferris.txt\""
msgstr "\"ferris.txt에 쓸 수 없습니다\""

#: src/cargo/test.md:102
msgid "// This test tries to write to the same file\n"
msgstr "// 이 테스트는 동일한 파일에 쓰기를 시도합니다\n"

#: src/cargo/test.md:112
msgid "// Print \"Corro\" 5 times.\n"
msgstr "// \"Corro\"를 5번 출력합니다.\n"

#: src/cargo/test.md:114
msgid "\"Corro\\n\""
msgstr "\"Corro\\n\""

#: src/cargo/test.md:121
msgid "Although the intent is to get the following:"
msgstr "의도는 다음과 같은 결과를 얻는 것이었지만:"

#: src/cargo/test.md:137
msgid "What actually gets put into `ferris.txt` is this:"
msgstr "`ferris.txt`에 실제로 기록된 내용은 다음과 같습니다:"

#: src/cargo/build_scripts.md:3
msgid ""
"Sometimes a normal build from `cargo` is not enough. Perhaps your crate "
"needs some pre-requisites before `cargo` will successfully compile, things "
"like code generation, or some native code that needs to be compiled. To "
"solve this problem we have build scripts that Cargo can run."
msgstr ""
"`cargo`의 일반적인 빌드만으로는 충분하지 않은 경우가 있습니다. 코드 생성이나 "
"컴파일되어야 하는 네이티브 코드와 같이 `cargo`가 성공적으로 컴파일되기 전에 "
"크레이트가 필요로 하는 전제 조건이 있을 수 있습니다. 이 문제를 해결하기 위해 "
"Cargo가 실행할 수 있는 빌드 스크립트가 있습니다."

#: src/cargo/build_scripts.md:8
msgid ""
"To add a build script to your package it can either be specified in the "
"`Cargo.toml` as follows:"
msgstr ""
"패키지에 빌드 스크립트를 추가하려면 다음과 같이 `Cargo.toml`에 지정할 수 있습"
"니다:"

#: src/cargo/build_scripts.md:11
msgid ""
"```toml\n"
"[package]\n"
"...\n"
"build = \"build.rs\"\n"
"```"
msgstr ""
"```toml\n"
"[package]\n"
"...\n"
"build = \"build.rs\"\n"
"```"

#: src/cargo/build_scripts.md:17
msgid ""
"Otherwise Cargo will look for a `build.rs` file in the project directory by "
"default."
msgstr ""
"그렇지 않으면 Cargo는 기본적으로 프로젝트 디렉토리에서 `build.rs` 파일을 찾습"
"니다."

#: src/cargo/build_scripts.md:20
msgid "How to use a build script"
msgstr "빌드 스크립트 사용 방법"

#: src/cargo/build_scripts.md:22
msgid ""
"The build script is simply another Rust file that will be compiled and "
"invoked prior to compiling anything else in the package. Hence it can be "
"used to fulfill pre-requisites of your crate."
msgstr ""
"빌드 스크립트는 단순히 또 다른 Rust 파일로, 패키지의 다른 어떤 것을 컴파일하"
"기 전에 먼저 컴파일되고 호출됩니다. 따라서 크레이트의 전제 조건을 충족시키는 "
"데 사용할 수 있습니다."

#: src/cargo/build_scripts.md:26
msgid ""
"Cargo provides the script with inputs via environment variables [specified "
"here](https://doc.rust-lang.org/cargo/reference/environment-"
"variables.html#environment-variables-cargo-sets-for-build-scripts) that can "
"be used."
msgstr ""
"Cargo는 스크립트에서 사용할 수 있는 환경 변수([여기에 명시됨](https://"
"doc.rust-lang.org/cargo/reference/environment-variables.html#environment-"
"variables-cargo-sets-for-build-scripts))를 통해 입력을 제공합니다."

#: src/cargo/build_scripts.md:29
msgid ""
"The script provides output via stdout. All lines printed are written to "
"`target/debug/build/<pkg>/output`. Further, lines prefixed with `cargo:` "
"will be interpreted by Cargo directly and hence can be used to define "
"parameters for the package's compilation."
msgstr ""
"스크립트는 stdout을 통해 출력을 제공합니다. 출력된 모든 줄은 `target/debug/"
"build/<pkg>/output`에 기록됩니다. 또한, `cargo:`로 시작하는 줄은 Cargo에 의"
"해 직접 해석되어 패키지 컴파일을 위한 매개변수를 정의하는 데 사용될 수 있습니"
"다."

#: src/cargo/build_scripts.md:34
msgid ""
"For further specification and examples have a read of the [Cargo "
"specification](https://doc.rust-lang.org/cargo/reference/build-scripts.html)."
msgstr ""
"추가적인 사양과 예제는 [Cargo 사양서](https://doc.rust-lang.org/cargo/"
"reference/build-scripts.html)를 읽어보세요."

#: src/attribute.md:3
msgid ""
"An attribute is metadata applied to some module, crate or item. This "
"metadata can be used to/for:"
msgstr ""
"속성(attribute)은 모듈, 크레이트 또는 아이템에 적용되는 메타데이터입니다. 이 "
"메타데이터는 다음과 같은 용도로 사용될 수 있습니다:"

#: src/attribute.md:8
msgid "[conditional compilation of code](attribute/cfg.md)"
msgstr "코드의 [조건부 컴파일](attribute/cfg.md)"

#: src/attribute.md:9
msgid ""
"[set crate name, version and type (binary or library)](attribute/crate.md)"
msgstr ""
"[크레이트 이름, 버전 및 유형(바이너리 또는 라이브러리) 설정](attribute/"
"crate.md)"

#: src/attribute.md:10
msgid ""
"disable [lints](https://en.wikipedia.org/wiki/Lint_%28software%29) (warnings)"
msgstr ""
"[린트(lints)](https://en.wikipedia.org/wiki/Lint_%28software%29) (경고) 비활"
"성화"

#: src/attribute.md:11
msgid "enable compiler features (macros, glob imports, etc.)"
msgstr "컴파일러 기능(매크로, glob 임포트 등) 활성화"

#: src/attribute.md:12
msgid "link to a foreign library"
msgstr "외부 라이브러리 링크"

#: src/attribute.md:13
msgid "mark functions as unit tests"
msgstr "함수를 유닛 테스트로 표시"

#: src/attribute.md:14
msgid "mark functions that will be part of a benchmark"
msgstr "벤치마크의 일부가 될 함수 표시"

#: src/attribute.md:15
msgid ""
"[attribute like macros](https://doc.rust-lang.org/book/ch19-06-"
"macros.html#attribute-like-macros)"
msgstr ""
"[속성형 매크로](https://doc.rust-lang.org/book/ch19-06-macros.html#attribute-"
"like-macros)"

#: src/attribute.md:17
msgid ""
"Attributes look like `#[outer_attribute]` or `#![inner_attribute]`, with the "
"difference between them being where they apply."
msgstr ""
"속성은 `#[outer_attribute]` 또는 `#![inner_attribute]`와 같은 형태를 띠며, "
"이 둘의 차이점은 적용되는 위치에 있습니다."

#: src/attribute.md:20
msgid ""
"`#[outer_attribute]` applies to the [item](https://doc.rust-lang.org/stable/"
"reference/items.html) immediately following it. Some examples of items are: "
"a function, a module declaration, a constant, a structure, an enum. Here is "
"an example where attribute `#[derive(Debug)]` applies to the struct "
"`Rectangle`:"
msgstr ""
"`#[outer_attribute]`는 바로 뒤에 오는 [아이템](https://doc.rust-lang.org/"
"stable/reference/items.html)에 적용됩니다. 아이템의 예로는 함수, 모듈 선언, "
"상수, 구조체, 열거형 등이 있습니다. 다음은 `#[derive(Debug)]` 속성이 "
"`Rectangle` 구조체에 적용된 예시입니다:"

#: src/attribute.md:34
msgid ""
"`#![inner_attribute]` applies to the enclosing [item](https://doc.rust-"
"lang.org/stable/reference/items.html) (typically a module or a crate). In "
"other words, this attribute is interpreted as applying to the entire scope "
"in which it's placed. Here is an example where `#![allow(unused_variables)]` "
"applies to the whole crate (if placed in `main.rs`):"
msgstr ""
"`#![inner_attribute]`는 자신을 감싸고 있는 [아이템](https://doc.rust-"
"lang.org/stable/reference/items.html) (주로 모듈이나 크레이트)에 적용됩니다. "
"다시 말해, 이 속성은 자신이 위치한 전체 스코프에 적용되는 것으로 해석됩니다. "
"다음은 `#![allow(unused_variables)]`가 (`main.rs`에 위치할 경우) 전체 크레이"
"트에 적용되는 예시입니다:"

#: src/attribute.md:44
msgid "// This would normally warn about an unused variable.\n"
msgstr "// 이것은 보통 사용되지 않는 변수에 대해 경고합니다.\n"

#: src/attribute.md:48
msgid "Attributes can take arguments with different syntaxes:"
msgstr "속성은 다양한 문법으로 인자를 받을 수 있습니다:"

#: src/attribute.md:50
msgid "`#[attribute = \"value\"]`"
msgstr "`#[attribute = \"value\"]`"

#: src/attribute.md:51
msgid "`#[attribute(key = \"value\")]`"
msgstr "`#[attribute(key = \"value\")]`"

#: src/attribute.md:52
msgid "`#[attribute(value)]`"
msgstr "`#[attribute(value)]`"

#: src/attribute.md:54
msgid ""
"Attributes can have multiple values and can be separated over multiple "
"lines, too:"
msgstr "속성은 여러 값을 가질 수 있으며 여러 줄에 걸쳐 분리될 수도 있습니다:"

#: src/attribute/unused.md:3
msgid ""
"The compiler provides a `dead_code` [_lint_](https://en.wikipedia.org/wiki/"
"Lint_%28software%29) that will warn about unused functions. An _attribute_ "
"can be used to disable the lint."
msgstr ""
"컴파일러는 사용되지 않는 함수에 대해 경고하는 `dead_code` [_린트(lint)_]"
"(https://en.wikipedia.org/wiki/Lint_%28software%29)를 제공합니다. _속성_을 사"
"용하여 이 린트를 비활성화할 수 있습니다."

#: src/attribute/unused.md:9
msgid ""
"// `#[allow(dead_code)]` is an attribute that disables the `dead_code` lint\n"
msgstr ""
"// `#[allow(dead_code)]`는 `dead_code` 린트를 비활성화하는 속성입니다\n"

#: src/attribute/unused.md:14
msgid "// FIXME ^ Add an attribute to suppress the warning\n"
msgstr "// FIXME ^ 경고를 억제하기 위해 속성을 추가하세요\n"

#: src/attribute/unused.md:22
msgid ""
"Note that in real programs, you should eliminate dead code. In these "
"examples we'll allow dead code in some places because of the interactive "
"nature of the examples."
msgstr ""
"실제 프로그램에서는 죽은 코드를 제거해야 합니다. 이 예제들에서는 예제의 대화"
"형 특성 때문에 일부 장소에서 죽은 코드를 허용할 것입니다."

#: src/attribute/crate.md:3
msgid ""
"The `crate_type` attribute can be used to tell the compiler whether a crate "
"is a binary or a library (and even which type of library), and the "
"`crate_name` attribute can be used to set the name of the crate."
msgstr ""
"`crate_type` 속성은 크레이트가 바이너리인지 라이브러리인지(심지어 어떤 종류"
"의 라이브러리인지) 컴파일러에게 알려주는 데 사용될 수 있으며, `crate_name` 속"
"성은 크레이트의 이름을 설정하는 데 사용될 수 있습니다."

#: src/attribute/crate.md:7
msgid ""
"However, it is important to note that both the `crate_type` and `crate_name` "
"attributes have **no** effect whatsoever when using Cargo, the Rust package "
"manager. Since Cargo is used for the majority of Rust projects, this means "
"real-world uses of `crate_type` and `crate_name` are relatively limited."
msgstr ""
"하지만 Rust 패키지 관리자인 Cargo를 사용할 때는 `crate_type`과 `crate_name` "
"속성 모두 **아무런** 효과가 없다는 점에 유의해야 합니다. 대다수의 Rust 프로젝"
"트가 Cargo를 사용하므로, `crate_type`과 `crate_name`의 실제 사용은 상대적으"
"로 제한적입니다."

#: src/attribute/crate.md:13
msgid "// This crate is a library\n"
msgstr "// 이 크레이트는 라이브러리입니다\n"

#: src/attribute/crate.md:14
msgid "\"lib\""
msgstr "\"lib\""

#: src/attribute/crate.md:14
msgid "// The library is named \"rary\"\n"
msgstr "// 라이브러리 이름은 \"rary\"입니다\n"

#: src/attribute/crate.md:16
msgid "\"rary\""
msgstr "\"rary\""

#: src/attribute/crate.md:33
msgid ""
"When the `crate_type` attribute is used, we no longer need to pass the `--"
"crate-type` flag to `rustc`."
msgstr ""
"`crate_type` 속성이 사용되면, 더 이상 `rustc`에 `--crate-type` 플래그를 전달"
"할 필요가 없습니다."

#: src/attribute/cfg.md:3
msgid ""
"Configuration conditional checks are possible through two different "
"operators:"
msgstr "설정 조건 검사는 두 가지 다른 연산자를 통해 가능합니다:"

#: src/attribute/cfg.md:5
msgid "the `cfg` attribute: `#[cfg(...)]` in attribute position"
msgstr "`cfg` 속성: 속성 위치에서의 `#[cfg(...)]`"

#: src/attribute/cfg.md:6
msgid "the `cfg!` macro: `cfg!(...)` in boolean expressions"
msgstr "`cfg!` 매크로: 불리언 표현식에서의 `cfg!(...)`"

#: src/attribute/cfg.md:8
msgid ""
"While the former enables conditional compilation, the latter conditionally "
"evaluates to `true` or `false` literals allowing for checks at run-time. "
"Both utilize identical argument syntax."
msgstr ""
"전자는 조건부 컴파일을 가능하게 하는 반면, 후자는 조건부로 `true` 또는 "
"`false` 리터럴로 평가되어 런타임에 검사를 가능하게 합니다. 둘 다 동일한 인자 "
"문법을 사용합니다."

#: src/attribute/cfg.md:12
msgid ""
"`cfg!`, unlike `#[cfg]`, does not remove any code and only evaluates to true "
"or false. For example, all blocks in an if/else expression need to be valid "
"when `cfg!` is used for the condition, regardless of what `cfg!` is "
"evaluating."
msgstr ""
"`cfg!`는 `#[cfg]`와 달리 코드를 제거하지 않으며 오직 참 또는 거짓으로만 평가"
"됩니다. 예를 들어 `cfg!`가 조건으로 사용될 때, `cfg!`가 무엇으로 평가되든 상"
"관없이 if/else 표현식의 모든 블록은 유효해야 합니다."

#: src/attribute/cfg.md:15
msgid "// This function only gets compiled if the target OS is linux\n"
msgstr "// 이 함수는 대상 OS가 리눅스인 경우에만 컴파일됩니다\n"

#: src/attribute/cfg.md:16 src/attribute/cfg.md:22 src/attribute/cfg.md:31
msgid "\"linux\""
msgstr "\"linux\""

#: src/attribute/cfg.md:18
msgid "\"You are running linux!\""
msgstr "\"당신은 리눅스를 사용하고 있습니다!\""

#: src/attribute/cfg.md:20
msgid ""
"// And this function only gets compiled if the target OS is *not* linux\n"
msgstr "// 그리고 이 함수는 타겟 OS가 리눅스가 *아닌* 경우에만 컴파일됩니다.\n"

#: src/attribute/cfg.md:24
msgid "\"You are *not* running linux!\""
msgstr "\"당신은 리눅스를 사용하고 있지 *않습니다*!\""

#: src/attribute/cfg.md:30
msgid "\"Are you sure?\""
msgstr "\"확실한가요?\""

#: src/attribute/cfg.md:32
msgid "\"Yes. It's definitely linux!\""
msgstr "\"네. 확실히 리눅스입니다!\""

#: src/attribute/cfg.md:34
msgid "\"Yes. It's definitely *not* linux!\""
msgstr "\"네. 확실히 리눅스가 *아닙니다*!\""

#: src/attribute/cfg.md:41
msgid ""
"[the reference](https://doc.rust-lang.org/reference/"
"attributes.html#conditional-compilation), [`cfg!`](https://doc.rust-lang.org/"
"std/macro.cfg!.html), and [macros](../macros.md)."
msgstr ""
"[참조](https://doc.rust-lang.org/reference/"
"attributes.html#conditional-compilation), [`cfg!`](https://doc.rust-lang.org/"
"std/macro.cfg!.html), 그리고 [매크로](../macros.md)."

#: src/attribute/cfg/custom.md:3
msgid ""
"Some conditionals like `target_os` are implicitly provided by `rustc`, but "
"custom conditionals must be passed to `rustc` using the `--cfg` flag."
msgstr ""
"`target_os`와 같은 일부 조건은 `rustc`에 의해 암시적으로 제공되지만, 사용자 "
"정의 조건은 `--cfg` 플래그를 사용하여 `rustc`에 전달되어야 합니다."

#: src/attribute/cfg/custom.md:9
msgid "\"condition met!\""
msgstr "\"조건 충족!\""

#: src/attribute/cfg/custom.md:17
msgid "Try to run this to see what happens without the custom `cfg` flag."
msgstr "사용자 정의 `cfg` 플래그 없이 실행하면 어떻게 되는지 확인해 보세요."

#: src/attribute/cfg/custom.md:19
msgid "With the custom `cfg` flag:"
msgstr "사용자 정의 `cfg` 플래그 사용 시:"

#: src/generics.md:3
msgid ""
"_Generics_ is the topic of generalizing types and functionalities to broader "
"cases. This is extremely useful for reducing code duplication in many ways, "
"but can call for rather involved syntax. Namely, being generic requires "
"taking great care to specify over which types a generic type is actually "
"considered valid. The simplest and most common use of generics is for type "
"parameters."
msgstr ""
"_제네릭(Generics)_은 타입과 기능을 더 넓은 케이스로 일반화하는 주제입니다. 이"
"는 여러 면에서 코드 중복을 줄이는 데 매우 유용하지만, 다소 복잡한 문법을 요"
"구할 수 있습니다. 즉, 제네릭이 되려면 제네릭 타입이 실제로 유효한 것으로 간주"
"되는 타입을 지정하는 데 세심한 주의가 필요합니다. 제네릭의 가장 간단하고 흔"
"한 용도는 타입 파라미터입니다."

#: src/generics.md:10
msgid ""
"A type parameter is specified as generic by the use of angle brackets and "
"upper [camel case](https://en.wikipedia.org/wiki/CamelCase): `<Aaa, "
"Bbb, ...>`. \"Generic type parameters\" are typically represented as `<T>`. "
"In Rust, \"generic\" also describes anything that accepts one or more "
"generic type parameters `<T>`. Any type specified as a generic type "
"parameter is generic, and everything else is concrete (non-generic)."
msgstr ""
"타입 파라미터는 꺾쇠 괄호와 대문자 [카멜 케이스](https://en.wikipedia.org/"
"wiki/CamelCase)를 사용하여 제네릭으로 지정됩니다: `<Aaa, Bbb, ...>`. \"제네"
"릭 타입 파라미터\"는 일반적으로 `<T>`로 표현됩니다. Rust에서 \"제네릭\"은 하"
"나 이상의 제네릭 타입 파라미터 `<T>`를 허용하는 모든 것을 설명하기도 합니다. "
"제네릭 타입 파라미터로 지정된 모든 타입은 제네릭이며, 그 외의 모든 것은 구체"
"적(비-제네릭)입니다."

#: src/generics.md:16
msgid ""
"For example, defining a _generic function_ named `foo` that takes an "
"argument `T` of any type:"
msgstr ""
"예를 들어, 모든 타입의 인자 `T`를 취하는 `foo`라는 이름의 _제네릭 함수_를 정"
"의하면 다음과 같습니다:"

#: src/generics.md:23
msgid ""
"Because `T` has been specified as a generic type parameter using `<T>`, it "
"is considered generic when used here as `(arg: T)`. This is the case even if "
"`T` has previously been defined as a `struct`."
msgstr ""
"`T`가 `<T>`를 사용하여 제네릭 타입 파라미터로 지정되었으므로, 여기서 `(arg: "
"T)`와 같이 사용될 때 제네릭으로 간주됩니다. 이는 `T`가 이전에 `struct`로 정의"
"되었더라도 마찬가지입니다."

#: src/generics.md:27
msgid "This example shows some of the syntax in action:"
msgstr "이 예제는 실제 작동하는 문법의 일부를 보여줍니다:"

#: src/generics.md:30
msgid "// A concrete type `A`.\n"
msgstr "// 구체적인 타입 `A`.\n"

#: src/generics.md:32
msgid ""
"// In defining the type `Single`, the first use of `A` is not preceded by "
"`<A>`.\n"
"// Therefore, `Single` is a concrete type, and `A` is defined as above.\n"
msgstr ""
"// `Single` 타입을 정의할 때, `A`의 첫 사용 앞에 `<A>`가 붙지 않습니다.\n"
"// 따라서 `Single`은 구체적인 타입이며, `A`는 위에서 정의된 대로입니다.\n"

#: src/generics.md:35
msgid "//            ^ Here is `Single`s first use of the type `A`.\n"
msgstr "//            ^ 여기서 `Single`이 처음으로 `A` 타입을 사용합니다.\n"

#: src/generics.md:37
msgid ""
"// Here, `<T>` precedes the first use of `T`, so `SingleGen` is a generic "
"type.\n"
"// Because the type parameter `T` is generic, it could be anything, "
"including\n"
"// the concrete type `A` defined at the top.\n"
msgstr ""
"// 여기서 `<T>`가 `T`의 첫 사용 앞에 오므로, `SingleGen`은 제네릭 타입입니"
"다.\n"
"// 타입 파라미터 `T`는 제네릭이므로, 상단에서 정의된 구체적인 타입 `A`를 포함"
"하여\n"
"// 무엇이든 될 수 있습니다.\n"

#: src/generics.md:44
msgid "// `Single` is concrete and explicitly takes `A`.\n"
msgstr "// `Single`은 구체적이며 명시적으로 `A`를 취합니다.\n"

#: src/generics.md:47
msgid ""
"// Create a variable `_char` of type `SingleGen<char>`\n"
"    // and give it the value `SingleGen('a')`.\n"
"    // Here, `SingleGen` has a type parameter explicitly specified.\n"
msgstr ""
"// `SingleGen<char>` 타입의 변수 `_char`를 생성하고\n"
"    // `SingleGen('a')` 값을 줍니다.\n"
"    // 여기서 `SingleGen`은 타입 파라미터가 명시적으로 지정되었습니다.\n"

#: src/generics.md:52
msgid "// `SingleGen` can also have a type parameter implicitly specified:\n"
msgstr "// `SingleGen`은 타입 파라미터를 암시적으로 지정할 수도 있습니다:\n"

#: src/generics.md:53
msgid "// Uses `A` defined at the top.\n"
msgstr "// 상단에서 정의된 `A`를 사용합니다.\n"

#: src/generics.md:54
msgid "// Uses `i32`.\n"
msgstr "// `i32`를 사용합니다.\n"

#: src/generics.md:55
msgid "// Uses `char`.\n"
msgstr "// `char`를 사용합니다.\n"

#: src/generics.md:61
msgid "[`structs`](custom_types/structs.md)"
msgstr "[`구조체`](custom_types/structs.md)"

#: src/generics/gen_fn.md:3
msgid ""
"The same set of rules can be applied to functions: a type `T` becomes "
"generic when preceded by `<T>`."
msgstr ""
"함수에도 동일한 규칙이 적용될 수 있습니다: 타입 `T` 앞에 `<T>`가 붙으면 제네"
"릭이 됩니다."

#: src/generics/gen_fn.md:6
msgid ""
"Using generic functions sometimes requires explicitly specifying type "
"parameters. This may be the case if the function is called where the return "
"type is generic, or if the compiler doesn't have enough information to infer "
"the necessary type parameters."
msgstr ""
"제네릭 함수를 사용할 때 때로는 타입 파라미터를 명시적으로 지정해야 할 필요가 "
"있습니다. 반환 타입이 제네릭인 곳에서 함수가 호출되거나, 컴파일러가 필요한 타"
"입 파라미터를 추론하기에 충분한 정보를 가지고 있지 않은 경우가 이에 해당할 "
"수 있습니다."

#: src/generics/gen_fn.md:11
msgid ""
"A function call with explicitly specified type parameters looks like: `fun::"
"<A, B, ...>()`."
msgstr ""
"명시적으로 지정된 타입 파라미터를 사용한 함수 호출은 다음과 같습니다: `fun::"
"<A, B, ...>()`."

#: src/generics/gen_fn.md:15
msgid "// Concrete type `A`.\n"
msgstr "// 구체적인 타입 `A`.\n"

#: src/generics/gen_fn.md:16
msgid "// Concrete type `S`.\n"
msgstr "// 구체적인 타입 `S`.\n"

#: src/generics/gen_fn.md:17
msgid "// Generic type `SGen`.\n"
msgstr "// 제네릭 타입 `SGen`.\n"

#: src/generics/gen_fn.md:18
msgid ""
"// The following functions all take ownership of the variable passed into\n"
"// them and immediately go out of scope, freeing the variable.\n"
msgstr ""
"// 다음 함수들은 모두 전달된 변수의 소유권을 가져가며,\n"
"// 즉시 스코프를 벗어나 변수를 해제합니다.\n"

#: src/generics/gen_fn.md:21
msgid ""
"// Define a function `reg_fn` that takes an argument `_s` of type `S`.\n"
"// This has no `<T>` so this is not a generic function.\n"
msgstr ""
"// `S` 타입의 인자 `_s`를 받는 `reg_fn` 함수를 정의합니다.\n"
"// `<T>`가 없으므로 이것은 제네릭 함수가 아닙니다.\n"

#: src/generics/gen_fn.md:25
msgid ""
"// Define a function `gen_spec_t` that takes an argument `_s` of type "
"`SGen<T>`.\n"
"// It has been explicitly given the type parameter `A`, but because `A` has "
"not\n"
"// been specified as a generic type parameter for `gen_spec_t`, it is not "
"generic.\n"
msgstr ""
"// `SGen<T>` 타입의 인자 `_s`를 받는 `gen_spec_t` 함수를 정의합니다.\n"
"// 타입 파라미터 `A`가 명시적으로 주어졌지만, `A`가 `gen_spec_t`의\n"
"// 제네릭 타입 파라미터로 지정되지 않았으므로, 이것은 제네릭이 아닙니다.\n"

#: src/generics/gen_fn.md:30
msgid ""
"// Define a function `gen_spec_i32` that takes an argument `_s` of type "
"`SGen<i32>`.\n"
"// It has been explicitly given the type parameter `i32`, which is a "
"specific type.\n"
"// Because `i32` is not a generic type, this function is also not generic.\n"
msgstr ""
"// `SGen<i32>` 타입의 인자 `_s`를 받는 `gen_spec_i32` 함수를 정의합니다.\n"
"// 구체적인 타입인 `i32`가 타입 파라미터로 명시적으로 주어졌습니다.\n"
"// `i32`는 제네릭 타입이 아니므로, 이 함수 또한 제네릭이 아닙니다.\n"

#: src/generics/gen_fn.md:35
msgid ""
"// Define a function `generic` that takes an argument `_s` of type "
"`SGen<T>`.\n"
"// Because `SGen<T>` is preceded by `<T>`, this function is generic over "
"`T`.\n"
msgstr ""
"// `SGen<T>` 타입의 인자 `_s`를 받는 `generic` 함수를 정의합니다.\n"
"// `SGen<T>` 앞에 `<T>`가 오기 때문에, 이 함수는 `T`에 대해 제네릭입니다.\n"

#: src/generics/gen_fn.md:41
msgid "// Using the non-generic functions\n"
msgstr "// 제네릭이 아닌 함수들 사용\n"

#: src/generics/gen_fn.md:42
msgid "// Concrete type.\n"
msgstr "// 구체적인 타입.\n"

#: src/generics/gen_fn.md:43
msgid "// Implicitly specified type parameter `A`.\n"
msgstr "// 암시적으로 지정된 타입 파라미터 `A`.\n"

#: src/generics/gen_fn.md:44
msgid "// Implicitly specified type parameter `i32`.\n"
msgstr "// 암시적으로 지정된 타입 파라미터 `i32`.\n"

#: src/generics/gen_fn.md:46
msgid "// Explicitly specified type parameter `char` to `generic()`.\n"
msgstr "// `generic()`에 명시적으로 지정된 타입 파라미터 `char`.\n"

#: src/generics/gen_fn.md:49
msgid "// Implicitly specified type parameter `char` to `generic()`.\n"
msgstr "// `generic()`에 암시적으로 지정된 타입 파라미터 `char`.\n"

#: src/generics/gen_fn.md:50
msgid "'c'"
msgstr "'c'"

#: src/generics/gen_fn.md:56
msgid "[functions](../fn.md) and [`struct`s](../custom_types/structs.md)"
msgstr "[함수](../fn.md)와 [`struct`](../custom_types/structs.md)"

#: src/generics/impl.md:3
msgid "Similar to functions, implementations require care to remain generic."
msgstr ""
"함수와 마찬가지로, 구현(implementation)도 제네릭을 유지하기 위해 주의가 필요"
"합니다."

#: src/generics/impl.md:6
msgid "// Concrete type `S`\n"
msgstr "// 구체적인 타입 `S`\n"

#: src/generics/impl.md:7
msgid "// Generic type `GenericVal`\n"
msgstr "// 제네릭 타입 `GenericVal`\n"

#: src/generics/impl.md:8
msgid "// impl of GenericVal where we explicitly specify type parameters:\n"
msgstr "// 타입 파라미터를 명시적으로 지정한 GenericVal의 구현:\n"

#: src/generics/impl.md:10
msgid "// Specify `f32`\n"
msgstr "// `f32` 지정\n"

#: src/generics/impl.md:11
msgid "// Specify `S` as defined above\n"
msgstr "// 위에서 정의한 `S` 지정\n"

#: src/generics/impl.md:12
msgid "// `<T>` Must precede the type to remain generic\n"
msgstr "// 제네릭을 유지하려면 `<T>`가 타입 앞에 와야 합니다\n"

#: src/generics/impl.md:25
msgid "// impl of Val\n"
msgstr "// Val 구현\n"

#: src/generics/impl.md:32
msgid "// impl of GenVal for a generic type `T`\n"
msgstr "// 제네릭 타입 `T`에 대한 GenVal 구현\n"

#: src/generics/impl.md:50
msgid ""
"[functions returning references](../scope/lifetime/fn.md), [`impl`](../fn/"
"methods.md), and [`struct`](../custom_types/structs.md)"
msgstr ""
"[참조를 반환하는 함수](../scope/lifetime/fn.md), [`impl`](../fn/methods.md), "
"그리고 [`struct`](../custom_types/structs.md)"

#: src/generics/gen_trait.md:3
msgid ""
"Of course `trait`s can also be generic. Here we define one which "
"reimplements the `Drop` `trait` as a generic method to `drop` itself and an "
"input."
msgstr ""
"물론 `trait`도 제네릭일 수 있습니다. 여기서는 `Drop` `트레이트`를 자신과 입력"
"을 `drop`하는 제네릭 메서드로 재구현한 것을 정의합니다."

#: src/generics/gen_trait.md:7
msgid "// Non-copyable types.\n"
msgstr "// 복사 불가능한 타입.\n"

#: src/generics/gen_trait.md:10
msgid "// A trait generic over `T`.\n"
msgstr "// `T`에 대해 제네릭인 트레이트.\n"

#: src/generics/gen_trait.md:13
msgid ""
"// Define a method on the caller type which takes an\n"
"    // additional single parameter `T` and does nothing with it.\n"
msgstr ""
"// 호출자 타입에 대해 추가적인 단일 파라미터 `T`를 취하고\n"
"// 아무것도 하지 않는 메서드를 정의합니다.\n"

#: src/generics/gen_trait.md:17
msgid ""
"// Implement `DoubleDrop<T>` for any generic parameter `T` and\n"
"// caller `U`.\n"
msgstr ""
"// 임의의 제네릭 파라미터 `T`와 호출자 `U`에 대해\n"
"// `DoubleDrop<T>`를 구현합니다.\n"

#: src/generics/gen_trait.md:21
msgid ""
"// This method takes ownership of both passed arguments,\n"
"    // deallocating both.\n"
msgstr ""
"// 이 메서드는 전달된 두 인자의 소유권을 가져와\n"
"// 둘 다 해제합니다.\n"

#: src/generics/gen_trait.md:30
msgid "// Deallocate `empty` and `null`.\n"
msgstr "// `empty`와 `null`을 해제합니다.\n"

#: src/generics/gen_trait.md:33
msgid ""
"//empty;\n"
"    //null;\n"
"    // ^ TODO: Try uncommenting these lines.\n"
msgstr ""
"//empty;\n"
"    //null;\n"
"    // ^ TODO: 이 줄들의 주석을 해제해 보세요.\n"

#: src/generics/gen_trait.md:41
msgid ""
"[`Drop`](https://doc.rust-lang.org/std/ops/trait.Drop.html), [`struct`](../"
"custom_types/structs.md), and [`trait`](../trait.md)"
msgstr ""
"[`Drop`](https://doc.rust-lang.org/std/ops/trait.Drop.html), [`구조체`](../"
"custom_types/structs.md), 그리고 [`트레이트`](../trait.md)"

#: src/generics/bounds.md:3
msgid ""
"When working with generics, the type parameters often must use traits as "
"_bounds_ to stipulate what functionality a type implements. For example, the "
"following example uses the trait `Display` to print and so it requires `T` "
"to be bound by `Display`; that is, `T` _must_ implement `Display`."
msgstr ""
"제네릭을 사용할 때, 타입 파라미터는 종종 타입이 구현해야 하는 기능을 규정하"
"기 위해 트레이트를 _바운드(bounds)_로 사용해야 합니다. 예를 들어, 다음 예제"
"는 `Display` 트레이트를 사용하여 출력하므로 `T`가 `Display`에 바운드되어야 합"
"니다. 즉, `T`는 반드시 `Display`를 구현해야 합니다."

#: src/generics/bounds.md:9
msgid ""
"// Define a function `printer` that takes a generic type `T` which\n"
"// must implement trait `Display`.\n"
msgstr ""
"// 제네릭 타입 `T`를 받는 함수 `printer`를 정의합니다.\n"
"// `T`는 반드시 `Display` 트레이트를 구현해야 합니다.\n"

#: src/generics/bounds.md:16
msgid ""
"Bounding restricts the generic to types that conform to the bounds. That is:"
msgstr "바운딩은 제네릭을 해당 바운드를 준수하는 타입들로 제한합니다. 즉:"

#: src/generics/bounds.md:20
msgid ""
"// Error! `Vec<T>` does not implement `Display`. This\n"
"// specialization will fail.\n"
msgstr ""
"// 에러! `Vec<T>`는 `Display`를 구현하지 않습니다.\n"
"// 이 특수화는 실패할 것입니다.\n"

#: src/generics/bounds.md:26
msgid ""
"Another effect of bounding is that generic instances are allowed to access "
"the [methods](../fn/methods.md) of traits specified in the bounds. For "
"example:"
msgstr ""
"바운딩의 또 다른 효과는 제네릭 인스턴스가 바운드에 지정된 트레이트의 [메서드]"
"(../fn/methods.md)에 접근할 수 있게 된다는 것입니다. 예를 들어:"

#: src/generics/bounds.md:30
msgid "// A trait which implements the print marker: `{:?}`.\n"
msgstr "// 출력 마커 `{:?}`를 구현하는 트레이트입니다.\n"

#: src/generics/bounds.md:45
msgid ""
"// The generic `T` must implement `Debug`. Regardless\n"
"// of the type, this will work properly.\n"
msgstr ""
"// 제네릭 `T`는 반드시 `Debug`를 구현해야 합니다.\n"
"// 타입에 상관없이 이는 제대로 작동할 것입니다.\n"

#: src/generics/bounds.md:51
msgid ""
"// `T` must implement `HasArea`. Any type which meets\n"
"// the bound can access `HasArea`'s function `area`.\n"
msgstr ""
"// `T`는 반드시 `HasArea`를 구현해야 합니다. 바운드를 충족하는\n"
"// 모든 타입은 `HasArea`의 `area` 함수에 접근할 수 있습니다.\n"

#: src/generics/bounds.md:61
msgid "\"Area: {}\""
msgstr "\"면적: {}\""

#: src/generics/bounds.md:63
msgid ""
"//print_debug(&_triangle);\n"
"    //println!(\"Area: {}\", area(&_triangle));\n"
"    // ^ TODO: Try uncommenting these.\n"
"    // | Error: Does not implement either `Debug` or `HasArea`.\n"
msgstr ""
"//print_debug(&_triangle);\n"
"//println!(\"면적: {}\", area(&_triangle));\n"
"// ^ TODO: 이 줄들의 주석을 해제해 보세요.\n"
"// | 에러: `Debug`나 `HasArea` 중 어느 것도 구현하지 않았습니다.\n"

#: src/generics/bounds.md:70
msgid ""
"As an additional note, [`where`](../generics/where.md) clauses can also be "
"used to apply bounds in some cases to be more expressive."
msgstr ""
"추가적으로, 어떤 경우에는 [`where`](../generics/where.md) 절을 사용하여 바운"
"드를 더 표현력 있게 적용할 수도 있습니다."

#: src/generics/bounds.md:75
msgid ""
"[`std::fmt`](../hello/print.md), [`struct`s](../custom_types/structs.md), "
"and [`trait`s](../trait.md)"
msgstr ""
"[`std::fmt`](../hello/print.md), [`struct`](../custom_types/structs.md), 그리"
"고 [`trait`](../trait.md)"

#: src/generics/bounds/testcase_empty.md:3
msgid ""
"A consequence of how bounds work is that even if a `trait` doesn't include "
"any functionality, you can still use it as a bound. `Eq` and `Copy` are "
"examples of such `trait`s from the `std` library."
msgstr ""
"바운드가 작동하는 방식의 결과로, `trait`가 아무런 기능을 포함하지 않더라도 여"
"전히 바운드로 사용할 수 있습니다. `std` 라이브러리의 `Eq`와 `Copy`가 그러한 "
"`trait`의 예입니다."

#: src/generics/bounds/testcase_empty.md:17
msgid ""
"// These functions are only valid for types which implement these\n"
"// traits. The fact that the traits are empty is irrelevant.\n"
msgstr ""
"// 이 함수들은 이 트레이트들을 구현하는 타입에 대해서만 유효합니다.\n"
"// 트레이트가 비어 있다는 사실은 무관합니다.\n"

#: src/generics/bounds/testcase_empty.md:20
msgid "\"red\""
msgstr "\"빨강\""

#: src/generics/bounds/testcase_empty.md:21
msgid "\"blue\""
msgstr "\"파랑\""

#: src/generics/bounds/testcase_empty.md:28
msgid ""
"// `red()` won't work on a blue jay nor vice versa\n"
"    // because of the bounds.\n"
msgstr ""
"// 바운드 때문에 `red()`는 blue jay(파랑 어치)에 대해 작동하지 않으며\n"
"// 그 반대도 마찬가지입니다.\n"

#: src/generics/bounds/testcase_empty.md:30
msgid "\"A cardinal is {}\""
msgstr "\"홍관조(cardinal)는 {}입니다\""

#: src/generics/bounds/testcase_empty.md:31
msgid "\"A blue jay is {}\""
msgstr "\"파랑 어치(blue jay)는 {}입니다\""

#: src/generics/bounds/testcase_empty.md:32
msgid ""
"//println!(\"A turkey is {}\", red(&_turkey));\n"
"    // ^ TODO: Try uncommenting this line.\n"
msgstr ""
"//println!(\"칠면조는 {}\", red(&_turkey));\n"
"// ^ TODO: 이 줄의 주석을 해제해 보세요.\n"

#: src/generics/bounds/testcase_empty.md:39
msgid ""
"[`std::cmp::Eq`](https://doc.rust-lang.org/std/cmp/trait.Eq.html), "
"[`std::marker::Copy`](https://doc.rust-lang.org/std/marker/trait.Copy.html), "
"and [`trait`s](../../trait.md)"
msgstr ""
"[`std::cmp::Eq`](https://doc.rust-lang.org/std/cmp/trait.Eq.html), "
"[`std::marker::Copy`](https://doc.rust-lang.org/std/marker/trait.Copy.html), "
"그리고 [`trait`](../../trait.md)"

#: src/generics/multi_bounds.md:3
msgid ""
"Multiple bounds for a single type can be applied with a `+`. Like normal, "
"different types are separated with `,`."
msgstr ""
"단일 타입에 대해 `+`를 사용하여 다중 바운드를 적용할 수 있습니다. 평소와 마찬"
"가지로, 서로 다른 타입은 `,`로 구분됩니다."

#: src/generics/multi_bounds.md:10
msgid "\"Debug: `{:?}`\""
msgstr "\"디버그: `{:?}`\""

#: src/generics/multi_bounds.md:11
msgid "\"Display: `{}`\""
msgstr "\"디스플레이: `{}`\""

#: src/generics/multi_bounds.md:15
msgid "\"t: `{:?}`\""
msgstr "\"t: `{:?}`\""

#: src/generics/multi_bounds.md:16
msgid "\"u: `{:?}`\""
msgstr "\"u: `{:?}`\""

#: src/generics/multi_bounds.md:20
msgid "\"words\""
msgstr "\"단어들\""

#: src/generics/multi_bounds.md:25
msgid ""
"//compare_prints(&array);\n"
"    // TODO ^ Try uncommenting this.\n"
msgstr ""
"//compare_prints(&array);\n"
"// TODO ^ 주석을 해제해 보세요.\n"

#: src/generics/multi_bounds.md:34
msgid "[`std::fmt`](../hello/print.md) and [`trait`s](../trait.md)"
msgstr "[`std::fmt`](../hello/print.md)와 [`trait`](../trait.md)"

#: src/generics/where.md:3
msgid ""
"A bound can also be expressed using a `where` clause immediately before the "
"opening `{`, rather than at the type's first mention. Additionally, `where` "
"clauses can apply bounds to arbitrary types, rather than just to type "
"parameters."
msgstr ""
"바운드는 타입이 처음 언급되는 곳이 아닌, 여는 중괄호 `{` 직전에 `where` 절을 "
"사용하여 표현할 수도 있습니다. 또한, `where` 절은 타입 파라미터뿐만 아니라 임"
"의의 타입에도 바운드를 적용할 수 있습니다."

#: src/generics/where.md:8
msgid "Some cases that a `where` clause is useful:"
msgstr "`where` 절이 유용한 몇 가지 경우:"

#: src/generics/where.md:10
msgid "When specifying generic types and bounds separately is clearer:"
msgstr "제네릭 타입과 바운드를 따로 명시하는 것이 더 명확할 때:"

#: src/generics/where.md:14
msgid "// Expressing bounds with a `where` clause\n"
msgstr "// `where` 절로 바운드 표현하기\n"

#: src/generics/where.md:21
msgid ""
"When using a `where` clause is more expressive than using normal syntax. The "
"`impl` in this example cannot be directly expressed without a `where` clause:"
msgstr ""
"`where` 절을 사용하는 것이 일반 구문을 사용하는 것보다 더 표현력이 좋을 때. "
"이 예제의 `impl`은 `where` 절 없이는 직접 표현할 수 없습니다:"

#: src/generics/where.md:30
msgid ""
"// Because we would otherwise have to express this as `T: Debug` or\n"
"// use another method of indirect approach, this requires a `where` clause:\n"
msgstr ""
"// 그렇지 않으면 `T: Debug`로 표현하거나\n"
"// 다른 간접적인 방법을 사용해야 하므로, 여기에는 `where` 절이 필요합니다:\n"

#: src/generics/where.md:35
msgid ""
"// We want `Option<T>: Debug` as our bound because that is what's\n"
"    // being printed. Doing otherwise would be using the wrong bound.\n"
msgstr ""
"// 출력되는 것이 `Option<T>`이므로, 바운드로 `Option<T>: Debug`를 원합니다.\n"
"    // 다르게 하면 잘못된 바운드를 사용하는 셈이 됩니다.\n"

#: src/generics/where.md:51
msgid ""
"[RFC](https://github.com/rust-lang/rfcs/blob/master/text/0135-where.md), "
"[`struct`](../custom_types/structs.md), and [`trait`](../trait.md)"
msgstr ""
"[RFC](https://github.com/rust-lang/rfcs/blob/master/text/0135-where.md), "
"[`struct`](../custom_types/structs.md), 그리고 [`trait`](../trait.md)"

#: src/generics/new_types.md:3
msgid ""
"The `newtype` idiom gives compile time guarantees that the right type of "
"value is supplied to a program."
msgstr ""
"`newtype` 관용구는 프로그램에 올바른 타입의 값이 제공됨을 컴파일 타임에 보장"
"해 줍니다."

#: src/generics/new_types.md:6
msgid ""
"For example, an age verification function that checks age in years, _must_ "
"be given a value of type `Years`."
msgstr ""
"예를 들어, 나이를 연 단위로 확인하는 나이 검증 함수는 반드시 `Years` 타입의 "
"값을 받아야 합니다."

#: src/generics/new_types.md:21
msgid "/// truncates partial years\n"
msgstr "/// 부분적인 연도는 버립니다\n"

#: src/generics/new_types.md:34 src/generics/new_types.md:35
msgid "\"Is an adult? {}\""
msgstr "\"성인입니까? {}\""

#: src/generics/new_types.md:36
msgid "// println!(\"Is an adult? {}\", is_adult(&age_days));\n"
msgstr "// println!(\"성인입니까? {}\", is_adult(&age_days));\n"

#: src/generics/new_types.md:40
msgid ""
"Uncomment the last print statement to observe that the type supplied must be "
"`Years`."
msgstr ""
"마지막 출력문의 주석을 해제하여 제공되는 타입이 반드시 `Years`여야 함을 관찰"
"해 보세요."

#: src/generics/new_types.md:42
msgid ""
"To obtain the `newtype`'s value as the base type, you may use the tuple or "
"destructuring syntax like so:"
msgstr ""
"`newtype`의 값을 기본 타입으로 얻으려면, 다음과 같이 튜플 또는 구조 분해 문법"
"을 사용할 수 있습니다:"

#: src/generics/new_types.md:49
msgid "// Tuple\n"
msgstr "// 튜플\n"

#: src/generics/new_types.md:50
msgid "// Destructuring\n"
msgstr "// 구조 분해\n"

#: src/generics/new_types.md:56
msgid "[`structs`](../custom_types/structs.md)"
msgstr "[`structs`](../custom_types/structs.md)"

#: src/generics/assoc_items.md:3
msgid ""
"\"Associated Items\" refers to a set of rules pertaining to [`item`](https://"
"doc.rust-lang.org/reference/items.html)s of various types. It is an "
"extension to `trait` generics, and allows `trait`s to internally define new "
"items."
msgstr ""
"\"연관 아이템(Associated Items)\"은 다양한 타입의 [`아이템`](https://"
"doc.rust-lang.org/reference/items.html)에 관련된 규칙 집합을 말합니다. 이는 "
"`trait` 제네릭의 확장이며, `trait`가 내부적으로 새로운 아이템을 정의할 수 있"
"게 해줍니다."

#: src/generics/assoc_items.md:7
msgid ""
"One such item is called an _associated type_, providing simpler usage "
"patterns when the `trait` is generic over its container type."
msgstr ""
"그러한 아이템 중 하나가 _연관 타입(associated type)_이며, `trait`가 컨테이너 "
"타입에 대해 제네릭일 때 더 간단한 사용 패턴을 제공합니다."

#: src/generics/assoc_items.md:12
msgid ""
"[RFC](https://github.com/rust-lang/rfcs/blob/master/text/0195-associated-"
"items.md)"
msgstr ""
"[RFC](https://github.com/rust-lang/rfcs/blob/master/text/0195-associated-"
"items.md)"

#: src/generics/assoc_items/the_problem.md:3
msgid ""
"A `trait` that is generic over its container type has type specification "
"requirements - users of the `trait` _must_ specify all of its generic types."
msgstr ""
"컨테이너 타입에 대해 제네릭인 `trait`는 타입 명시 요구사항을 가집니다 - "
"`trait` 사용자는 모든 제네릭 타입을 _반드시_ 명시해야 합니다."

#: src/generics/assoc_items/the_problem.md:6
msgid ""
"In the example below, the `Contains` `trait` allows the use of the generic "
"types `A` and `B`. The trait is then implemented for the `Container` type, "
"specifying `i32` for `A` and `B` so that it can be used with `fn "
"difference()`."
msgstr ""
"아래 예제에서 `Contains` `trait`는 제네릭 타입 `A`와 `B`의 사용을 허용합니"
"다. 그 후 이 트레이트는 `Container` 타입에 대해 구현되는데, `fn difference()`"
"와 함께 사용될 수 있도록 `A`와 `B`에 대해 `i32`를 지정합니다."

#: src/generics/assoc_items/the_problem.md:10
msgid ""
"Because `Contains` is generic, we are forced to explicitly state _all_ of "
"the generic types for `fn difference()`. In practice, we want a way to "
"express that `A` and `B` are determined by the _input_ `C`. As you will see "
"in the next section, associated types provide exactly that capability."
msgstr ""
"`Contains`가 제네릭이기 때문에, 우리는 `fn difference()`에 대해 _모든_ 제네"
"릭 타입을 명시적으로 나열해야만 합니다. 실제로는 `A`와 `B`가 _입력_ `C`에 의"
"해 결정된다는 것을 표현하고 싶습니다. 다음 섹션에서 보게 되겠지만, 연관 타입"
"은 정확히 그런 기능을 제공합니다."

#: src/generics/assoc_items/the_problem.md:17
#: src/generics/assoc_items/types.md:36
msgid ""
"// A trait which checks if 2 items are stored inside of container.\n"
"// Also retrieves first or last value.\n"
msgstr ""
"// 컨테이너 안에 2개의 아이템이 저장되어 있는지 확인하는 트레이트입니다.\n"
"// 또한 첫 번째 또는 마지막 값을 가져옵니다.\n"

#: src/generics/assoc_items/the_problem.md:21
msgid "// Explicitly requires `A` and `B`.\n"
msgstr "// 명시적으로 `A`와 `B`를 요구합니다.\n"

#: src/generics/assoc_items/the_problem.md:22
#: src/generics/assoc_items/the_problem.md:23
msgid "// Doesn't explicitly require `A` or `B`.\n"
msgstr "// 명시적으로 `A`나 `B`를 요구하지 않습니다.\n"

#: src/generics/assoc_items/the_problem.md:27
msgid "// True if the numbers stored are equal.\n"
msgstr "// 저장된 숫자들이 같으면 참입니다.\n"

#: src/generics/assoc_items/the_problem.md:32
#: src/generics/assoc_items/types.md:60
msgid "// Grab the first number.\n"
msgstr "// 첫 번째 숫자를 가져옵니다.\n"

#: src/generics/assoc_items/the_problem.md:35
#: src/generics/assoc_items/types.md:63
msgid "// Grab the last number.\n"
msgstr "// 마지막 숫자를 가져옵니다.\n"

#: src/generics/assoc_items/the_problem.md:38
msgid ""
"// `C` contains `A` and `B`. In light of that, having to express `A` and\n"
"// `B` again is a nuisance.\n"
msgstr ""
"// `C`는 `A`와 `B`를 포함합니다. 이를 고려할 때, `A`와 `B`를\n"
"// 다시 표현해야 하는 것은 성가신 일입니다.\n"

#: src/generics/assoc_items/the_problem.md:52
#: src/generics/assoc_items/types.md:77
msgid "\"Does container contain {} and {}: {}\""
msgstr "\"컨테이너가 {}와 {}를 포함합니까: {}\""

#: src/generics/assoc_items/the_problem.md:55
#: src/generics/assoc_items/types.md:80
msgid "\"First number: {}\""
msgstr "\"첫 번째 숫자: {}\""

#: src/generics/assoc_items/the_problem.md:56
#: src/generics/assoc_items/types.md:81
msgid "\"Last number: {}\""
msgstr "\"마지막 숫자: {}\""

#: src/generics/assoc_items/the_problem.md:58
#: src/generics/assoc_items/types.md:83
msgid "\"The difference is: {}\""
msgstr "\"차이는: {}\""

#: src/generics/assoc_items/the_problem.md:64
msgid ""
"[`struct`s](../../custom_types/structs.md), and [`trait`s](../../trait.md)"
msgstr ""
"[`struct`](../../custom_types/structs.md), 그리고 [`trait`](../../trait.md)"

#: src/generics/assoc_items/types.md:3
msgid ""
"The use of \"Associated types\" improves the overall readability of code by "
"moving inner types locally into a trait as _output_ types. Syntax for the "
"`trait` definition is as follows:"
msgstr ""
"\"연관 타입\"을 사용하면 내부 타입을 트레이트 내의 _출력_ 타입으로 지역적으"
"로 이동시켜 코드의 전반적인 가독성을 향상시킬 수 있습니다. `trait` 정의를 위"
"한 구문은 다음과 같습니다:"

#: src/generics/assoc_items/types.md:8
msgid ""
"// `A` and `B` are defined in the trait via the `type` keyword.\n"
"// (Note: `type` in this context is different from `type` when used for\n"
"// aliases).\n"
msgstr ""
"// `A`와 `B`는 `type` 키워드를 통해 트레이트 내에 정의됩니다.\n"
"// (참고: 이 문맥에서의 `type`은 별칭(aliases)에 사용되는 `type`과는 다릅니"
"다).\n"

#: src/generics/assoc_items/types.md:15
msgid "// Updated syntax to refer to these new types generically.\n"
msgstr ""
"// 이 새로운 타입들을 제네릭하게 참조하기 위해 업데이트된 구문입니다.\n"

#: src/generics/assoc_items/types.md:20
msgid ""
"Note that functions that use the `trait` `Contains` are no longer required "
"to express `A` or `B` at all:"
msgstr ""
"`Contains` `trait`를 사용하는 함수들은 더 이상 `A`나 `B`를 표현할 필요가 없다"
"는 점에 유의하세요:"

#: src/generics/assoc_items/types.md:24
msgid "// Without using associated types\n"
msgstr "// 연관 타입을 사용하지 않는 경우\n"

#: src/generics/assoc_items/types.md:27
msgid "// Using associated types\n"
msgstr "// 연관 타입 사용\n"

#: src/generics/assoc_items/types.md:32
msgid ""
"Let's rewrite the example from the previous section using associated types:"
msgstr "이전 섹션의 예제를 연관 타입을 사용하여 다시 작성해 봅시다:"

#: src/generics/assoc_items/types.md:40
msgid "// Define generic types here which methods will be able to utilize.\n"
msgstr "// 여기서 제네릭 타입을 정의하여 메서드들이 활용할 수 있게 합니다.\n"

#: src/generics/assoc_items/types.md:50
msgid ""
"// Specify what types `A` and `B` are. If the `input` type\n"
"    // is `Container(i32, i32)`, the `output` types are determined\n"
"    // as `i32` and `i32`.\n"
msgstr ""
"// `A`와 `B`가 어떤 타입인지 명시합니다. 만약 `input` 타입이\n"
"    // `Container(i32, i32)`라면, `output` 타입은 `i32`와 `i32`로\n"
"    // 결정됩니다.\n"

#: src/generics/assoc_items/types.md:56
msgid "// `&Self::A` and `&Self::B` are also valid here.\n"
msgstr "// `&Self::A`와 `&Self::B` 또한 여기서 유효합니다.\n"

#: src/generics/phantom.md:3
msgid ""
"A phantom type parameter is one that doesn't show up at runtime, but is "
"checked statically (and only) at compile time."
msgstr ""
"팬텀 타입 파라미터(phantom type parameter)는 런타임에는 나타나지 않지만, 컴파"
"일 타임에만 정적으로 검사되는 파라미터입니다."

#: src/generics/phantom.md:6
msgid ""
"Data types can use extra generic type parameters to act as markers or to "
"perform type checking at compile time. These extra parameters hold no "
"storage values, and have no runtime behavior."
msgstr ""
"데이터 타입은 추가적인 제네릭 타입 파라미터를 사용하여 마커 역할을 하거나 컴"
"파일 타임에 타입 검사를 수행할 수 있습니다. 이러한 추가 파라미터는 저장 값을 "
"가지지 않으며, 런타임 동작도 없습니다."

#: src/generics/phantom.md:10
msgid ""
"In the following example, we combine [std::marker::PhantomData](https://"
"doc.rust-lang.org/std/marker/struct.PhantomData.html) with the phantom type "
"parameter concept to create tuples containing different data types."
msgstr ""
"다음 예제에서는 [std::marker::PhantomData](https://doc.rust-lang.org/std/"
"marker/struct.PhantomData.html)와 팬텀 타입 파라미터 개념을 결합하여 서로 다"
"른 데이터 타입을 포함하는 튜플을 생성합니다."

#: src/generics/phantom.md:16
msgid ""
"// A phantom tuple struct which is generic over `A` with hidden parameter "
"`B`.\n"
msgstr ""
"// 숨겨진 파라미터 `B`를 가지며 `A`에 대해 제네릭인 팬텀 튜플 구조체.\n"

#: src/generics/phantom.md:18 src/generics/phantom.md:22
msgid "// Allow equality test for this type.\n"
msgstr "// 이 타입에 대한 동등성 테스트를 허용합니다.\n"

#: src/generics/phantom.md:20
msgid ""
"// A phantom type struct which is generic over `A` with hidden parameter "
"`B`.\n"
msgstr ""
"// 숨겨진 파라미터 `B`를 가지며 `A`에 대해 제네릭인 팬텀 타입 구조체.\n"

#: src/generics/phantom.md:24
msgid ""
"// Note: Storage is allocated for generic type `A`, but not for `B`.\n"
"//       Therefore, `B` cannot be used in computations.\n"
msgstr ""
"// 주의: 제네릭 타입 `A`에는 저장 공간이 할당되지만, `B`에는 할당되지 않습니"
"다.\n"
"//       따라서 `B`는 연산에 사용될 수 없습니다.\n"

#: src/generics/phantom.md:29
msgid ""
"// Here, `f32` and `f64` are the hidden parameters.\n"
"    // PhantomTuple type specified as `<char, f32>`.\n"
msgstr ""
"// 여기서 `f32`와 `f64`는 숨겨진 파라미터입니다.\n"
"    // PhantomTuple 타입이 `<char, f32>`로 지정되었습니다.\n"

#: src/generics/phantom.md:31 src/generics/phantom.md:33
#: src/generics/phantom.md:37 src/generics/phantom.md:42
#: src/scope/borrow/ref.md:12
msgid "'Q'"
msgstr "'Q'"

#: src/generics/phantom.md:32
msgid "// PhantomTuple type specified as `<char, f64>`.\n"
msgstr "// PhantomTuple 타입이 `<char, f64>`로 지정되었습니다.\n"

#: src/generics/phantom.md:35
msgid "// Type specified as `<char, f32>`.\n"
msgstr "// 타입이 `<char, f32>`로 지정되었습니다.\n"

#: src/generics/phantom.md:40
msgid "// Type specified as `<char, f64>`.\n"
msgstr "// 타입이 `<char, f64>`로 지정되었습니다.\n"

#: src/generics/phantom.md:46
msgid ""
"// Compile-time Error! Type mismatch so these cannot be compared:\n"
"    // println!(\"_tuple1 == _tuple2 yields: {}\",\n"
"    //           _tuple1 == _tuple2);\n"
msgstr ""
"// 컴파일 타임 에러! 타입 불일치로 인해 비교할 수 없습니다:\n"
"    // println!(\"_tuple1 == _tuple2 yields: {}\",\n"
"    //           _tuple1 == _tuple2);\n"

#: src/generics/phantom.md:50
msgid ""
"// Compile-time Error! Type mismatch so these cannot be compared:\n"
"    // println!(\"_struct1 == _struct2 yields: {}\",\n"
"    //           _struct1 == _struct2);\n"
msgstr ""
"// 컴파일 타임 에러! 타입 불일치로 인해 비교할 수 없습니다:\n"
"// println!(\"_struct1 == _struct2 yields: {}\",\n"
"//           _struct1 == _struct2);\n"

#: src/generics/phantom.md:58
msgid ""
"[Derive](../trait/derive.md), [struct](../custom_types/structs.md), and "
"[tuple](../primitives/tuples.html)."
msgstr ""
"[Derive](../trait/derive.md), [구조체](../custom_types/structs.md), 그리고 "
"[튜플](../primitives/tuples.html)."

#: src/generics/phantom/testcase_units.md:3
msgid ""
"A useful method of unit conversions can be examined by implementing `Add` "
"with a phantom type parameter. The `Add` `trait` is examined below:"
msgstr ""
"팬텀 타입 파라미터로 `Add`를 구현하여 유용한 단위 변환 방법을 살펴볼 수 있습"
"니다. `Add` `트레이트`는 아래에서 살펴봅니다:"

#: src/generics/phantom/testcase_units.md:7
msgid ""
"// This construction would impose: `Self + RHS = Output`\n"
"// where RHS defaults to Self if not specified in the implementation.\n"
msgstr ""
"// 이 구조는 다음을 부과합니다: `Self + RHS = Output`\n"
"// 구현에서 지정되지 않은 경우 RHS는 기본적으로 Self입니다.\n"

#: src/generics/phantom/testcase_units.md:14
msgid "// `Output` must be `T<U>` so that `T<U> + T<U> = T<U>`.\n"
msgstr ""
"// `Output`은 `T<U> + T<U> = T<U>`가 되도록 반드시 `T<U>`여야 합니다.\n"

#: src/generics/phantom/testcase_units.md:22
msgid "The whole implementation:"
msgstr "전체 구현:"

#: src/generics/phantom/testcase_units.md:27
msgid "/// Create void enumerations to define unit types.\n"
msgstr "/// 단위 타입을 정의하기 위해 빈 열거형을 생성합니다.\n"

#: src/generics/phantom/testcase_units.md:33
msgid ""
"/// `Length` is a type with phantom type parameter `Unit`,\n"
"/// and is not generic over the length type (that is `f64`).\n"
"///\n"
"/// `f64` already implements the `Clone` and `Copy` traits.\n"
msgstr ""
"/// `Length`는 팬텀 타입 파라미터 `Unit`을 가지는 타입이며,\n"
"/// 길이 타입(`f64`)에 대해서는 제네릭이 아닙니다.\n"
"///\n"
"/// `f64`는 이미 `Clone`과 `Copy` 트레이트를 구현하고 있습니다.\n"

#: src/generics/phantom/testcase_units.md:40
msgid "/// The `Add` trait defines the behavior of the `+` operator.\n"
msgstr "/// `Add` 트레이트는 `+` 연산자의 동작을 정의합니다.\n"

#: src/generics/phantom/testcase_units.md:45
msgid "// add() returns a new `Length` struct containing the sum.\n"
msgstr "// add()는 합계를 포함하는 새로운 `Length` 구조체를 반환합니다.\n"

#: src/generics/phantom/testcase_units.md:47
msgid "// `+` calls the `Add` implementation for `f64`.\n"
msgstr "// `+`는 `f64`에 대한 `Add` 구현을 호출합니다.\n"

#: src/generics/phantom/testcase_units.md:53
msgid "// Specifies `one_foot` to have phantom type parameter `Inch`.\n"
msgstr "// `one_foot`가 팬텀 타입 파라미터 `Inch`를 가지도록 지정합니다.\n"

#: src/generics/phantom/testcase_units.md:55
msgid "// `one_meter` has phantom type parameter `Mm`.\n"
msgstr "// `one_meter`는 팬텀 타입 파라미터 `Mm`을 가집니다.\n"

#: src/generics/phantom/testcase_units.md:58
msgid ""
"// `+` calls the `add()` method we implemented for `Length<Unit>`.\n"
"    //\n"
"    // Since `Length` implements `Copy`, `add()` does not consume\n"
"    // `one_foot` and `one_meter` but copies them into `self` and `rhs`.\n"
msgstr ""
"// `+`는 우리가 `Length<Unit>`에 대해 구현한 `add()` 메서드를 호출합니다.\n"
"//\n"
"// `Length`가 `Copy`를 구현하므로, `add()`는 `one_foot`과 `one_meter`를\n"
"// 소비(consume)하지 않고 `self`와 `rhs`로 복사합니다.\n"

#: src/generics/phantom/testcase_units.md:65
msgid "// Addition works.\n"
msgstr "// 덧셈이 작동합니다.\n"

#: src/generics/phantom/testcase_units.md:66
msgid "\"one foot + one_foot = {:?} in\""
msgstr "\"1피트 + 1피트 = {:?} 인치\""

#: src/generics/phantom/testcase_units.md:67
msgid "\"one meter + one_meter = {:?} mm\""
msgstr "\"1미터 + 1미터 = {:?} mm\""

#: src/generics/phantom/testcase_units.md:69
msgid ""
"// Nonsensical operations fail as they should:\n"
"    // Compile-time Error: type mismatch.\n"
"    //let one_feter = one_foot + one_meter;\n"
msgstr ""
"// 말도 안 되는 연산은 실패합니다:\n"
"// 컴파일 타임 에러: 타입 불일치.\n"
"// let one_feter = one_foot + one_meter;\n"

#: src/generics/phantom/testcase_units.md:77
msgid ""
"[Borrowing (`&`)](../../scope/borrow.md), [Bounds (`X: Y`)](../../generics/"
"bounds.md), [enum](../../custom_types/enum.md), [impl & self](../../fn/"
"methods.md), [Overloading](../../trait/ops.md), [ref](../../scope/borrow/"
"ref.md), [Traits (`X for Y`)](../../trait.md), and [TupleStructs](../../"
"custom_types/structs.md)."
msgstr ""
"[빌림(Borrowing) (`&`)](../../scope/borrow.md), [바운드(Bounds) (`X: Y`)]"
"(../../generics/bounds.md), [열거형(enum)](../../custom_types/enum.md), "
"[impl & self](../../fn/methods.md), [오버로딩(Overloading)](../../trait/"
"ops.md), [ref](../../scope/borrow/ref.md), [트레이트(Traits) (`X for Y`)]"
"(../../trait.md), 그리고 [튜플 구조체(TupleStructs)](../../custom_types/"
"structs.md)."

#: src/scope.md:3
msgid ""
"Scopes play an important part in ownership, borrowing, and lifetimes. That "
"is, they indicate to the compiler when borrows are valid, when resources can "
"be freed, and when variables are created or destroyed."
msgstr ""
"스코프(범위)는 소유권(ownership), 빌림(borrowing), 라이프타임(lifetimes)에서 "
"중요한 역할을 합니다. 즉, 스코프는 컴파일러에게 언제 빌림이 유효한지, 언제 자"
"원이 해제될 수 있는지, 언제 변수가 생성되고 파괴되는지를 알려줍니다."

#: src/scope/raii.md:3
msgid ""
"Variables in Rust do more than just hold data in the stack: they also _own_ "
"resources, e.g. `Box<T>` owns memory in the heap. Rust enforces [RAII]"
"(https://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization) "
"(Resource Acquisition Is Initialization), so whenever an object goes out of "
"scope, its destructor is called and its owned resources are freed."
msgstr ""
"Rust의 변수는 스택에 데이터를 저장하는 것 이상의 일을 합니다. 예를 들어 "
"`Box<T>`는 힙 메모리를 소유하는 것처럼 리소스를 _소유(own)_하기도 합니다. "
"Rust는 [RAII](https://en.wikipedia.org/wiki/"
"Resource_Acquisition_Is_Initialization) (자원의 획득은 초기화이다)를 강제하므"
"로, 객체가 스코프를 벗어날 때마다 소멸자가 호출되어 소유한 리소스가 해제됩니"
"다."

#: src/scope/raii.md:8
msgid ""
"This behavior shields against _resource leak_ bugs, so you'll never have to "
"manually free memory or worry about memory leaks again! Here's a quick "
"showcase:"
msgstr ""
"이러한 동작은 _리소스 누수_ 버그를 방지하므로, 수동으로 메모리를 해제하거나 "
"메모리 누수에 대해 걱정할 필요가 없습니다! 간단한 예시를 보여드리겠습니다:"

#: src/scope/raii.md:12
msgid "// raii.rs\n"
msgstr "// raii.rs\n"

#: src/scope/raii.md:14 src/scope/raii.md:21 src/scope/raii.md:26
msgid "// Allocate an integer on the heap\n"
msgstr "// 힙에 정수를 할당합니다\n"

#: src/scope/raii.md:17
msgid "// `_box1` is destroyed here, and memory gets freed\n"
msgstr "// `_box1`은 여기서 파괴되고, 메모리가 해제됩니다\n"

#: src/scope/raii.md:24
msgid "// A nested scope:\n"
msgstr "// 중첩된 스코프:\n"

#: src/scope/raii.md:29
msgid "// `_box3` is destroyed here, and memory gets freed\n"
msgstr "// `_box3`은 여기서 파괴되고, 메모리가 해제됩니다\n"

#: src/scope/raii.md:32
msgid ""
"// Creating lots of boxes just for fun\n"
"    // There's no need to manually free memory!\n"
msgstr ""
"// 재미 삼아 많은 상자를 만듭니다\n"
"    // 수동으로 메모리를 해제할 필요가 없습니다!\n"

#: src/scope/raii.md:38
msgid "// `_box2` is destroyed here, and memory gets freed\n"
msgstr "// `_box2`는 여기서 파괴되고, 메모리가 해제됩니다\n"

#: src/scope/raii.md:42
msgid ""
"Of course, we can double check for memory errors using [`valgrind`](http://"
"valgrind.org/info/):"
msgstr ""
"물론 [`valgrind`](http://valgrind.org/info/)를 사용하여 메모리 에러를 다시 확"
"인할 수 있습니다:"

#: src/scope/raii.md:65
msgid "No leaks here!"
msgstr "누수가 없습니다!"

#: src/scope/raii.md:67
msgid "Destructor"
msgstr "소멸자"

#: src/scope/raii.md:69
msgid ""
"The notion of a destructor in Rust is provided through the [`Drop`](https://"
"doc.rust-lang.org/std/ops/trait.Drop.html) trait. The destructor is called "
"when the resource goes out of scope. This trait is not required to be "
"implemented for every type, only implement it for your type if you require "
"its own destructor logic."
msgstr ""
"Rust에서 소멸자의 개념은 [`Drop`](https://doc.rust-lang.org/std/ops/"
"trait.Drop.html) 트레이트를 통해 제공됩니다. 소멸자는 리소스가 스코프를 벗어"
"날 때 호출됩니다. 모든 타입에 대해 이 트레이트를 구현할 필요는 없으며, 자체적"
"인 소멸자 로직이 필요한 경우에만 구현하면 됩니다."

#: src/scope/raii.md:74
msgid ""
"Run the below example to see how the [`Drop`](https://doc.rust-lang.org/std/"
"ops/trait.Drop.html) trait works. When the variable in the `main` function "
"goes out of scope the custom destructor will be invoked."
msgstr ""
"아래 예제를 실행하여 [`Drop`](https://doc.rust-lang.org/std/ops/"
"trait.Drop.html) 트레이트가 어떻게 작동하는지 확인해 보세요. `main` 함수의 변"
"수가 스코프를 벗어나면 사용자 정의 소멸자가 호출될 것입니다."

#: src/scope/raii.md:82
msgid "\"ToDrop is being dropped\""
msgstr "\"ToDrop이 드롭되고 있습니다\""

#: src/scope/raii.md:88
msgid "\"Made a ToDrop!\""
msgstr "\"ToDrop을 만들었습니다!\""

#: src/scope/raii.md:94
msgid "[Box](../std/box.md)"
msgstr "[Box](../std/box.md)"

#: src/scope/move.md:3
msgid ""
"Because variables are in charge of freeing their own resources, **resources "
"can only have one owner**. This prevents resources from being freed more "
"than once. Note that not all variables own resources (e.g. [references](../"
"flow_control/match/destructuring/destructure_pointers.md))."
msgstr ""
"변수는 자신의 리소스를 해제할 책임이 있으므로, **리소스는 오직 하나의 소유자"
"만 가질 수 있습니다**. 이는 리소스가 한 번 이상 해제되는 것을 방지합니다. 모"
"든 변수가 리소스를 소유하는 것은 아닙니다(예: [참조](../flow_control/match/"
"destructuring/destructure_pointers.md))."

#: src/scope/move.md:8
msgid ""
"When doing assignments (`let x = y`) or passing function arguments by value "
"(`foo(x)`), the _ownership_ of the resources is transferred. In Rust-speak, "
"this is known as a _move_."
msgstr ""
"할당(`let x = y`)을 하거나 함수 인자를 값으로 전달(`foo(x)`)할 때, 리소스의 _"
"소유권_이 이전됩니다. Rust 용어로는 이를 _이동(move)_이라고 합니다."

#: src/scope/move.md:12
msgid ""
"After moving resources, the previous owner can no longer be used. This "
"avoids creating dangling pointers."
msgstr ""
"리소스를 이동한 후에는 이전 소유자를 더 이상 사용할 수 없습니다. 이는 댕글링 "
"포인터(dangling pointers) 생성을 방지합니다."

#: src/scope/move.md:16
msgid "// This function takes ownership of the heap allocated memory\n"
msgstr "// 이 함수는 힙에 할당된 메모리의 소유권을 가져갑니다\n"

#: src/scope/move.md:18
msgid "\"Destroying a box that contains {}\""
msgstr "\"{}를 포함하는 상자를 파괴 중\""

#: src/scope/move.md:20
msgid "// `c` is destroyed and the memory freed\n"
msgstr "// `c`가 파괴되고 메모리가 해제됩니다\n"

#: src/scope/move.md:24
msgid "// _Stack_ allocated integer\n"
msgstr "// _스택_에 할당된 정수\n"

#: src/scope/move.md:27
msgid "// *Copy* `x` into `y` - no resources are moved\n"
msgstr "// `x`를 `y`로 *복사* - 리소스가 이동되지 않음\n"

#: src/scope/move.md:30
msgid "// Both values can be independently used\n"
msgstr "// 두 값 모두 독립적으로 사용될 수 있음\n"

#: src/scope/move.md:31
msgid "\"x is {}, and y is {}\""
msgstr "\"x는 {}이고, y는 {}입니다\""

#: src/scope/move.md:33
msgid "// `a` is a pointer to a _heap_ allocated integer\n"
msgstr "// `a`는 _힙_에 할당된 정수에 대한 포인터입니다\n"

#: src/scope/move.md:36
msgid "\"a contains: {}\""
msgstr "\"a가 포함하는 것: {}\""

#: src/scope/move.md:38
msgid "// *Move* `a` into `b`\n"
msgstr "// `a`를 `b`로 *이동*\n"

#: src/scope/move.md:40
msgid ""
"// The pointer address of `a` is copied (not the data) into `b`.\n"
"    // Both are now pointers to the same heap allocated data, but\n"
"    // `b` now owns it.\n"
msgstr ""
"// `a`의 포인터 주소가 (데이터가 아니라) `b`로 복사됩니다.\n"
"// 둘 다 이제 동일한 힙 할당 데이터를 가리키지만,\n"
"// 이제 `b`가 소유권을 가집니다.\n"

#: src/scope/move.md:44
msgid ""
"// Error! `a` can no longer access the data, because it no longer owns the\n"
"    // heap memory\n"
"    //println!(\"a contains: {}\", a);\n"
"    // TODO ^ Try uncommenting this line\n"
msgstr ""
"// 에러! `a`는 더 이상 데이터를 소유하고 있지 않으므로 접근할 수 없습니다.\n"
"//println!(\"a가 포함하는 것: {}\", a);\n"
"// TODO ^ 이 줄의 주석을 해제해 보세요\n"

#: src/scope/move.md:49
msgid ""
"// This function takes ownership of the heap allocated memory from `b`\n"
msgstr "// 이 함수는 `b`로부터 힙에 할당된 메모리의 소유권을 가져갑니다\n"

#: src/scope/move.md:52
msgid ""
"// Since the heap memory has been freed at this point, this action would\n"
"    // result in dereferencing freed memory, but it's forbidden by the "
"compiler\n"
"    // Error! Same reason as the previous Error\n"
"    //println!(\"b contains: {}\", b);\n"
"    // TODO ^ Try uncommenting this line\n"
msgstr ""
"// 이 시점에서 힙 메모리가 해제되었으므로, 이 동작은\n"
"    // 해제된 메모리를 역참조하는 결과를 낳겠지만, 컴파일러에 의해 금지됩니"
"다.\n"
"    // 에러! 이전 에러와 같은 이유입니다.\n"
"    //println!(\"b가 포함하는 것: {}\", b);\n"
"    // TODO ^ 이 줄의 주석을 해제해 보세요\n"

#: src/scope/move/mut.md:3
msgid "Mutability of data can be changed when ownership is transferred."
msgstr "소유권이 이전될 때 데이터의 가변성이 변경될 수 있습니다."

#: src/scope/move/mut.md:9
msgid "\"immutable_box contains {}\""
msgstr "\"불변 상자가 포함하는 것: {}\""

#: src/scope/move/mut.md:11
msgid ""
"// Mutability error\n"
"    //*immutable_box = 4;\n"
msgstr ""
"// 가변성 에러\n"
"    //*immutable_box = 4;\n"

#: src/scope/move/mut.md:14
msgid "// *Move* the box, changing the ownership (and mutability)\n"
msgstr "// 상자를 *이동*하여 소유권(및 가변성)을 변경합니다\n"

#: src/scope/move/mut.md:17
msgid "\"mutable_box contains {}\""
msgstr "\"가변 상자가 포함하는 것: {}\""

#: src/scope/move/mut.md:19
msgid "// Modify the contents of the box\n"
msgstr "// 상자의 내용물을 수정합니다\n"

#: src/scope/move/mut.md:22
msgid "\"mutable_box now contains {}\""
msgstr "\"가변 상자가 이제 포함하는 것: {}\""

#: src/scope/move/partial_move.md:3
msgid ""
"Within the [destructuring](../../flow_control/match/destructuring.md) of a "
"single variable, both `by-move` and `by-reference` pattern bindings can be "
"used at the same time. Doing this will result in a _partial move_ of the "
"variable, which means that parts of the variable will be moved while other "
"parts stay. In such a case, the parent variable cannot be used afterwards as "
"a whole, however the parts that are only referenced (and not moved) can "
"still be used. Note that types that implement the [`Drop` trait](../../trait/"
"drop.md) cannot be partially moved from, because its `drop` method would use "
"it afterwards as a whole."
msgstr ""
"단일 변수의 [구조 분해](../../flow_control/match/destructuring.md) 내에서 `이"
"동에 의한(by-move)` 패턴 바인딩과 `참조에 의한(by-reference)` 패턴 바인딩을 "
"동시에 사용할 수 있습니다. 이렇게 하면 변수의 _부분 이동(partial move)_이 발"
"생하는데, 이는 변수의 일부는 이동하고 다른 부분은 남아있음을 의미합니다. 이"
"런 경우 부모 변수는 전체로서 나중에 사용될 수 없지만, 참조만 되고 이동되지 않"
"은 부분은 여전히 사용될 수 있습니다. [`Drop` 트레이트](../../trait/drop.md)"
"를 구현한 타입은 부분적으로 이동될 수 없다는 점에 유의하세요. 왜냐하면 해당 "
"타입의 `drop` 메서드가 나중에 전체로서 사용될 것이기 때문입니다."

#: src/scope/move/partial_move.md:22
msgid ""
"// Error! cannot move out of a type which implements the `Drop` trait\n"
"    //impl Drop for Person {\n"
"    //    fn drop(&mut self) {\n"
"    //        println!(\"Dropping the person struct {:?}\", self)\n"
"    //    }\n"
"    //}\n"
"    // TODO ^ Try uncommenting these lines\n"
msgstr ""
"// 에러! `Drop` 트레이트를 구현한 타입에서는 이동해 나올 수 없습니다\n"
"    //impl Drop for Person {\n"
"    //    fn drop(&mut self) {\n"
"    //        println!(\"Person 구조체를 드롭합니다 {:?}\", self)\n"
"    //    }\n"
"    //}\n"
"    // TODO ^ 이 줄들의 주석을 해제해 보세요\n"

#: src/scope/move/partial_move.md:35
msgid "// `name` is moved out of person, but `age` is referenced\n"
msgstr "// `name`은 person에서 밖으로 이동되지만, `age`는 참조됩니다\n"

#: src/scope/move/partial_move.md:38
msgid "\"The person's age is {}\""
msgstr "\"이 사람의 나이는 {}입니다\""

#: src/scope/move/partial_move.md:40
msgid "\"The person's name is {}\""
msgstr "\"이 사람의 이름은 {}입니다\""

#: src/scope/move/partial_move.md:42
msgid ""
"// Error! borrow of partially moved value: `person` partial move occurs\n"
"    //println!(\"The person struct is {:?}\", person);\n"
msgstr ""
"// 에러! 부분적으로 이동된 값의 빌림: `person`의 부분 이동이 발생했습니다\n"
"    //println!(\"Person 구조체는 {:?}입니다\", person);\n"

#: src/scope/move/partial_move.md:45
msgid ""
"// `person` cannot be used but `person.age` can be used as it is not moved\n"
msgstr ""
"// `person`은 사용할 수 없지만 `person.age`는 이동되지 않았으므로 사용할 수 "
"있습니다\n"

#: src/scope/move/partial_move.md:46
msgid "\"The person's age from person struct is {}\""
msgstr "\"person 구조체에서 가져온 이 사람의 나이는 {}입니다\""

#: src/scope/move/partial_move.md:50
msgid ""
"(In this example, we store the `age` variable on the heap to illustrate the "
"partial move: deleting `ref` in the above code would give an error as the "
"ownership of `person.age` would be moved to the variable `age`. If "
"`Person.age` were stored on the stack, `ref` would not be required as the "
"definition of `age` would copy the data from `person.age` without moving it.)"
msgstr ""
"(이 예제에서는 부분 이동을 설명하기 위해 `age` 변수를 힙에 저장합니다. 위 코"
"드에서 `ref`를 삭제하면 `person.age`의 소유권이 `age` 변수로 이동하기 때문에 "
"에러가 발생합니다. `Person.age`가 스택에 저장되어 있었다면, `age`의 정의가 "
"`person.age`에서 데이터를 이동 없이 복사하므로 `ref`가 필요하지 않았을 것입니"
"다.)"

#: src/scope/move/partial_move.md:59
msgid "[destructuring](../../flow_control/match/destructuring.md)"
msgstr "[구조 분해](../../flow_control/match/destructuring.md)"

#: src/scope/borrow.md:3
msgid ""
"Most of the time, we'd like to access data without taking ownership over it. "
"To accomplish this, Rust uses a _borrowing_ mechanism. Instead of passing "
"objects by value (`T`), objects can be passed by reference (`&T`)."
msgstr ""
"대부분의 경우, 우리는 데이터의 소유권을 가져오지 않고 데이터에 접근하고 싶어 "
"합니다. 이를 달성하기 위해 Rust는 _빌림(borrowing)_ 메커니즘을 사용합니다. 객"
"체를 값(`T`)으로 전달하는 대신, 참조(`&T`)로 전달할 수 있습니다."

#: src/scope/borrow.md:7
msgid ""
"The compiler statically guarantees (via its borrow checker) that references "
"_always_ point to valid objects. That is, while references to an object "
"exist, the object cannot be destroyed."
msgstr ""
"컴파일러는 (빌림 검사기를 통해) 참조가 _항상_ 유효한 객체를 가리킨다는 것을 "
"정적으로 보장합니다. 즉, 객체에 대한 참조가 존재하는 동안에는 해당 객체를 파"
"괴할 수 없습니다."

#: src/scope/borrow.md:12
msgid "// This function takes ownership of a box and destroys it\n"
msgstr "// 이 함수는 상자의 소유권을 가져와 파괴합니다\n"

#: src/scope/borrow.md:14
msgid "\"Destroying box that contains {}\""
msgstr "\"{}를 포함하는 상자를 파괴 중\""

#: src/scope/borrow.md:16
msgid "// This function borrows an i32\n"
msgstr "// 이 함수는 i32를 빌립니다\n"

#: src/scope/borrow.md:19
msgid "\"This int is: {}\""
msgstr "\"이 정수는: {}\""

#: src/scope/borrow.md:23
msgid ""
"// Create a boxed i32 in the heap, and an i32 on the stack\n"
"    // Remember: numbers can have arbitrary underscores added for "
"readability\n"
"    // 5_i32 is the same as 5i32\n"
msgstr ""
"// 힙에 boxed i32를 생성하고, 스택에 i32를 생성합니다\n"
"// 기억하세요: 숫자는 가독성을 위해 임의의 밑줄을 추가할 수 있습니다\n"
"// 5_i32는 5i32와 동일합니다\n"

#: src/scope/borrow.md:29
msgid ""
"// Borrow the contents of the box. Ownership is not taken,\n"
"    // so the contents can be borrowed again.\n"
msgstr ""
"// 상자의 내용물을 빌립니다. 소유권을 가져가지 않으므로,\n"
"// 내용물을 다시 빌릴 수 있습니다.\n"

#: src/scope/borrow.md:35
msgid "// Take a reference to the data contained inside the box\n"
msgstr "// 상자 안에 포함된 데이터에 대한 참조를 가져옵니다\n"

#: src/scope/borrow.md:38
msgid ""
"// Error!\n"
"        // Can't destroy `boxed_i32` while the inner value is borrowed later "
"in scope.\n"
msgstr ""
"// 에러!\n"
"// 내부 값이 스코프의 나중 부분에서 빌려지고 있는 동안에는 `boxed_i32`를 파괴"
"할 수 없습니다.\n"

#: src/scope/borrow.md:43
msgid "// Attempt to borrow `_ref_to_i32` after inner value is destroyed\n"
msgstr "// 내부 값이 파괴된 후에 `_ref_to_i32`를 빌리려고 시도합니다\n"

#: src/scope/borrow.md:45
msgid "// `_ref_to_i32` goes out of scope and is no longer borrowed.\n"
msgstr "// `_ref_to_i32`가 스코프를 벗어나며 더 이상 빌려지지 않습니다.\n"

#: src/scope/borrow.md:48
msgid ""
"// `boxed_i32` can now give up ownership to `eat_box_i32` and be destroyed\n"
msgstr ""
"// `boxed_i32`는 이제 `eat_box_i32`에게 소유권을 넘기고 파괴될 수 있습니다\n"

#: src/scope/borrow/mut.md:3
msgid ""
"Mutable data can be mutably borrowed using `&mut T`. This is called a "
"_mutable reference_ and gives read/write access to the borrower. In "
"contrast, `&T` borrows the data via an immutable reference, and the borrower "
"can read the data but not modify it:"
msgstr ""
"가변 데이터는 `&mut T`를 사용하여 가변적으로 빌려올 수 있습니다. 이를 _가변 "
"참조(mutable reference)_라고 하며 빌리는 사람에게 읽기/쓰기 권한을 부여합니"
"다. 반면 `&T`는 불변 참조를 통해 데이터를 빌려오며, 빌리는 사람은 데이터를 읽"
"을 수는 있지만 수정할 수는 없습니다:"

#: src/scope/borrow/mut.md:12
msgid ""
"// `&'static str` is a reference to a string allocated in read only memory\n"
msgstr ""
"// `&'static str`은 읽기 전용 메모리에 할당된 문자열에 대한 참조입니다\n"

#: src/scope/borrow/mut.md:17
msgid "// This function takes a reference to a book\n"
msgstr "// 이 함수는 책에 대한 참조를 받습니다\n"

#: src/scope/borrow/mut.md:20
msgid "\"I immutably borrowed {} - {} edition\""
msgstr "\"{} - {} 판을 불변으로 빌렸습니다\""

#: src/scope/borrow/mut.md:22
msgid ""
"// This function takes a reference to a mutable book and changes `year` to "
"2014\n"
msgstr ""
"// 이 함수는 가변적인 책에 대한 참조를 받아 `year`를 2014로 변경합니다\n"

#: src/scope/borrow/mut.md:26
msgid "\"I mutably borrowed {} - {} edition\""
msgstr "\"{} - {} 판을 가변으로 빌렸습니다\""

#: src/scope/borrow/mut.md:30
msgid "// Create an immutable Book named `immutabook`\n"
msgstr "// `immutabook`이라는 이름의 불변 책을 생성합니다\n"

#: src/scope/borrow/mut.md:32
msgid "// string literals have type `&'static str`\n"
msgstr "// 문자열 리터럴은 `&'static str` 타입을 가집니다\n"

#: src/scope/borrow/mut.md:33
msgid "\"Douglas Hofstadter\""
msgstr "\"더글라스 호프스태터\""

#: src/scope/borrow/mut.md:34
msgid "\"Gödel, Escher, Bach\""
msgstr "\"괴델, 에셔, 바흐\""

#: src/scope/borrow/mut.md:38
msgid "// Create a mutable copy of `immutabook` and call it `mutabook`\n"
msgstr "// `immutabook`의 가변 복사본을 생성하고 `mutabook`이라고 부릅니다\n"

#: src/scope/borrow/mut.md:41
msgid "// Immutably borrow an immutable object\n"
msgstr "// 불변 객체를 불변으로 빌립니다\n"

#: src/scope/borrow/mut.md:44
msgid "// Immutably borrow a mutable object\n"
msgstr "// 가변 객체를 불변으로 빌립니다\n"

#: src/scope/borrow/mut.md:47
msgid "// Borrow a mutable object as mutable\n"
msgstr "// 가변 객체를 가변으로 빌립니다\n"

#: src/scope/borrow/mut.md:50
msgid "// Error! Cannot borrow an immutable object as mutable\n"
msgstr "// 에러! 불변 객체는 가변으로 빌릴 수 없습니다\n"

#: src/scope/borrow/mut.md:58
msgid "[`static`](../lifetime/static_lifetime.md)"
msgstr "[`static`](../lifetime/static_lifetime.md)"

#: src/scope/borrow/alias.md:3
msgid ""
"Data can be immutably borrowed any number of times, but while immutably "
"borrowed, the original data can't be mutably borrowed. On the other hand, "
"only _one_ mutable borrow is allowed at a time. The original data can be "
"borrowed again only _after_ the mutable reference has been used for the last "
"time."
msgstr ""
"데이터는 횟수에 제한 없이 불변으로 빌려질 수 있지만, 불변으로 빌려진 동안에"
"는 원본 데이터를 가변으로 빌릴 수 없습니다. 반면에, 가변 빌림은 한 번에 _하나"
"_만 허용됩니다. 원본 데이터는 가변 참조가 마지막으로 사용된 _후_에만 다시 빌"
"려질 수 있습니다."

#: src/scope/borrow/alias.md:17
msgid "// Data can be accessed via the references and the original owner\n"
msgstr "// 데이터는 참조와 원본 소유자를 통해 접근할 수 있습니다\n"

#: src/scope/borrow/alias.md:18 src/scope/borrow/alias.md:27
#: src/scope/borrow/alias.md:49
msgid "\"Point has coordinates: ({}, {}, {})\""
msgstr "\"점의 좌표: ({}, {}, {})\""

#: src/scope/borrow/alias.md:21
msgid ""
"// Error! Can't borrow `point` as mutable because it's currently\n"
"    // borrowed as immutable.\n"
"    // let mutable_borrow = &mut point;\n"
"    // TODO ^ Try uncommenting this line\n"
msgstr ""
"// 에러! 현재 불변으로 빌려진 상태이기 때문에 `point`를 가변으로 빌릴 수 없습"
"니다.\n"
"// let mutable_borrow = &mut point;\n"
"// TODO ^ 이 줄의 주석을 해제해 보세요\n"

#: src/scope/borrow/alias.md:26
msgid "// The borrowed values are used again here\n"
msgstr "// 빌려온 값들이 여기서 다시 사용됩니다\n"

#: src/scope/borrow/alias.md:30
msgid ""
"// The immutable references are no longer used for the rest of the code so\n"
"    // it is possible to reborrow with a mutable reference.\n"
msgstr ""
"// 불변 참조들이 코드의 나머지 부분에서 더 이상 사용되지 않으므로\n"
"// 가변 참조로 다시 빌리는 것이 가능합니다.\n"

#: src/scope/borrow/alias.md:34
msgid "// Change data via mutable reference\n"
msgstr "// 가변 참조를 통해 데이터를 변경합니다\n"

#: src/scope/borrow/alias.md:39
msgid ""
"// Error! Can't borrow `point` as immutable because it's currently\n"
"    // borrowed as mutable.\n"
"    // let y = &point.y;\n"
"    // TODO ^ Try uncommenting this line\n"
msgstr ""
"// 에러! 현재 가변으로 빌려진 상태이기 때문에 `point`를 불변으로 빌릴 수 없습"
"니다.\n"
"// let y = &point.y;\n"
"// TODO ^ 이 줄의 주석을 해제해 보세요\n"

#: src/scope/borrow/alias.md:44
msgid ""
"// Error! Can't print because `println!` takes an immutable reference.\n"
"    // println!(\"Point Z coordinate is {}\", point.z);\n"
"    // TODO ^ Try uncommenting this line\n"
msgstr ""
"// 에러! `println!`은 불변 참조를 받기 때문에 출력할 수 없습니다.\n"
"// println!(\"점의 Z 좌표는 {}입니다\", point.z);\n"
"// TODO ^ 이 줄의 주석을 해제해 보세요\n"

#: src/scope/borrow/alias.md:48
msgid "// Ok! Mutable references can be passed as immutable to `println!`\n"
msgstr "// 좋습니다! 가변 참조는 불변 참조로 `println!`에 전달될 수 있습니다\n"

#: src/scope/borrow/alias.md:52
msgid ""
"// The mutable reference is no longer used for the rest of the code so it\n"
"    // is possible to reborrow\n"
msgstr ""
"// 가변 참조가 코드의 나머지 부분에서 더 이상 사용되지 않으므로\n"
"// 다시 빌리는 것이 가능합니다\n"

#: src/scope/borrow/alias.md:55
msgid "\"Point now has coordinates: ({}, {}, {})\""
msgstr "\"점은 이제 다음 좌표를 가집니다: ({}, {}, {})\""

#: src/scope/borrow/ref.md:3
msgid ""
"When doing pattern matching or destructuring via the `let` binding, the "
"`ref` keyword can be used to take references to the fields of a struct/"
"tuple. The example below shows a few instances where this can be useful:"
msgstr ""
"`let` 바인딩을 통해 패턴 매칭이나 구조 분해를 수행할 때, `ref` 키워드를 사용"
"하여 구조체/튜플 필드에 대한 참조를 가져올 수 있습니다. 아래 예제는 이것이 유"
"용할 수 있는 몇 가지 사례를 보여줍니다:"

#: src/scope/borrow/ref.md:14
msgid ""
"// A `ref` borrow on the left side of an assignment is equivalent to\n"
"    // an `&` borrow on the right side.\n"
msgstr ""
"// 할당의 왼쪽 편에 있는 `ref` 빌림은\n"
"// 오른쪽 편에 있는 `&` 빌림과 동일합니다.\n"

#: src/scope/borrow/ref.md:19
msgid "\"ref_c1 equals ref_c2: {}\""
msgstr "\"ref_c1은 ref_c2와 같습니다: {}\""

#: src/scope/borrow/ref.md:23
msgid "// `ref` is also valid when destructuring a struct.\n"
msgstr "// `ref`는 구조체를 구조 분해할 때도 유효합니다.\n"

#: src/scope/borrow/ref.md:25
msgid "// `ref_to_x` is a reference to the `x` field of `point`.\n"
msgstr "// `ref_to_x`는 `point`의 `x` 필드에 대한 참조입니다.\n"

#: src/scope/borrow/ref.md:28
msgid "// Return a copy of the `x` field of `point`.\n"
msgstr "// `point`의 `x` 필드 복사본을 반환합니다.\n"

#: src/scope/borrow/ref.md:32
msgid "// A mutable copy of `point`\n"
msgstr "// `point`의 가변 복사본\n"

#: src/scope/borrow/ref.md:36
msgid "// `ref` can be paired with `mut` to take mutable references.\n"
msgstr "// `ref`는 `mut`와 짝을 이루어 가변 참조를 가져올 수 있습니다.\n"

#: src/scope/borrow/ref.md:39
msgid "// Mutate the `y` field of `mutable_point` via a mutable reference.\n"
msgstr "// 가변 참조를 통해 `mutable_point`의 `y` 필드를 변경합니다.\n"

#: src/scope/borrow/ref.md:43
msgid "\"point is ({}, {})\""
msgstr "\"point는 ({}, {})입니다\""

#: src/scope/borrow/ref.md:44
msgid "\"mutable_point is ({}, {})\""
msgstr "\"mutable_point는 ({}, {})입니다\""

#: src/scope/borrow/ref.md:46
msgid "// A mutable tuple that includes a pointer\n"
msgstr "// 포인터를 포함하는 가변 튜플\n"

#: src/scope/borrow/ref.md:50
msgid "// Destructure `mutable_tuple` to change the value of `last`.\n"
msgstr "// `mutable_tuple`을 구조 분해하여 `last` 값을 변경합니다.\n"

#: src/scope/borrow/ref.md:55
msgid "\"tuple is {:?}\""
msgstr "\"튜플은 {:?}입니다\""

#: src/scope/lifetime.md:3
msgid ""
"A _lifetime_ is a construct the compiler (or more specifically, its _borrow "
"checker_) uses to ensure all borrows are valid. Specifically, a variable's "
"lifetime begins when it is created and ends when it is destroyed. While "
"lifetimes and scopes are often referred to together, they are not the same."
msgstr ""
"_라이프타임(lifetime)_은 컴파일러(더 구체적으로는 _빌림 검사기_)가 모든 빌림"
"이 유효한지 확인하기 위해 사용하는 구성 요소입니다. 구체적으로, 변수의 라이프"
"타임은 생성될 때 시작하고 파괴될 때 끝납니다. 라이프타임과 스코프는 종종 함"
"께 언급되지만, 같은 것은 아닙니다."

#: src/scope/lifetime.md:8
msgid ""
"Take, for example, the case where we borrow a variable via `&`. The borrow "
"has a lifetime that is determined by where it is declared. As a result, the "
"borrow is valid as long as it ends before the lender is destroyed. However, "
"the scope of the borrow is determined by where the reference is used."
msgstr ""
"예를 들어, `&`를 통해 변수를 빌리는 경우를 생각해 봅시다. 빌림은 선언된 위치"
"에 따라 결정되는 라이프타임을 가집니다. 결과적으로 빌림은 빌려준 대상이 파괴"
"되기 전에 끝나는 한 유효합니다. 하지만 빌림의 스코프는 참조가 사용되는 위치"
"에 따라 결정됩니다."

#: src/scope/lifetime.md:13
msgid ""
"In the following example and in the rest of this section, we will see how "
"lifetimes relate to scopes, as well as how the two differ."
msgstr ""
"다음 예제와 이 섹션의 나머지 부분에서 라이프타임이 스코프와 어떻게 관련되어 "
"있는지, 그리고 두 가지가 어떻게 다른지 살펴보겠습니다."

#: src/scope/lifetime.md:17
msgid ""
"// Lifetimes are annotated below with lines denoting the creation\n"
"// and destruction of each variable.\n"
"// `i` has the longest lifetime because its scope entirely encloses\n"
"// both `borrow1` and `borrow2`. The duration of `borrow1` compared\n"
"// to `borrow2` is irrelevant since they are disjoint.\n"
msgstr ""
"// 아래에는 각 변수의 생성과 파괴를 나타내는 선으로 라이프타임이 주석 처리되"
"어 있습니다.\n"
"// `i`의 스코프가 `borrow1`과 `borrow2`를 완전히 감싸고 있기 때문에\n"
"// `i`는 가장 긴 라이프타임을 가집니다. `borrow1`과 `borrow2`는 서로 겹치지 "
"않으므로\n"
"// 둘의 기간 비교는 무의미합니다.\n"

#: src/scope/lifetime.md:23
msgid ""
"// Lifetime for `i` starts. ────────────────┐\n"
"    //                                                     │\n"
msgstr ""
"// `i`의 라이프타임 시작. ──────────────────┐\n"
"    //                                                     │\n"

#: src/scope/lifetime.md:25 src/scope/lifetime.md:32
msgid "//                                                   │\n"
msgstr "//                                                   │\n"

#: src/scope/lifetime.md:26
msgid ""
"// `borrow1` lifetime starts. ──┐│\n"
"        //                                                ││\n"
msgstr ""
"// `borrow1` 라이프타임 시작. ──┐│\n"
"        //                                                ││\n"

#: src/scope/lifetime.md:28
msgid "\"borrow1: {}\""
msgstr "\"borrow1: {}\""

#: src/scope/lifetime.md:28 src/scope/lifetime.md:35
msgid "//              ││\n"
msgstr "//              ││\n"

#: src/scope/lifetime.md:29
msgid ""
"// `borrow1` ends. ─────────────────────────────────┘│\n"
"    //                                                     │\n"
"    //                                                     │\n"
msgstr ""
"// `borrow1` 끝. ───────────────────────────────────┘│\n"
"    //                                                     │\n"
"    //                                                     │\n"

#: src/scope/lifetime.md:33
msgid ""
"// `borrow2` lifetime starts. ──┐│\n"
"        //                                                ││\n"
msgstr ""
"// `borrow2` 라이프타임 시작. ──┐│\n"
"        //                                                ││\n"

#: src/scope/lifetime.md:35
msgid "\"borrow2: {}\""
msgstr "\"borrow2: {}\""

#: src/scope/lifetime.md:36
msgid ""
"// `borrow2` ends. ─────────────────────────────────┘│\n"
"    //                                                     │\n"
msgstr ""
"// `borrow2` 끝. ───────────────────────────────────┘│\n"
"    //                                                     │\n"

#: src/scope/lifetime.md:38
msgid "// Lifetime ends. ─────────────────────────────────────┘\n"
msgstr "// 라이프타임 끝. ─────────────────────────────────────┘\n"

#: src/scope/lifetime.md:41
msgid ""
"Note that no names or types are assigned to label lifetimes. This restricts "
"how lifetimes will be able to be used as we will see."
msgstr ""
"레이블 라이프타임에는 이름이나 타입이 할당되지 않는다는 점에 유의하세요. 이"
"는 앞으로 보게 될 것처럼 라이프타임을 사용하는 방식에 제한을 줍니다."

#: src/scope/lifetime/explicit.md:3
msgid ""
"The borrow checker uses explicit lifetime annotations to determine how long "
"references should be valid. In cases where lifetimes are not elided[^1], "
"Rust requires explicit annotations to determine what the lifetime of a "
"reference should be. The syntax for explicitly annotating a lifetime uses an "
"apostrophe character as follows:"
msgstr ""
"빌림 검사기는 참조가 얼마나 오래 유효해야 하는지 결정하기 위해 명시적 라이프"
"타임 어노테이션을 사용합니다. 라이프타임이 생략(elided)[^1]되지 않는 경우, "
"Rust는 참조의 라이프타임이 어떻게 되어야 하는지 결정하기 위해 명시적인 어노테"
"이션을 요구합니다. 라이프타임을 명시적으로 어노테이션하는 구문은 다음과 같이 "
"아포스트로피 문자를 사용합니다:"

#: src/scope/lifetime/explicit.md:10
msgid "// `foo` has a lifetime parameter `'a`\n"
msgstr "// `foo`는 라이프타임 파라미터 `'a`를 가집니다\n"

#: src/scope/lifetime/explicit.md:14
msgid ""
"Similar to [closures](../../fn/closures/anonymity.md), using lifetimes "
"requires generics. Additionally, this lifetime syntax indicates that the "
"lifetime of `foo` may not exceed that of `'a`. Explicit annotation of a type "
"has the form `&'a T` where `'a` has already been introduced."
msgstr ""
"[클로저](../../fn/closures/anonymity.md)와 유사하게, 라이프타임을 사용하려면 "
"제네릭이 필요합니다. 또한, 이 라이프타임 구문은 `foo`의 라이프타임이 `'a`의 "
"라이프타임을 초과할 수 없음을 나타냅니다. 타입의 명시적 어노테이션은 `&'a T` "
"형식을 가지며, 여기서 `'a`는 이미 도입된 라이프타임입니다."

#: src/scope/lifetime/explicit.md:19
msgid "In cases with multiple lifetimes, the syntax is similar:"
msgstr "여러 라이프타임이 있는 경우에도 구문은 유사합니다:"

#: src/scope/lifetime/explicit.md:22
msgid "// `foo` has lifetime parameters `'a` and `'b`\n"
msgstr "// `foo`는 라이프타임 파라미터 `'a`와 `'b`를 가집니다\n"

#: src/scope/lifetime/explicit.md:26
msgid ""
"In this case, the lifetime of `foo` cannot exceed that of either `'a` _or_ "
"`'b`."
msgstr ""
"이 경우, `foo`의 라이프타임은 `'a` _또는_ `'b` 중 어느 하나의 라이프타임도 초"
"과할 수 없습니다."

#: src/scope/lifetime/explicit.md:28
msgid "See the following example for explicit lifetime annotation in use:"
msgstr "명시적 라이프타임 어노테이션이 사용된 다음 예제를 참조하세요:"

#: src/scope/lifetime/explicit.md:31
msgid ""
"// `print_refs` takes two references to `i32` which have different\n"
"// lifetimes `'a` and `'b`. These two lifetimes must both be at\n"
"// least as long as the function `print_refs`.\n"
msgstr ""
"// `print_refs`는 서로 다른 라이프타임 `'a`와 `'b`를 가진\n"
"// 두 개의 `i32` 참조를 받습니다. 이 두 라이프타임은 모두\n"
"// 적어도 `print_refs` 함수만큼 길어야 합니다.\n"

#: src/scope/lifetime/explicit.md:35
msgid "\"x is {} and y is {}\""
msgstr "\"x는 {}이고 y는 {}입니다\""

#: src/scope/lifetime/explicit.md:37
msgid ""
"// A function which takes no arguments, but has a lifetime parameter `'a`.\n"
msgstr "// 인자를 받지 않지만 라이프타임 파라미터 `'a`를 가진 함수입니다.\n"

#: src/scope/lifetime/explicit.md:42
msgid "// ERROR: `_x` does not live long enough\n"
msgstr "// 에러: `_x`의 수명이 충분히 길지 않습니다\n"

#: src/scope/lifetime/explicit.md:44
msgid ""
"// Attempting to use the lifetime `'a` as an explicit type annotation\n"
"    // inside the function will fail because the lifetime of `&_x` is "
"shorter\n"
"    // than that of `_y`. A short lifetime cannot be coerced into a longer "
"one.\n"
msgstr ""
"// 함수 내부에서 라이프타임 `'a`를 명시적 타입 어노테이션으로 사용하려고 하"
"면\n"
"    // 실패합니다. `&_x`의 라이프타임이 `_y`의 라이프타임보다 짧기 때문입니"
"다.\n"
"    // 짧은 라이프타임은 더 긴 라이프타임으로 강제 변환될 수 없습니다.\n"

#: src/scope/lifetime/explicit.md:50
msgid "// Create variables to be borrowed below.\n"
msgstr "// 아래에서 빌려올 변수들을 생성합니다.\n"

#: src/scope/lifetime/explicit.md:53
msgid "// Borrows (`&`) of both variables are passed into the function.\n"
msgstr "// 두 변수의 빌림(`&`)이 함수로 전달됩니다.\n"

#: src/scope/lifetime/explicit.md:55
msgid ""
"// Any input which is borrowed must outlive the borrower.\n"
"    // In other words, the lifetime of `four` and `nine` must\n"
"    // be longer than that of `print_refs`.\n"
msgstr ""
"// 빌려온 모든 입력은 빌리는 주체보다 오래 살아야 합니다.\n"
"    // 다시 말해, `four`와 `nine`의 라이프타임은\n"
"    // `print_refs`의 라이프타임보다 길어야 합니다.\n"

#: src/scope/lifetime/explicit.md:60
msgid ""
"// `failed_borrow` contains no references to force `'a` to be\n"
"    // longer than the lifetime of the function, but `'a` is longer.\n"
"    // Because the lifetime is never constrained, it defaults to `'static`.\n"
msgstr ""
"// `failed_borrow`는 `'a`가 함수의 라이프타임보다 길어야 함을 강제하는\n"
"// 참조를 포함하지 않지만, `'a`는 더 깁니다.\n"
"// 라이프타임이 결코 제약되지 않으므로, 이는 `'static`으로 기본 설정됩니다.\n"

#: src/scope/lifetime/explicit.md:66
msgid ""
"[elision](elision.md) implicitly annotates lifetimes and so is different."
msgstr ""
"[생략(elision)](elision.md)은 암시적으로 라이프타임을 어노테이션하므로 다릅니"
"다."

#: src/scope/lifetime/explicit.md:70
msgid "[generics](../../generics.md) and [closures](../../fn/closures.md)"
msgstr "[제네릭](../../generics.md) 및 [클로저](../../fn/closures.md)"

#: src/scope/lifetime/fn.md:3
msgid ""
"Ignoring [elision](elision.md), function signatures with lifetimes have a "
"few constraints:"
msgstr ""
"[생략](elision.md)을 무시하고, 라이프타임을 가진 함수 시그니처에는 몇 가지 제"
"약 사항이 있습니다:"

#: src/scope/lifetime/fn.md:5
msgid "any reference _must_ have an annotated lifetime."
msgstr "모든 참조는 _반드시_ 어노테이션된 라이프타임을 가져야 합니다."

#: src/scope/lifetime/fn.md:6
msgid ""
"any reference being returned _must_ have the same lifetime as an input or be "
"`static`."
msgstr ""
"반환되는 모든 참조는 입력과 동일한 라이프타임을 가지거나 `static`이어야 _합니"
"다_."

#: src/scope/lifetime/fn.md:9
msgid ""
"Additionally, note that returning references without input is banned if it "
"would result in returning references to invalid data. The following example "
"shows off some valid forms of functions with lifetimes:"
msgstr ""
"또한, 입력 없이 참조를 반환하는 것이 유효하지 않은 데이터에 대한 참조를 반환"
"하는 결과를 낳는다면 금지된다는 점에 유의하세요. 다음 예제는 라이프타임이 있"
"는 유효한 함수 형태를 보여줍니다:"

#: src/scope/lifetime/fn.md:14
msgid ""
"// One input reference with lifetime `'a` which must live\n"
"// at least as long as the function.\n"
msgstr ""
"// 라이프타임 `'a`를 가진 하나의 입력 참조입니다.\n"
"// 이 참조는 적어도 함수만큼 오래 살아야 합니다.\n"

#: src/scope/lifetime/fn.md:17
msgid "\"`print_one`: x is {}\""
msgstr "\"`print_one`: x는 {}입니다\""

#: src/scope/lifetime/fn.md:19
msgid "// Mutable references are possible with lifetimes as well.\n"
msgstr "// 가변 참조도 라이프타임과 함께 사용할 수 있습니다.\n"

#: src/scope/lifetime/fn.md:24
msgid ""
"// Multiple elements with different lifetimes. In this case, it\n"
"// would be fine for both to have the same lifetime `'a`, but\n"
"// in more complex cases, different lifetimes may be required.\n"
msgstr ""
"// 서로 다른 라이프타임을 가진 여러 요소들입니다. 이 경우,\n"
"// 둘 다 동일한 라이프타임 `'a`를 가져도 괜찮지만,\n"
"// 더 복잡한 경우에는 서로 다른 라이프타임이 필요할 수 있습니다.\n"

#: src/scope/lifetime/fn.md:29
msgid "\"`print_multi`: x is {}, y is {}\""
msgstr "\"`print_multi`: x는 {}, y는 {}입니다\""

#: src/scope/lifetime/fn.md:31
msgid ""
"// Returning references that have been passed in is acceptable.\n"
"// However, the correct lifetime must be returned.\n"
msgstr ""
"// 전달된 참조를 반환하는 것은 허용됩니다.\n"
"// 하지만, 올바른 라이프타임이 반환되어야 합니다.\n"

#: src/scope/lifetime/fn.md:35
msgid ""
"//fn invalid_output<'a>() -> &'a String { &String::from(\"foo\") }\n"
"// The above is invalid: `'a` must live longer than the function.\n"
"// Here, `&String::from(\"foo\")` would create a `String`, followed by a\n"
"// reference. Then the data is dropped upon exiting the scope, leaving\n"
"// a reference to invalid data to be returned.\n"
msgstr ""
"//fn invalid_output<'a>() -> &'a String { &String::from(\"foo\") }\n"
"// 위 코드는 유효하지 않습니다: `'a`는 함수보다 오래 살아야 합니다.\n"
"// 여기서 `&String::from(\"foo\")`는 `String`을 생성한 후 참조를 생성합니"
"다.\n"
"// 그런 다음 스코프를 벗어날 때 데이터가 드롭되어,\n"
"// 유효하지 않은 데이터에 대한 참조가 반환됩니다.\n"

#: src/scope/lifetime/fn.md:60
msgid "[Functions](../../fn.md)"
msgstr "[함수](../../fn.md)"

#: src/scope/lifetime/methods.md:3
msgid "Methods are annotated similarly to functions:"
msgstr "메서드는 함수와 유사하게 어노테이션됩니다:"

#: src/scope/lifetime/methods.md:9
msgid "// Annotate lifetimes as in a standalone function.\n"
msgstr "// 독립형 함수처럼 라이프타임을 어노테이션합니다.\n"

#: src/scope/lifetime/methods.md:12
msgid "\"`print`: {}\""
msgstr "\"`print`: {}\""

#: src/scope/lifetime/methods.md:26
msgid "[methods](../../fn/methods.md)"
msgstr "[메서드](../../fn/methods.md)"

#: src/scope/lifetime/struct.md:3
msgid "Annotation of lifetimes in structures are also similar to functions:"
msgstr "구조체에서의 라이프타임 어노테이션도 함수와 비슷합니다:"

#: src/scope/lifetime/struct.md:6
msgid ""
"// A type `Borrowed` which houses a reference to an\n"
"// `i32`. The reference to `i32` must outlive `Borrowed`.\n"
msgstr ""
"// `i32`에 대한 참조를 보관하는 `Borrowed` 타입입니다.\n"
"// `i32`에 대한 참조는 `Borrowed`보다 오래 살아야 합니다.\n"

#: src/scope/lifetime/struct.md:10
msgid "// Similarly, both references here must outlive this structure.\n"
msgstr "// 마찬가지로, 여기의 두 참조는 이 구조체보다 오래 살아야 합니다.\n"

#: src/scope/lifetime/struct.md:17
msgid "// An enum which is either an `i32` or a reference to one.\n"
msgstr "// `i32`이거나 이에 대한 참조인 열거형입니다.\n"

#: src/scope/lifetime/struct.md:34 src/scope/lifetime/struct.md:36
msgid "\"x is borrowed in {:?}\""
msgstr "\"x는 {:?}에서 빌려졌습니다\""

#: src/scope/lifetime/struct.md:35
msgid "\"x and y are borrowed in {:?}\""
msgstr "\"x와 y는 {:?}에서 빌려졌습니다\""

#: src/scope/lifetime/struct.md:37
msgid "\"y is *not* borrowed in {:?}\""
msgstr "\"y는 {:?}에서 빌려지지 *않았습니다*\""

#: src/scope/lifetime/struct.md:43
msgid "[`struct`s](../../custom_types/structs.md)"
msgstr "[`struct`](../../custom_types/structs.md)"

#: src/scope/lifetime/trait.md:3
msgid ""
"Annotation of lifetimes in trait methods basically are similar to functions. "
"Note that `impl` may have annotation of lifetimes too."
msgstr ""
"트레이트 메서드의 라이프타임 어노테이션은 기본적으로 함수와 유사합니다. "
"`impl`도 라이프타임 어노테이션을 가질 수 있음에 유의하세요."

#: src/scope/lifetime/trait.md:7
msgid "// A struct with annotation of lifetimes.\n"
msgstr "// 라이프타임 어노테이션이 있는 구조체.\n"

#: src/scope/lifetime/trait.md:12
msgid "// Annotate lifetimes to impl.\n"
msgstr "// impl에 라이프타임을 어노테이션합니다.\n"

#: src/scope/lifetime/trait.md:24
msgid "\"b is {:?}\""
msgstr "\"b는 {:?}입니다\""

#: src/scope/lifetime/trait.md:30
msgid "[`trait`s](../../trait.md)"
msgstr "[`trait`](../../trait.md)"

#: src/scope/lifetime/lifetime_bounds.md:3
msgid ""
"Just like generic types can be bounded, lifetimes (themselves generic) use "
"bounds as well. The `:` character has a slightly different meaning here, but "
"`+` is the same. Note how the following read:"
msgstr ""
"제네릭 타입이 바운드될 수 있는 것처럼, (그 자체로 제네릭인) 라이프타임도 바운"
"드를 사용합니다. 여기서 `:` 문자는 약간 다른 의미를 갖지만, `+`는 동일합니"
"다. 다음이 어떻게 읽히는지 주목하세요:"

#: src/scope/lifetime/lifetime_bounds.md:7
msgid "`T: 'a`: _All_ references in `T` must outlive lifetime `'a`."
msgstr ""
"`T: 'a`: `T` 내의 _모든_ 참조는 라이프타임 `'a`보다 오래 살아야 합니다."

#: src/scope/lifetime/lifetime_bounds.md:8
msgid ""
"`T: Trait + 'a`: Type `T` must implement trait `Trait` and _all_ references "
"in `T` must outlive `'a`."
msgstr ""
"`T: Trait + 'a`: 타입 `T`는 트레이트 `Trait`를 구현해야 하며, `T` 내의 _모든"
"_ 참조는 `'a`보다 오래 살아야 합니다."

#: src/scope/lifetime/lifetime_bounds.md:11
msgid ""
"The example below shows the above syntax in action used after keyword "
"`where`:"
msgstr ""
"아래 예제는 `where` 키워드 뒤에 사용된 위 구문의 실제 사용 예를 보여줍니다:"

#: src/scope/lifetime/lifetime_bounds.md:14
msgid "// Trait to bound with.\n"
msgstr "// 바운드할 트레이트.\n"

#: src/scope/lifetime/lifetime_bounds.md:17
msgid ""
"// `Ref` contains a reference to a generic type `T` that has\n"
"// some lifetime `'a` unknown by `Ref`. `T` is bounded such that any\n"
"// *references* in `T` must outlive `'a`. Additionally, the lifetime\n"
"// of `Ref` may not exceed `'a`.\n"
msgstr ""
"// `Ref`는 `Ref`가 알 수 없는 어떤 라이프타임 `'a`를 가진 제네릭 타입 `T`에 "
"대한\n"
"// 참조를 포함합니다. `T`는 `T` 내부의 모든 *참조*가 `'a`보다 오래 살아야 한"
"다는\n"
"// 바운드를 가집니다. 추가적으로, `Ref`의 라이프타임은 `'a`를 초과할 수 없습"
"니다.\n"

#: src/scope/lifetime/lifetime_bounds.md:22
msgid "// A generic function which prints using the `Debug` trait.\n"
msgstr "// `Debug` 트레이트를 사용하여 출력하는 제네릭 함수.\n"

#: src/scope/lifetime/lifetime_bounds.md:26
msgid "\"`print`: t is {:?}\""
msgstr "\"`print`: t는 {:?}입니다\""

#: src/scope/lifetime/lifetime_bounds.md:28
msgid ""
"// Here a reference to `T` is taken where `T` implements\n"
"// `Debug` and all *references* in `T` outlive `'a`. In\n"
"// addition, `'a` must outlive the function.\n"
msgstr ""
"// 여기서 `T`는 `Debug`를 구현하고 `T`의 모든 *참조*가 `'a`보다 오래 사는\n"
"// `T`에 대한 참조를 받습니다. 또한, `'a`는 함수보다 오래 살아야 합니다.\n"

#: src/scope/lifetime/lifetime_bounds.md:34
msgid "\"`print_ref`: t is {:?}\""
msgstr "\"`print_ref`: t는 {:?}입니다\""

#: src/scope/lifetime/lifetime_bounds.md:48
msgid ""
"[generics](../../generics.md), [bounds in generics](../../generics/"
"bounds.md), and [multiple bounds in generics](../../generics/multi_bounds.md)"
msgstr ""
"[제네릭](../../generics.md), [제네릭의 바운드](../../generics/bounds.md), 그"
"리고 [제네릭의 다중 바운드](../../generics/multi_bounds.md)"

#: src/scope/lifetime/lifetime_coercion.md:3
msgid ""
"A longer lifetime can be coerced into a shorter one so that it works inside "
"a scope it normally wouldn't work in. This comes in the form of inferred "
"coercion by the Rust compiler, and also in the form of declaring a lifetime "
"difference:"
msgstr ""
"더 긴 라이프타임은 평소에는 작동하지 않을 스코프 내에서도 작동하도록 더 짧은 "
"라이프타임으로 강제 변환(coerced)될 수 있습니다. 이는 Rust 컴파일러에 의한 추"
"론된 강제 변환 형태와 라이프타임 차이를 선언하는 형태로 나타납니다:"

#: src/scope/lifetime/lifetime_coercion.md:9
msgid ""
"// Here, Rust infers a lifetime that is as short as possible.\n"
"// The two references are then coerced to that lifetime.\n"
msgstr ""
"// 여기서 Rust는 가능한 한 짧은 라이프타임을 추론합니다.\n"
"// 그 후 두 참조는 해당 라이프타임으로 강제 변환됩니다.\n"

#: src/scope/lifetime/lifetime_coercion.md:14
msgid ""
"// `<'a: 'b, 'b>` reads as lifetime `'a` is at least as long as `'b`.\n"
"// Here, we take in an `&'a i32` and return a `&'b i32` as a result of "
"coercion.\n"
msgstr ""
"// `<'a: 'b, 'b>`는 라이프타임 `'a`가 적어도 `'b`만큼 길다는 뜻으로 읽힙니"
"다.\n"
"// 여기서 우리는 `&'a i32`를 받아 강제 변환의 결과로 `&'b i32`를 반환합니"
"다.\n"

#: src/scope/lifetime/lifetime_coercion.md:22
msgid "// Longer lifetime\n"
msgstr "// 더 긴 라이프타임\n"

#: src/scope/lifetime/lifetime_coercion.md:25
msgid "// Shorter lifetime\n"
msgstr "// 더 짧은 라이프타임\n"

#: src/scope/lifetime/lifetime_coercion.md:27
msgid "\"The product is {}\""
msgstr "\"곱은 {}입니다\""

#: src/scope/lifetime/lifetime_coercion.md:28
msgid "\"{} is the first\""
msgstr "\"{}은(는) 첫 번째입니다\""

#: src/scope/lifetime/static_lifetime.md:3
msgid ""
"Rust has a few reserved lifetime names. One of those is `'static`. You might "
"encounter it in two situations:"
msgstr ""
"Rust에는 몇 가지 예약된 라이프타임 이름이 있습니다. 그중 하나가 `'static`입니"
"다. 두 가지 상황에서 이를 마주칠 수 있습니다:"

#: src/scope/lifetime/static_lifetime.md:7
msgid "// A reference with 'static lifetime:\n"
msgstr "// 'static 라이프타임을 가진 참조:\n"

#: src/scope/lifetime/static_lifetime.md:8
msgid "\"hello world\""
msgstr "\"안녕 세상\""

#: src/scope/lifetime/static_lifetime.md:9
msgid "// 'static as part of a trait bound:\n"
msgstr "// 트레이트 바운드의 일부로서의 'static:\n"

#: src/scope/lifetime/static_lifetime.md:14
msgid ""
"Both are related but subtly different and this is a common source for "
"confusion when learning Rust. Here are some examples for each situation:"
msgstr ""
"두 가지는 관련이 있지만 미묘하게 다르며, 이는 Rust를 배울 때 흔한 혼란의 원인"
"이 됩니다. 각 상황에 대한 몇 가지 예시를 소개합니다:"

#: src/scope/lifetime/static_lifetime.md:17
msgid "Reference lifetime"
msgstr "참조 라이프타임"

#: src/scope/lifetime/static_lifetime.md:19
msgid ""
"As a reference lifetime `'static` indicates that the data pointed to by the "
"reference lives for the remaining lifetime of the running program. It can "
"still be coerced to a shorter lifetime."
msgstr ""
"참조 라이프타임으로서 `'static`은 참조가 가리키는 데이터가 실행 중인 프로그램"
"의 남은 수명 동안 살아있음을 나타냅니다. 여전히 더 짧은 라이프타임으로 강제 "
"변환될 수 있습니다."

#: src/scope/lifetime/static_lifetime.md:23
msgid ""
"There are two common ways to make a variable with `'static` lifetime, and "
"both are stored in the read-only memory of the binary:"
msgstr ""
"`'static` 라이프타임을 가진 변수를 만드는 두 가지 일반적인 방법이 있으며, 둘 "
"다 바이너리의 읽기 전용 메모리에 저장됩니다:"

#: src/scope/lifetime/static_lifetime.md:26
msgid "Make a constant with the `static` declaration."
msgstr "`static` 선언으로 상수를 만듭니다."

#: src/scope/lifetime/static_lifetime.md:27
msgid "Make a `string` literal which has type: `&'static str`."
msgstr "`&'static str` 타입을 갖는 `문자열` 리터럴을 만듭니다."

#: src/scope/lifetime/static_lifetime.md:29
msgid "See the following example for a display of each method:"
msgstr "각 방법에 대한 예제는 다음을 참조하세요:"

#: src/scope/lifetime/static_lifetime.md:32
msgid "// Make a constant with `'static` lifetime.\n"
msgstr "// `'static` 라이프타임을 가진 상수를 만듭니다.\n"

#: src/scope/lifetime/static_lifetime.md:34
msgid ""
"// Returns a reference to `NUM` where its `'static`\n"
"// lifetime is coerced to that of the input argument.\n"
msgstr ""
"// `NUM`에 대한 참조를 반환합니다. 여기서 `NUM`의 `'static`\n"
"// 라이프타임은 입력 인자의 라이프타임으로 강제 변환됩니다.\n"

#: src/scope/lifetime/static_lifetime.md:43
msgid "// Make a `string` literal and print it:\n"
msgstr "// `문자열` 리터럴을 만들고 출력합니다:\n"

#: src/scope/lifetime/static_lifetime.md:44
msgid "\"I'm in read-only memory\""
msgstr "\"저는 읽기 전용 메모리에 있습니다\""

#: src/scope/lifetime/static_lifetime.md:45
msgid "\"static_string: {}\""
msgstr "\"static_string: {}\""

#: src/scope/lifetime/static_lifetime.md:47
msgid ""
"// When `static_string` goes out of scope, the reference\n"
"        // can no longer be used, but the data remains in the binary.\n"
msgstr ""
"// `static_string`이 스코프를 벗어나면, 참조는\n"
"// 더 이상 사용할 수 없지만, 데이터는 바이너리에 남아 있습니다.\n"

#: src/scope/lifetime/static_lifetime.md:52
msgid "// Make an integer to use for `coerce_static`:\n"
msgstr "// `coerce_static`에 사용할 정수를 만듭니다:\n"

#: src/scope/lifetime/static_lifetime.md:55
msgid "// Coerce `NUM` to lifetime of `lifetime_num`:\n"
msgstr "// `NUM`을 `lifetime_num`의 라이프타임으로 강제 변환합니다:\n"

#: src/scope/lifetime/static_lifetime.md:58
msgid "\"coerced_static: {}\""
msgstr "\"강제 변환된 static: {}\""

#: src/scope/lifetime/static_lifetime.md:61
msgid "\"NUM: {} stays accessible!\""
msgstr "\"NUM: {} 여전히 접근 가능합니다!\""

#: src/scope/lifetime/static_lifetime.md:65
msgid ""
"Since `'static` references only need to be valid for the _remainder_ of a "
"program's life, they can be created while the program is executed. Just to "
"demonstrate, the below example uses [`Box::leak`](https://doc.rust-lang.org/"
"std/boxed/struct.Box.html#method.leak) to dynamically create `'static` "
"references. In that case it definitely doesn't live for the entire duration, "
"but only from the leaking point onward."
msgstr ""
"`'static` 참조는 프로그램 수명의 _나머지_ 기간 동안만 유효하면 되므로, 프로그"
"램이 실행되는 동안 생성될 수 있습니다. 아래 예제는 [`Box::leak`](https://"
"doc.rust-lang.org/std/boxed/struct.Box.html#method.leak)를 사용하여 "
"`'static` 참조를 동적으로 생성하는 방법을 보여줍니다. 이 경우 전체 기간 동안 "
"살아있는 것은 아니지만, 누수 지점부터는 계속 살아있습니다."

#: src/scope/lifetime/static_lifetime.md:90
msgid "Trait bound"
msgstr "트레이트 바운드"

#: src/scope/lifetime/static_lifetime.md:92
msgid ""
"As a trait bound, it means the type does not contain any non-static "
"references. Eg. the receiver can hold on to the type for as long as they "
"want and it will never become invalid until they drop it."
msgstr ""
"트레이트 바운드로서, 이는 해당 타입이 정적이지 않은(non-static) 참조를 포함하"
"지 않음을 의미합니다. 예를 들어, 수신자는 원하는 만큼 해당 타입을 보유할 수 "
"있으며, 드롭할 때까지 절대 유효하지 않게 되지 않습니다."

#: src/scope/lifetime/static_lifetime.md:96
msgid ""
"It's important to understand this means that any owned data always passes a "
"`'static` lifetime bound, but a reference to that owned data generally does "
"not:"
msgstr ""
"이것이 의미하는 바를 이해하는 것이 중요합니다. 모든 소유된 데이터는 항상 "
"`'static` 라이프타임 바운드를 통과하지만, 소유된 데이터에 대한 참조는 일반적"
"으로 그렇지 않습니다:"

#: src/scope/lifetime/static_lifetime.md:104
msgid "\"'static value passed in is: {:?}\""
msgstr "\"'static 값이 전달되었습니다: {:?}\""

#: src/scope/lifetime/static_lifetime.md:108
msgid "// i is owned and contains no references, thus it's 'static:\n"
msgstr "// i는 소유된 데이터이며 참조를 포함하지 않으므로 'static입니다:\n"

#: src/scope/lifetime/static_lifetime.md:112
msgid ""
"// oops, &i only has the lifetime defined by the scope of\n"
"    // main(), so it's not 'static:\n"
msgstr ""
"// 이런, &i는 main()의 스코프에 의해 정의된 라이프타임만\n"
"// 가지므로 'static이 아닙니다:\n"

#: src/scope/lifetime/static_lifetime.md:118
msgid "The compiler will tell you:"
msgstr "컴파일러는 다음과 같이 알려줄 것입니다:"

#: src/scope/lifetime/static_lifetime.md:135
msgid "[`'static` constants](../../custom_types/constants.md)"
msgstr "[`'static` 상수](../../custom_types/constants.md)"

#: src/scope/lifetime/elision.md:3
msgid ""
"Some lifetime patterns are overwhelmingly common and so the borrow checker "
"will allow you to omit them to save typing and to improve readability. This "
"is known as elision. Elision exists in Rust solely because these patterns "
"are common."
msgstr ""
"일부 라이프타임 패턴은 압도적으로 흔해서, 빌림 검사기는 타이핑을 줄이고 가독"
"성을 높이기 위해 이를 생략할 수 있게 해줍니다. 이를 생략(elision)이라고 합니"
"다. 생략은 오직 이러한 패턴이 흔하다는 이유만으로 Rust에 존재합니다."

#: src/scope/lifetime/elision.md:8
msgid ""
"The following code shows a few examples of elision. For a more comprehensive "
"description of elision, see [lifetime elision](https://doc.rust-lang.org/"
"book/ch10-03-lifetime-syntax.html#lifetime-elision) in the book."
msgstr ""
"다음 코드는 생략의 몇 가지 예시를 보여줍니다. 생략에 대한 더 포괄적인 설명은 "
"책의 [라이프타임 생략](https://doc.rust-lang.org/book/ch10-03-lifetime-"
"syntax.html#lifetime-elision)을 참조하세요."

#: src/scope/lifetime/elision.md:12
msgid ""
"// `elided_input` and `annotated_input` essentially have identical "
"signatures\n"
"// because the lifetime of `elided_input` is inferred by the compiler:\n"
msgstr ""
"// `elided_input`과 `annotated_input`은 본질적으로 동일한 시그니처를 가집니"
"다.\n"
"// `elided_input`의 라이프타임이 컴파일러에 의해 추론되기 때문입니다:\n"

#: src/scope/lifetime/elision.md:15
msgid "\"`elided_input`: {}\""
msgstr "\"`elided_input`: {}\""

#: src/scope/lifetime/elision.md:19
msgid "\"`annotated_input`: {}\""
msgstr "\"`annotated_input`: {}\""

#: src/scope/lifetime/elision.md:21
msgid ""
"// Similarly, `elided_pass` and `annotated_pass` have identical signatures\n"
"// because the lifetime is added implicitly to `elided_pass`:\n"
msgstr ""
"// 마찬가지로, `elided_pass`와 `annotated_pass`는 동일한 시그니처를 가집니"
"다.\n"
"// 라이프타임이 `elided_pass`에 암시적으로 추가되기 때문입니다:\n"

#: src/scope/lifetime/elision.md:34
msgid "\"`elided_pass`: {}\""
msgstr "\"`elided_pass`: {}\""

#: src/scope/lifetime/elision.md:35
msgid "\"`annotated_pass`: {}\""
msgstr "\"`annotated_pass`: {}\""

#: src/scope/lifetime/elision.md:41
msgid ""
"[elision](https://doc.rust-lang.org/book/ch10-03-lifetime-"
"syntax.html#lifetime-elision)"
msgstr ""
"[생략](https://doc.rust-lang.org/book/ch10-03-lifetime-syntax.html#lifetime-"
"elision)"

#: src/trait.md:3
msgid ""
"A `trait` is a collection of methods defined for an unknown type: `Self`. "
"They can access other methods declared in the same trait."
msgstr ""
"`trait`는 알 수 없는 타입 `Self`에 대해 정의된 메서드들의 모음입니다. 이들은 "
"동일한 트레이트 내에 선언된 다른 메서드에 접근할 수 있습니다."

#: src/trait.md:6
msgid ""
"Traits can be implemented for any data type. In the example below, we define "
"`Animal`, a group of methods. The `Animal` `trait` is then implemented for "
"the `Sheep` data type, allowing the use of methods from `Animal` with a "
"`Sheep`."
msgstr ""
"트레이트는 모든 데이터 타입에 대해 구현될 수 있습니다. 아래 예제에서는 메서"
"드 그룹인 `Animal`을 정의합니다. 그런 다음 `Animal` `trait`를 `Sheep` 데이터 "
"타입에 대해 구현하여 `Sheep`으로 `Animal`의 메서드를 사용할 수 있게 합니다."

#: src/trait.md:15
msgid ""
"// Associated function signature; `Self` refers to the implementor type.\n"
msgstr "// 연관 함수 시그니처; `Self`는 구현하는 타입을 가리킵니다.\n"

#: src/trait.md:18
msgid "// Method signatures; these will return a string.\n"
msgstr "// 메서드 시그니처; 이들은 문자열을 반환할 것입니다.\n"

#: src/trait.md:22
msgid "// Traits can provide default method definitions.\n"
msgstr "// 트레이트는 기본 메서드 정의를 제공할 수 있습니다.\n"

#: src/trait.md:24
msgid "\"{} says {}\""
msgstr "\"{}가 말하길 {}\""

#: src/trait.md:35
msgid "// Implementor methods can use the implementor's trait methods.\n"
msgstr "// 구현자의 메서드는 구현자의 트레이트 메서드를 사용할 수 있습니다.\n"

#: src/trait.md:36
msgid "\"{} is already naked...\""
msgstr "\"{}는 이미 벌거벗었습니다...\""

#: src/trait.md:38
msgid "\"{} gets a haircut!\""
msgstr "\"{}가 털을 깎습니다!\""

#: src/trait.md:44 src/trait/dyn.md:25
msgid "// Implement the `Animal` trait for `Sheep`.\n"
msgstr "// `Sheep`에 대해 `Animal` 트레이트를 구현합니다.\n"

#: src/trait.md:47
msgid "// `Self` is the implementor type: `Sheep`.\n"
msgstr "// `Self`는 구현하는 타입인 `Sheep`입니다.\n"

#: src/trait.md:58
msgid "\"baaaaah?\""
msgstr "\"메에에에?\""

#: src/trait.md:60 src/trait/dyn.md:29
msgid "\"baaaaah!\""
msgstr "\"메에에에!\""

#: src/trait.md:64
msgid "// Default trait methods can be overridden.\n"
msgstr "// 기본 트레이트 메서드는 재정의(오버라이드)될 수 있습니다.\n"

#: src/trait.md:66
msgid "// For example, we can add some quiet contemplation.\n"
msgstr "// 예를 들어, 조용한 사색을 추가할 수 있습니다.\n"

#: src/trait.md:67
msgid "\"{} pauses briefly... {}\""
msgstr "\"{}가 잠시 멈춥니다... {}\""

#: src/trait.md:72
msgid "// Type annotation is necessary in this case.\n"
msgstr "// 이 경우에는 타입 어노테이션이 필요합니다.\n"

#: src/trait.md:73
msgid "\"Dolly\""
msgstr "\"돌리\""

#: src/trait.md:74
msgid "// TODO ^ Try removing the type annotations.\n"
msgstr "// TODO ^ 타입 어노테이션을 제거해 보세요.\n"

#: src/trait/derive.md:3
msgid ""
"The compiler is capable of providing basic implementations for some traits "
"via the `#[derive]` [attribute](../attribute.md). These traits can still be "
"manually implemented if a more complex behavior is required."
msgstr ""
"컴파일러는 `#[derive]` [속성](../attribute.md)을 통해 일부 트레이트에 대한 기"
"본적인 구현을 제공할 수 있습니다. 더 복잡한 동작이 필요한 경우에는 이러한 트"
"레이트들을 수동으로 구현할 수도 있습니다."

#: src/trait/derive.md:7
msgid "The following is a list of derivable traits:"
msgstr "다음은 derive 가능한 트레이트 목록입니다:"

#: src/trait/derive.md:9
msgid ""
"Comparison traits: [`Eq`](https://doc.rust-lang.org/std/cmp/trait.Eq.html), "
"[`PartialEq`](https://doc.rust-lang.org/std/cmp/trait.PartialEq.html), "
"[`Ord`](https://doc.rust-lang.org/std/cmp/trait.Ord.html), [`PartialOrd`]"
"(https://doc.rust-lang.org/std/cmp/trait.PartialOrd.html)."
msgstr ""
"비교 트레이트: [`Eq`](https://doc.rust-lang.org/std/cmp/trait.Eq.html), "
"[`PartialEq`](https://doc.rust-lang.org/std/cmp/trait.PartialEq.html), "
"[`Ord`](https://doc.rust-lang.org/std/cmp/trait.Ord.html), [`PartialOrd`]"
"(https://doc.rust-lang.org/std/cmp/trait.PartialOrd.html)."

#: src/trait/derive.md:11
msgid ""
"[`Clone`](https://doc.rust-lang.org/std/clone/trait.Clone.html), to create "
"`T` from `&T` via a copy."
msgstr ""
"[`Clone`](https://doc.rust-lang.org/std/clone/trait.Clone.html), 복사를 통해 "
"`&T`로부터 `T`를 생성합니다."

#: src/trait/derive.md:12
msgid ""
"[`Copy`](https://doc.rust-lang.org/core/marker/trait.Copy.html), to give a "
"type 'copy semantics' instead of 'move semantics'."
msgstr ""
"[`Copy`](https://doc.rust-lang.org/core/marker/trait.Copy.html), 타입에 '이"
"동 의미론(move semantics)' 대신 '복사 의미론(copy semantics)'을 부여합니다."

#: src/trait/derive.md:13
msgid ""
"[`Hash`](https://doc.rust-lang.org/std/hash/trait.Hash.html), to compute a "
"hash from `&T`."
msgstr ""
"[`Hash`](https://doc.rust-lang.org/std/hash/trait.Hash.html), `&T`로부터 해시"
"를 계산합니다."

#: src/trait/derive.md:14
msgid ""
"[`Default`](https://doc.rust-lang.org/std/default/trait.Default.html), to "
"create an empty instance of a data type."
msgstr ""
"[`Default`](https://doc.rust-lang.org/std/default/trait.Default.html), 데이"
"터 타입의 빈 인스턴스를 생성합니다."

#: src/trait/derive.md:15
msgid ""
"[`Debug`](https://doc.rust-lang.org/std/fmt/trait.Debug.html), to format a "
"value using the `{:?}` formatter."
msgstr ""
"[`Debug`](https://doc.rust-lang.org/std/fmt/trait.Debug.html), `{:?}` 포맷터"
"를 사용하여 값을 형식화합니다."

#: src/trait/derive.md:18
msgid "// `Centimeters`, a tuple struct that can be compared\n"
msgstr "// `Centimeters`, 비교 가능한 튜플 구조체\n"

#: src/trait/derive.md:21
msgid "// `Inches`, a tuple struct that can be printed\n"
msgstr "// `Inches`, 출력 가능한 튜플 구조체\n"

#: src/trait/derive.md:33
msgid "// `Seconds`, a tuple struct with no additional attributes\n"
msgstr "// `Seconds`, 추가 속성이 없는 튜플 구조체\n"

#: src/trait/derive.md:40
msgid ""
"// Error: `Seconds` can't be printed; it doesn't implement the `Debug` "
"trait\n"
"    //println!(\"One second looks like: {:?}\", _one_second);\n"
"    // TODO ^ Try uncommenting this line\n"
msgstr ""
"// 에러: `Seconds`는 출력될 수 없습니다. `Debug` 트레이트를 구현하지 않았기 "
"때문입니다.\n"
"    //println!(\"One second looks like: {:?}\", _one_second);\n"
"    // TODO ^ 이 줄의 주석을 해제해 보세요.\n"

#: src/trait/derive.md:44
msgid ""
"// Error: `Seconds` can't be compared; it doesn't implement the `PartialEq` "
"trait\n"
"    //let _this_is_true = (_one_second == _one_second);\n"
"    // TODO ^ Try uncommenting this line\n"
msgstr ""
"// 에러: `Seconds`는 비교될 수 없습니다. `PartialEq` 트레이트를 구현하지 않았"
"기 때문입니다.\n"
"    //let _this_is_true = (_one_second == _one_second);\n"
"    // TODO ^ 이 줄의 주석을 해제해 보세요.\n"

#: src/trait/derive.md:50
msgid "\"One foot equals {:?}\""
msgstr "\"1피트는 {:?}와 같습니다.\""

#: src/trait/derive.md:56
msgid "\"smaller\""
msgstr "\"더 작습니다\""

#: src/trait/derive.md:58
msgid "\"bigger\""
msgstr "\"더 큽니다\""

#: src/trait/derive.md:61
msgid "\"One foot is {} than one meter.\""
msgstr "\"1피트는 1미터보다 {}.\""

#: src/trait/derive.md:67
msgid "[`derive`](https://doc.rust-lang.org/reference/attributes.html#derive)"
msgstr "[`derive`](https://doc.rust-lang.org/reference/attributes.html#derive)"

#: src/trait/dyn.md:3
msgid ""
"The Rust compiler needs to know how much space every function's return type "
"requires. This means all your functions have to return a concrete type. "
"Unlike other languages, if you have a trait like `Animal`, you can't write a "
"function that returns `Animal`, because its different implementations will "
"need different amounts of memory."
msgstr ""
"Rust 컴파일러는 모든 함수의 반환 타입이 얼마나 많은 공간을 필요로 하는지 알아"
"야 합니다. 이는 여러분의 모든 함수가 구체적인 타입을 반환해야 함을 의미합니"
"다. 다른 언어와 달리, `Animal`과 같은 트레이트가 있을 때 `Animal`을 반환하는 "
"함수를 작성할 수 없는데, 그 이유는 서로 다른 구현체들이 서로 다른 양의 메모리"
"를 필요로 하기 때문입니다."

#: src/trait/dyn.md:8
msgid ""
"However, there's an easy workaround. Instead of returning a trait object "
"directly, our functions return a `Box` which _contains_ some `Animal`. A "
"`box` is just a reference to some memory in the heap. Because a reference "
"has a statically-known size, and the compiler can guarantee it points to a "
"heap-allocated `Animal`, we can return a trait from our function!"
msgstr ""
"하지만 쉬운 해결 방법이 있습니다. 트레이트 객체를 직접 반환하는 대신, 우리 함"
"수는 어떤 `Animal`을 *포함하는* `Box`를 반환합니다. `Box`는 단지 힙 메모리에 "
"대한 참조일 뿐입니다. 참조는 정적으로 알려진 크기를 가지며, 컴파일러는 그것"
"이 힙에 할당된 `Animal`을 가리키고 있음을 보장할 수 있으므로, 우리 함수에서 "
"트레이트를 반환할 수 있게 됩니다!"

#: src/trait/dyn.md:13
msgid ""
"Rust tries to be as explicit as possible whenever it allocates memory on the "
"heap. So if your function returns a pointer-to-trait-on-heap in this way, "
"you need to write the return type with the `dyn` keyword, e.g. `Box<dyn "
"Animal>`."
msgstr ""
"Rust는 힙에 메모리를 할당할 때마다 가능한 한 명시적이려고 노력합니다. 따라서 "
"여러분의 함수가 이런 방식으로 힙상의 트레이트에 대한 포인터를 반환한다면, 반"
"환 타입에 `dyn` 키워드를 사용해야 합니다. 예: `Box<dyn Animal>`."

#: src/trait/dyn.md:22
msgid "// Instance method signature\n"
msgstr "// 인스턴스 메서드 시그니처\n"

#: src/trait/dyn.md:32
msgid "// Implement the `Animal` trait for `Cow`.\n"
msgstr "// `Cow`에 대해 `Animal` 트레이트를 구현합니다.\n"

#: src/trait/dyn.md:36
msgid "\"moooooo!\""
msgstr "\"음메~!\""

#: src/trait/dyn.md:39
msgid ""
"// Returns some struct that implements Animal, but we don't know which one "
"at compile time.\n"
msgstr ""
"// `Animal`을 구현하는 어떤 구조체를 반환하지만, 컴파일 타임에는 그것이 무엇"
"인지 알 수 없습니다.\n"

#: src/trait/dyn.md:52
msgid "\"You've randomly chosen an animal, and it says {}\""
msgstr "\"동물을 무작위로 선택했고, 그 동물은 {}라고 말합니다.\""

#: src/trait/ops.md:3
msgid ""
"In Rust, many of the operators can be overloaded via traits. That is, some "
"operators can be used to accomplish different tasks based on their input "
"arguments. This is possible because operators are syntactic sugar for method "
"calls. For example, the `+` operator in `a + b` calls the `add` method (as "
"in `a.add(b)`). This `add` method is part of the `Add` trait. Hence, the `+` "
"operator can be used by any implementor of the `Add` trait."
msgstr ""
"Rust에서 많은 연산자들은 트레이트를 통해 오버로딩될 수 있습니다. 즉, 일부 연"
"산자들은 입력 인자에 따라 서로 다른 작업을 수행하는 데 사용될 수 있습니다. 이"
"는 연산자가 메서드 호출의 구문 설탕(syntactic sugar)이기 때문에 가능합니다. "
"예를 들어, `a + b`에서의 `+` 연산자는 (`a.add(b)`와 같이) `add` 메서드를 호출"
"합니다. 이 `add` 메서드는 `Add` 트레이트의 일부입니다. 따라서 `+` 연산자는 "
"`Add` 트레이트의 모든 구현체에서 사용될 수 있습니다."

#: src/trait/ops.md:9
msgid ""
"A list of the traits, such as `Add`, that overload operators can be found in "
"[`core::ops`](https://doc.rust-lang.org/core/ops/)."
msgstr ""
"연산자를 오버로딩하는 `Add`와 같은 트레이트들의 목록은 [`core::ops`](https://"
"doc.rust-lang.org/core/ops/)에서 찾을 수 있습니다."

#: src/trait/ops.md:22
msgid ""
"// The `std::ops::Add` trait is used to specify the functionality of `+`.\n"
"// Here, we make `Add<Bar>` - the trait for addition with a RHS of type "
"`Bar`.\n"
"// The following block implements the operation: Foo + Bar = FooBar\n"
msgstr ""
"// `std::ops::Add` 트레이트는 `+`의 기능을 지정하는 데 사용됩니다.\n"
"// 여기서 우리는 `Add<Bar>`를 만듭니다 - 이는 RHS(우항) 타입이 `Bar`인 덧셈"
"을 위한 트레이트입니다.\n"
"// 다음 블록은 Foo + Bar = FooBar 연산을 구현합니다.\n"

#: src/trait/ops.md:30
msgid "\"> Foo.add(Bar) was called\""
msgstr "\"> Foo.add(Bar)가 호출되었습니다\""

#: src/trait/ops.md:35
msgid ""
"// By reversing the types, we end up implementing non-commutative addition.\n"
"// Here, we make `Add<Foo>` - the trait for addition with a RHS of type "
"`Foo`.\n"
"// This block implements the operation: Bar + Foo = BarFoo\n"
msgstr ""
"// 타입을 반대로 함으로써, 우리는 비가환(non-commutative) 덧셈을 구현하게 됩"
"니다.\n"
"// 여기서 우리는 `Add<Foo>`를 만듭니다 - 이는 RHS 타입이 `Foo`인 덧셈을 위한 "
"트레이트입니다.\n"
"// 이 블록은 Bar + Foo = BarFoo 연산을 구현합니다.\n"

#: src/trait/ops.md:43
msgid "\"> Bar.add(Foo) was called\""
msgstr "\"> Bar.add(Foo)가 호출되었습니다\""

#: src/trait/ops.md:50
msgid "\"Foo + Bar = {:?}\""
msgstr "\"Foo + Bar = {:?}\""

#: src/trait/ops.md:51
msgid "\"Bar + Foo = {:?}\""
msgstr "\"Bar + Foo = {:?}\""

#: src/trait/ops.md:55 src/testing.md:16 src/testing/doc_testing.md:105
#: src/testing/dev_dependencies.md:36
msgid "See Also"
msgstr "참고"

#: src/trait/ops.md:57
msgid ""
"[Add](https://doc.rust-lang.org/core/ops/trait.Add.html), [Syntax Index]"
"(https://doc.rust-lang.org/book/appendix-02-operators.html)"
msgstr ""
"[Add](https://doc.rust-lang.org/core/ops/trait.Add.html), [구문 색인]"
"(https://doc.rust-lang.org/book/appendix-02-operators.html)"

#: src/trait/drop.md:3
msgid ""
"The [`Drop`](https://doc.rust-lang.org/std/ops/trait.Drop.html) trait only "
"has one method: `drop`, which is called automatically when an object goes "
"out of scope. The main use of the `Drop` trait is to free the resources that "
"the implementor instance owns."
msgstr ""
"[`Drop`](https://doc.rust-lang.org/std/ops/trait.Drop.html) 트레이트는 `drop`"
"이라는 하나의 메서드만을 가집니다. 이 메서드는 객체가 스코프를 벗어날 때 자동"
"으로 호출됩니다. `Drop` 트레이트의 주요 용도는 구현체 인스턴스가 소유한 리소"
"스를 해제하는 것입니다."

#: src/trait/drop.md:7
msgid ""
"`Box`, `Vec`, `String`, `File`, and `Process` are some examples of types "
"that implement the `Drop` trait to free resources. The `Drop` trait can also "
"be manually implemented for any custom data type."
msgstr ""
"`Box`, `Vec`, `String`, `File`, 그리고 `Process`는 리소스를 해제하기 위해 "
"`Drop` 트레이트를 구현하는 몇 가지 타입의 예입니다. `Drop` 트레이트는 임의의 "
"사용자 정의 데이터 타입에 대해 수동으로 구현될 수도 있습니다."

#: src/trait/drop.md:11
msgid ""
"The following example adds a print to console to the `drop` function to "
"announce when it is called."
msgstr ""
"다음 예제는 `drop` 함수가 호출될 때 알림을 주기 위해 콘솔 출력을 추가합니다."

#: src/trait/drop.md:18
msgid "// This trivial implementation of `drop` adds a print to console.\n"
msgstr "// 이 간단한 `drop` 구현은 콘솔에 출력을 추가합니다.\n"

#: src/trait/drop.md:22
msgid "\"> Dropping {}\""
msgstr "\"> {}를 해제합니다\""

#: src/trait/drop.md:27 src/std_misc/path.md:33 src/std_misc/fs.md:44
#: src/std_misc/fs.md:87
msgid "\"a\""
msgstr "\"a\""

#: src/trait/drop.md:29
msgid "// block A\n"
msgstr "// 블록 A\n"

#: src/trait/drop.md:31 src/std_misc/path.md:33
msgid "\"b\""
msgstr "\"b\""

#: src/trait/drop.md:33
msgid "// block B\n"
msgstr "// 블록 B\n"

#: src/trait/drop.md:35 src/std_misc/path.md:36
msgid "\"c\""
msgstr "\"c\""

#: src/trait/drop.md:36
msgid "\"d\""
msgstr "\"d\""

#: src/trait/drop.md:38
msgid "\"Exiting block B\""
msgstr "\"블록 B를 나가는 중\""

#: src/trait/drop.md:40
msgid "\"Just exited block B\""
msgstr "\"방금 블록 B를 나갔습니다\""

#: src/trait/drop.md:42
msgid "\"Exiting block A\""
msgstr "\"블록 A를 나가는 중\""

#: src/trait/drop.md:44
msgid "\"Just exited block A\""
msgstr "\"방금 블록 A를 나갔습니다\""

#: src/trait/drop.md:46
msgid "// Variable can be manually dropped using the `drop` function\n"
msgstr "// 변수는 `drop` 함수를 사용하여 수동으로 해제할 수 있습니다.\n"

#: src/trait/drop.md:48
msgid "// TODO ^ Try commenting this line\n"
msgstr "// TODO ^ 이 줄을 주석 처리해 보세요.\n"

#: src/trait/drop.md:50
msgid "\"end of the main function\""
msgstr "\"메인 함수 끝\""

#: src/trait/drop.md:52
msgid ""
"// `_a` *won't* be `drop`ed again here, because it already has been\n"
"    // (manually) `drop`ed\n"
msgstr ""
"// `_a`는 여기서 다시 `drop`되지 않습니다. 이미 (수동으로) `drop`되었기 때문"
"입니다.\n"

#: src/trait/drop.md:57
msgid ""
"For a more practical example, here's how the `Drop` trait can be used to "
"automatically clean up temporary files when they're no longer needed:"
msgstr ""
"더 실용적인 예로, `Drop` 트레이트를 사용하여 더 이상 필요하지 않은 임시 파일"
"을 자동으로 정리하는 방법은 다음과 같습니다:"

#: src/trait/drop.md:71
msgid "// Note: File::create() will overwrite existing files\n"
msgstr "// 참고: `File::create()`는 기존 파일을 덮어씁니다.\n"

#: src/trait/drop.md:77
msgid ""
"// When TempFile is dropped:\n"
"// 1. First, our drop implementation will remove the file's name from the "
"filesystem.\n"
"// 2. Then, File's drop will close the file, removing its underlying content "
"from the disk.\n"
msgstr ""
"// `TempFile`이 drop될 때:\n"
"// 1. 먼저, 우리가 작성한 drop 구현이 파일 시스템에서 파일 이름을 제거합니"
"다.\n"
"// 2. 그런 다음, `File`의 drop이 파일을 닫고 디스크에서 기본 콘텐츠를 제거합"
"니다.\n"

#: src/trait/drop.md:84
msgid "\"Failed to remove temporary file: {}\""
msgstr "\"임시 파일을 제거하는 데 실패했습니다: {}\""

#: src/trait/drop.md:86
msgid "\"> Dropped temporary file: {:?}\""
msgstr "\"> 임시 파일을 해제했습니다: {:?}\""

#: src/trait/drop.md:87
msgid ""
"// File's drop is implicitly called here because it is a field of this "
"struct.\n"
msgstr ""
"// `File`의 drop은 이 구조체의 필드이므로 여기서 암시적으로 호출됩니다.\n"

#: src/trait/drop.md:92
msgid "// Create a new scope to demonstrate drop behavior\n"
msgstr "// drop 동작을 시연하기 위해 새 스코프를 생성합니다.\n"

#: src/trait/drop.md:94
msgid "\"test.txt\""
msgstr "\"test.txt\""

#: src/trait/drop.md:95
msgid "\"Temporary file created\""
msgstr "\"임시 파일이 생성되었습니다\""

#: src/trait/drop.md:96
msgid "// File will be automatically cleaned up when temp goes out of scope\n"
msgstr "// `temp`가 스코프를 벗어날 때 파일이 자동으로 정리됩니다.\n"

#: src/trait/drop.md:98
msgid "\"End of scope - file should be cleaned up\""
msgstr "\"스코프 종료 - 파일이 정리되어야 합니다\""

#: src/trait/drop.md:100
msgid "// We can also manually drop if needed\n"
msgstr "// 필요하다면 수동으로 drop할 수도 있습니다.\n"

#: src/trait/drop.md:101
msgid "\"another_test.txt\""
msgstr "\"another_test.txt\""

#: src/trait/drop.md:102
msgid "// Explicitly drop the file\n"
msgstr "// 파일을 명시적으로 drop합니다.\n"

#: src/trait/drop.md:103
msgid "\"Manually dropped file\""
msgstr "\"수동으로 파일을 drop했습니다\""

#: src/trait/iter.md:3
msgid ""
"The [`Iterator`](https://doc.rust-lang.org/core/iter/trait.Iterator.html) "
"trait is used to implement iterators over collections such as arrays."
msgstr ""
"[`Iterator`](https://doc.rust-lang.org/core/iter/trait.Iterator.html) 트레이"
"트는 배열과 같은 컬렉션에 대한 이터레이터를 구현하는 데 사용됩니다."

#: src/trait/iter.md:6
msgid ""
"The trait requires only a method to be defined for the `next` element, which "
"may be manually defined in an `impl` block or automatically defined (as in "
"arrays and ranges)."
msgstr ""
"이 트레이트는 `next` 요소에 대해 정의될 메서드 하나만을 필요로 하며, 이는 "
"`impl` 블록에서 수동으로 정의하거나 (배열 및 범위와 같이) 자동으로 정의될 수 "
"있습니다."

#: src/trait/iter.md:10
msgid ""
"As a point of convenience for common situations, the `for` construct turns "
"some collections into iterators using the [`.into_iter()`](https://doc.rust-"
"lang.org/std/iter/trait.IntoIterator.html) method."
msgstr ""
"일반적인 상황에서의 편의를 위해, `for` 구문은 [`.into_iter()`](https://"
"doc.rust-lang.org/std/iter/trait.IntoIterator.html) 메서드를 사용하여 일부 컬"
"렉션을 이터레이터로 변환합니다."

#: src/trait/iter.md:18
msgid ""
"// Implement `Iterator` for `Fibonacci`.\n"
"// The `Iterator` trait only requires a method to be defined for the `next` "
"element,\n"
"// and an `associated type` to declare the return type of the iterator.\n"
msgstr ""
"// `Fibonacci`에 대해 `Iterator`를 구현합니다.\n"
"// `Iterator` 트레이트는 `next` 요소에 대해 정의될 메서드 하나와,\n"
"// 이터레이터의 반환 타입을 선언하기 위한 `연관 타입(associated type)`만을 필"
"요로 합니다.\n"

#: src/trait/iter.md:23
msgid "// We can refer to this type using Self::Item\n"
msgstr "// `Self::Item`을 사용하여 이 타입을 참조할 수 있습니다.\n"

#: src/trait/iter.md:26
msgid ""
"// Here, we define the sequence using `.curr` and `.next`.\n"
"    // The return type is `Option<T>`:\n"
"    //     * When the `Iterator` is finished, `None` is returned.\n"
"    //     * Otherwise, the next value is wrapped in `Some` and returned.\n"
"    // We use Self::Item in the return type, so we can change\n"
"    // the type without having to update the function signatures.\n"
msgstr ""
"// 여기서리는 `.curr`와 `.next`를 사용하여 수열을 정의합니다.\n"
"    // 반환 타입은 `Option<T>`입니다:\n"
"    //     * 이터레이터가 끝나면 `None`이 반환됩니다.\n"
"    //     * 그렇지 않으면 다음 값이 `Some`으로 감싸져서 반환됩니다.\n"
"    // 반환 타입에 `Self::Item`을 사용하므로, 함수 시그니처를 업데이트할 필"
"요 없이\n"
"    // 타입을 변경할 수 있습니다.\n"

#: src/trait/iter.md:38
msgid ""
"// Since there's no endpoint to a Fibonacci sequence, the `Iterator`\n"
"        // will never return `None`, and `Some` is always returned.\n"
msgstr ""
"// 피보나치 수열에는 끝이 없으므로, 이 `Iterator`는\n"
"        // 결코 `None`을 반환하지 않으며 항상 `Some`이 반환됩니다.\n"

#: src/trait/iter.md:43
msgid "// Returns a Fibonacci sequence generator\n"
msgstr "// 피보나치 수열 생성기를 반환합니다.\n"

#: src/trait/iter.md:50
msgid "// `0..3` is an `Iterator` that generates: 0, 1, and 2.\n"
msgstr "// `0..3`은 0, 1, 2를 생성하는 `Iterator`입니다.\n"

#: src/trait/iter.md:53
msgid "\"Four consecutive `next` calls on 0..3\""
msgstr "\"0..3에 대한 네 번의 연속적인 `next` 호출\""

#: src/trait/iter.md:54 src/trait/iter.md:55 src/trait/iter.md:56
#: src/trait/iter.md:57 src/std_misc/fs.md:90
msgid "\"> {:?}\""
msgstr "\"> {:?}\""

#: src/trait/iter.md:59
msgid ""
"// `for` works through an `Iterator` until it returns `None`.\n"
"    // Each `Some` value is unwrapped and bound to a variable (here, `i`).\n"
msgstr ""
"// `for`는 `None`이 반환될 때까지 `Iterator`를 통해 작동합니다.\n"
"    // 각 `Some` 값은 래핑이 해제되어 변수(여기서는 `i`)에 바인딩됩니다.\n"

#: src/trait/iter.md:61
msgid "\"Iterate through 0..3 using `for`\""
msgstr "\"`for`를 사용하여 0..3을 순회합니다\""

#: src/trait/iter.md:63 src/trait/iter.md:69 src/trait/iter.md:75
#: src/trait/iter.md:83 src/std/vec.md:50 src/std/str.md:22
#: src/std_misc/fs.md:82
msgid "\"> {}\""
msgstr "\"> {}\""

#: src/trait/iter.md:66
msgid "// The `take(n)` method reduces an `Iterator` to its first `n` terms.\n"
msgstr "// `take(n)` 메서드는 `Iterator`를 처음 `n`개의 항으로 줄입니다.\n"

#: src/trait/iter.md:67
msgid "\"The first four terms of the Fibonacci sequence are: \""
msgstr "\"피보나치 수열의 처음 네 항은 다음과 같습니다: \""

#: src/trait/iter.md:72
msgid ""
"// The `skip(n)` method shortens an `Iterator` by dropping its first `n` "
"terms.\n"
msgstr ""
"// `skip(n)` 메서드는 처음 `n`개의 항을 버리고 `Iterator`를 단축시킵니다.\n"

#: src/trait/iter.md:73
msgid "\"The next four terms of the Fibonacci sequence are: \""
msgstr "\"피보나치 수열의 다음 네 항은 다음과 같습니다: \""

#: src/trait/iter.md:80
msgid "// The `iter` method produces an `Iterator` over an array/slice.\n"
msgstr "// `iter` 메서드는 배열/슬라이스에 대한 `Iterator`를 생성합니다.\n"

#: src/trait/iter.md:81
msgid "\"Iterate the following array {:?}\""
msgstr "\"다음 배열 {:?}을 순회합니다\""

#: src/trait/impl_trait.md:3
msgid "`impl Trait` can be used in two locations:"
msgstr "`impl Trait`는 두 위치에서 사용될 수 있습니다:"

#: src/trait/impl_trait.md:5
msgid "as an argument type"
msgstr "인자 타입으로서"

#: src/trait/impl_trait.md:6
msgid "as a return type"
msgstr "반환 타입으로서"

#: src/trait/impl_trait.md:8
msgid "As an argument type"
msgstr "인자 타입으로서"

#: src/trait/impl_trait.md:10
msgid ""
"If your function is generic over a trait but you don't mind the specific "
"type, you can simplify the function declaration using `impl Trait` as the "
"type of the argument."
msgstr ""
"함수가 트레이트에 대해 제네릭이지만 구체적인 타입에는 관심이 없다면, 인자 타"
"입으로 `impl Trait`를 사용하여 함수 선언을 단순화할 수 있습니다."

#: src/trait/impl_trait.md:12
msgid "For example, consider the following code:"
msgstr "예를 들어, 다음 코드를 살펴보세요:"

#: src/trait/impl_trait.md:18 src/trait/impl_trait.md:37
msgid "// For each line in the source\n"
msgstr "// 소스의 각 줄에 대해\n"

#: src/trait/impl_trait.md:20 src/trait/impl_trait.md:39
msgid ""
"// If the line was read successfully, process it, if not, return the error\n"
msgstr ""
"// 줄을 성공적으로 읽었다면 처리하고, 그렇지 않으면 에러를 반환합니다\n"

#: src/trait/impl_trait.md:21 src/trait/impl_trait.md:40 src/std/str.md:41
msgid "','"
msgstr "','"

#: src/trait/impl_trait.md:21 src/trait/impl_trait.md:40
msgid "// Split the line separated by commas\n"
msgstr "// 콤마로 구분된 줄을 분할합니다\n"

#: src/trait/impl_trait.md:22 src/trait/impl_trait.md:41
msgid "// Remove leading and trailing whitespace\n"
msgstr "// 앞뒤 공백을 제거합니다\n"

#: src/trait/impl_trait.md:23 src/trait/impl_trait.md:42
msgid "// Collect all strings in a row into a Vec<String>\n"
msgstr "// 한 행의 모든 문자열을 `Vec<String>`으로 수집합니다\n"

#: src/trait/impl_trait.md:26 src/trait/impl_trait.md:45
msgid "// Collect all lines into a Vec<Vec<String>>\n"
msgstr "// 모든 줄을 `Vec<Vec<String>>`으로 수집합니다\n"

#: src/trait/impl_trait.md:30
msgid ""
"`parse_csv_document` is generic, allowing it to take any type which "
"implements BufRead, such as `BufReader<File>` or `[u8]`, but it's not "
"important what type `R` is, and `R` is only used to declare the type of "
"`src`, so the function can also be written as:"
msgstr ""
"`parse_csv_document`는 제네릭이어서 `BufReader<File>`이나 `[u8]`과 같이 "
"`BufRead`를 구현하는 모든 타입을 취할 수 있지만, `R`이 어떤 타입인지는 중요하"
"지 않고 `R`은 단지 `src`의 타입을 선언하는 데만 사용되므로, 다음과 같이 작성"
"할 수도 있습니다:"

#: src/trait/impl_trait.md:49
msgid ""
"Note that using `impl Trait` as an argument type means that you cannot "
"explicitly state what form of the function you use, i.e. "
"`parse_csv_document::<std::io::Empty>(std::io::empty())` will not work with "
"the second example."
msgstr ""
"`impl Trait`를 인자 타입으로 사용하는 것은 여러분이 함수의 어떤 형태를 사용하"
"는지 명시적으로 명시할 수 없음을 의미합니다. 즉, `parse_csv_document::"
"<std::io::Empty>(std::io::empty())`는 두 번째 예제에서 작동하지 않습니다."

#: src/trait/impl_trait.md:51
msgid "As a return type"
msgstr "반환 타입으로서"

#: src/trait/impl_trait.md:53
msgid ""
"If your function returns a type that implements `MyTrait`, you can write its "
"return type as `-> impl MyTrait`. This can help simplify your type "
"signatures quite a lot!"
msgstr ""
"여러분의 함수가 `MyTrait`를 구현하는 타입을 반환한다면, 반환 타입을 `-> impl "
"MyTrait`로 작성할 수 있습니다. 이는 타입 시그니처를 아주 많이 단순화하는 데 "
"도움이 될 수 있습니다!"

#: src/trait/impl_trait.md:59
msgid ""
"// This function combines two `Vec<i32>` and returns an iterator over it.\n"
"// Look how complicated its return type is!\n"
msgstr ""
"// 이 함수는 두 개의 `Vec<i32>`를 결합하고 그에 대한 이터레이터를 반환합니"
"다.\n"
"// 반환 타입이 얼마나 복잡한지 보세요!\n"

#: src/trait/impl_trait.md:68
msgid ""
"// This is the exact same function, but its return type uses `impl Trait`.\n"
"// Look how much simpler it is!\n"
msgstr ""
"// 이것은 정확히 동일한 함수이지만, 반환 타입에 `impl Trait`를 사용합니다.\n"
"// 훨씬 더 간단해진 것을 보세요!\n"

#: src/trait/impl_trait.md:87
msgid "\"all done\""
msgstr "\"모두 완료\""

#: src/trait/impl_trait.md:91
msgid ""
"More importantly, some Rust types can't be written out. For example, every "
"closure has its own unnamed concrete type. Before `impl Trait` syntax, you "
"had to allocate on the heap in order to return a closure. But now you can do "
"it all statically, like this:"
msgstr ""
"더 중요한 점은, 일부 Rust 타입은 명시적으로 작성할 수 없다는 것입니다. 예를 "
"들어, 모든 클로저는 자신만의 이름 없는 구체적인 타입을 가집니다. `impl "
"Trait` 구문이 생기기 전에는 클로저를 반환하기 위해 힙에 할당해야만 했습니다. "
"하지만 이제는 다음과 같이 정적으로 처리할 수 있습니다:"

#: src/trait/impl_trait.md:97
msgid "// Returns a function that adds `y` to its input\n"
msgstr "// 입력에 `y`를 더하는 함수를 반환합니다.\n"

#: src/trait/impl_trait.md:109
msgid ""
"You can also use `impl Trait` to return an iterator that uses `map` or "
"`filter` closures! This makes using `map` and `filter` easier. Because "
"closure types don't have names, you can't write out an explicit return type "
"if your function returns iterators with closures. But with `impl Trait` you "
"can do this easily:"
msgstr ""
"또한 `impl Trait`를 사용하여 `map`이나 `filter` 클로저를 사용하는 이터레이터"
"를 반환할 수도 있습니다! 이는 `map`과 `filter`를 더 쉽게 사용할 수 있게 해줍"
"니다. 클로저 타입은 이름이 없기 때문에, 함수가 클로저를 포함하는 이터레이터"
"를 반환할 경우 명시적인 반환 타입을 작성할 수 없습니다. 하지만 `impl Trait`"
"를 사용하면 이를 쉽게 할 수 있습니다:"

#: src/trait/clone.md:3
msgid ""
"When dealing with resources, the default behavior is to transfer them during "
"assignments or function calls. However, sometimes we need to make a copy of "
"the resource as well."
msgstr ""
"리소스를 다룰 때, 기본 동작은 할당이나 함수 호출 시 리소스를 이전(transfer)하"
"는 것입니다. 하지만 때로는 리소스의 복사본을 만들어야 할 때도 있습니다."

#: src/trait/clone.md:7
msgid ""
"The [`Clone`](https://doc.rust-lang.org/std/clone/trait.Clone.html) trait "
"helps us do exactly this. Most commonly, we can use the `.clone()` method "
"defined by the `Clone` trait."
msgstr ""
"[`Clone`](https://doc.rust-lang.org/std/clone/trait.Clone.html) 트레이트는 바"
"로 이런 일을 돕습니다. 가장 일반적으로, `Clone` 트레이트에 정의된 `.clone()` "
"메서드를 사용할 수 있습니다."

#: src/trait/clone.md:11
msgid "// A unit struct without resources\n"
msgstr "// 리소스가 없는 유닛 구조체\n"

#: src/trait/clone.md:14
msgid "// A tuple struct with resources that implements the `Clone` trait\n"
msgstr "// `Clone` 트레이트를 구현하는 리소스가 있는 튜플 구조체\n"

#: src/trait/clone.md:20
msgid "// Instantiate `Unit`\n"
msgstr "// `Unit`을 인스턴스화합니다\n"

#: src/trait/clone.md:22
msgid "// Copy `Unit`, there are no resources to move\n"
msgstr "// `Unit`을 복사합니다. 이동할 리소스가 없습니다.\n"

#: src/trait/clone.md:25
msgid "// Both `Unit`s can be used independently\n"
msgstr "// 두 `Unit` 모두 독립적으로 사용될 수 있습니다.\n"

#: src/trait/clone.md:26 src/trait/clone.md:31
msgid "\"original: {:?}\""
msgstr "\"원본: {:?}\""

#: src/trait/clone.md:27
msgid "\"copy: {:?}\""
msgstr "\"복사본: {:?}\""

#: src/trait/clone.md:29
msgid "// Instantiate `Pair`\n"
msgstr "// `Pair`를 인스턴스화합니다\n"

#: src/trait/clone.md:33
msgid "// Move `pair` into `moved_pair`, moves resources\n"
msgstr "// `pair`를 `moved_pair`로 이동합니다. 리소스가 이동됩니다.\n"

#: src/trait/clone.md:35
msgid "\"moved: {:?}\""
msgstr "\"이동됨: {:?}\""

#: src/trait/clone.md:37
msgid ""
"// Error! `pair` has lost its resources\n"
"    //println!(\"original: {:?}\", pair);\n"
"    // TODO ^ Try uncommenting this line\n"
msgstr ""
"// 에러! `pair`는 리소스를 잃었습니다\n"
"    //println!(\"original: {:?}\", pair);\n"
"    // TODO ^ 이 줄의 주석을 해제해 보세요\n"

#: src/trait/clone.md:41
msgid "// Clone `moved_pair` into `cloned_pair` (resources are included)\n"
msgstr "// `moved_pair`를 `cloned_pair`로 클론합니다(리소스가 포함됩니다)\n"

#: src/trait/clone.md:43
msgid "// Drop the moved original pair using std::mem::drop\n"
msgstr "// `std::mem::drop`을 사용하여 이동된 원본 페어를 해제합니다\n"

#: src/trait/clone.md:46
msgid ""
"// Error! `moved_pair` has been dropped\n"
"    //println!(\"moved and dropped: {:?}\", moved_pair);\n"
"    // TODO ^ Try uncommenting this line\n"
msgstr ""
"// 에러! `moved_pair`가 해제되었습니다\n"
"    //println!(\"moved and dropped: {:?}\", moved_pair);\n"
"    // TODO ^ 이 줄의 주석을 해제해 보세요\n"

#: src/trait/clone.md:50
msgid "// The result from .clone() can still be used!\n"
msgstr "// `.clone()`의 결과는 여전히 사용될 수 있습니다!\n"

#: src/trait/clone.md:51
msgid "\"clone: {:?}\""
msgstr "\"클론: {:?}\""

#: src/trait/supertraits.md:3
msgid ""
"Rust doesn't have \"inheritance\", but you can define a trait as being a "
"superset of another trait. For example:"
msgstr ""
"Rust에는 \"상속\"이 없지만, 한 트레이트를 다른 트레이트의 슈퍼셋(superset)으"
"로 정의할 수 있습니다. 예를 들어:"

#: src/trait/supertraits.md:10
msgid ""
"// Person is a supertrait of Student.\n"
"// Implementing Student requires you to also impl Person.\n"
msgstr ""
"// Person은 Student의 슈퍼트레이트입니다.\n"
"// Student를 구현하려면 Person도 구현해야 합니다.\n"

#: src/trait/supertraits.md:20
msgid ""
"// CompSciStudent (computer science student) is a subtrait of both "
"Programmer\n"
"// and Student. Implementing CompSciStudent requires you to impl both "
"supertraits.\n"
msgstr ""
"// CompSciStudent(컴퓨터 공학 학생)는 Programmer와 Student 모두의 서브트레이"
"트입니다.\n"
"// CompSciStudent를 구현하려면 두 슈퍼트레이트를 모두 구현해야 합니다.\n"

#: src/trait/supertraits.md:29
msgid ""
"\"My name is {} and I attend {}. My favorite language is {}. My Git username "
"is {}\""
msgstr ""
"\"제 이름은 {}이고 {}에 다닙니다. 제가 가장 좋아하는 언어는 {}입니다. 제 Git "
"사용자 이름은 {}입니다.\""

#: src/trait/supertraits.md:42
msgid ""
"[The Rust Programming Language chapter on supertraits](https://doc.rust-"
"lang.org/book/ch19-03-advanced-traits.html#using-supertraits-to-require-one-"
"traits-functionality-within-another-trait)"
msgstr ""
"[러스트 프로그래밍 언어의 슈퍼트레이트 장](https://doc.rust-lang.org/book/"
"ch19-03-advanced-traits.html#using-supertraits-to-require-one-traits-"
"functionality-within-another-trait)"

#: src/trait/disambiguating.md:3
msgid ""
"A type can implement many different traits. What if two traits both require "
"the same name for a function? For example, many traits might have a method "
"named `get()`. They might even have different return types!"
msgstr ""
"하나의 타입은 여러 개의 서로 다른 트레이트를 구현할 수 있습니다. 만약 두 트레"
"이트가 함수에 대해 동일한 이름을 요구한다면 어떨까요? 예를 들어, 많은 트레이"
"트가 `get()`이라는 이름의 메서드를 가질 수 있습니다. 심지어 반환 타입이 다를 "
"수도 있습니다!"

#: src/trait/disambiguating.md:7
msgid ""
"Good news: because each trait implementation gets its own `impl` block, it's "
"clear which trait's `get` method you're implementing."
msgstr ""
"좋은 소식은, 각 트레이트 구현이 자신만의 `impl` 블록을 가지기 때문에, 어떤 트"
"레이트의 `get` 메서드를 구현하고 있는지 명확하다는 것입니다."

#: src/trait/disambiguating.md:10
msgid ""
"What about when it comes time to _call_ those methods? To disambiguate "
"between them, we have to use Fully Qualified Syntax."
msgstr ""
"그럼 그 메서드들을 *호출*해야 할 때는 어떨까요? 이들 사이의 모호함을 없애기 "
"위해, 우리는 '완전한 정규화 구문(Fully Qualified Syntax)'을 사용해야 합니다."

#: src/trait/disambiguating.md:15
msgid "// Get the selected username out of this widget\n"
msgstr "// 이 위젯에서 선택된 사용자 이름을 가져옵니다\n"

#: src/trait/disambiguating.md:20
msgid "// Get the selected age out of this widget\n"
msgstr "// 이 위젯에서 선택된 나이를 가져옵니다\n"

#: src/trait/disambiguating.md:23
msgid "// A form with both a UsernameWidget and an AgeWidget\n"
msgstr "// UsernameWidget과 AgeWidget을 모두 포함하는 폼\n"

#: src/trait/disambiguating.md:44 src/trait/disambiguating.md:54
msgid "\"rustacean\""
msgstr "\"러스타시안(rustacean)\""

#: src/trait/disambiguating.md:48
msgid ""
"// If you uncomment this line, you'll get an error saying\n"
"    // \"multiple `get` found\". Because, after all, there are multiple "
"methods\n"
"    // named `get`.\n"
"    // println!(\"{}\", form.get());\n"
msgstr ""
"// 이 줄의 주석을 해제하면 \"multiple `get` found\"라는 에러가 발생합니다.\n"
"    // 결국 `get`이라는 이름의 메서드가 여러 개 있기 때문입니다.\n"
"    // println!(\"{}\", form.get());\n"

#: src/trait/disambiguating.md:62
msgid ""
"[The Rust Programming Language chapter on Fully Qualified syntax](https://"
"doc.rust-lang.org/book/ch19-03-advanced-traits.html#fully-qualified-syntax-"
"for-disambiguation-calling-methods-with-the-same-name)"
msgstr ""
"[러스트 프로그래밍 언어의 완전한 정규화 구문 장](https://doc.rust-lang.org/"
"book/ch19-03-advanced-traits.html#fully-qualified-syntax-for-disambiguation-"
"calling-methods-with-the-same-name)"

#: src/macros.md:1
msgid "`macro_rules!`"
msgstr "`macro_rules!`"

#: src/macros.md:3
msgid ""
"Rust provides a powerful macro system that allows metaprogramming. As you've "
"seen in previous chapters, macros look like functions, except that their "
"name ends with a bang `!`, but instead of generating a function call, macros "
"are expanded into source code that gets compiled with the rest of the "
"program. However, unlike macros in C and other languages, Rust macros are "
"expanded into abstract syntax trees, rather than string preprocessing, so "
"you don't get unexpected precedence bugs."
msgstr ""
"Rust는 메타프로그래밍을 가능하게 하는 강력한 매크로 시스템을 제공합니다. 이"
"전 장들에서 보았듯이, 매크로는 이름이 느낌표 `!`로 끝난다는 점을 제외하면 함"
"수와 비슷해 보입니다. 하지만 함수 호출을 생성하는 대신, 매크로는 프로그램의 "
"나머지 부분과 함께 컴파일되는 소스 코드로 확장됩니다. 그러나 C나 다른 언어의 "
"매크로와 달리, Rust 매크로는 문자열 전처리가 아닌 추상 구문 트리(AST)로 확장"
"되므로, 예상치 못한 연산자 우선순위 버그가 발생하지 않습니다."

#: src/macros.md:11
msgid "Macros are created using the `macro_rules!` macro."
msgstr "매크로는 `macro_rules!` 매크로를 사용하여 생성됩니다."

#: src/macros.md:14
msgid "// This is a simple macro named `say_hello`.\n"
msgstr "// `say_hello`라는 이름의 간단한 매크로입니다.\n"

#: src/macros.md:16
msgid "// `()` indicates that the macro takes no argument.\n"
msgstr "// `()`는 매크로가 인자를 취하지 않음을 나타냅니다.\n"

#: src/macros.md:18
msgid "// The macro will expand into the contents of this block.\n"
msgstr "// 매크로는 이 블록의 내용으로 확장됩니다.\n"

#: src/macros.md:19
msgid "\"Hello!\""
msgstr "\"안녕하세요!\""

#: src/macros.md:24
msgid "// This call will expand into `println!(\"Hello!\")`\n"
msgstr "// 이 호출은 `println!(\"안녕하세요!\")`로 확장됩니다.\n"

#: src/macros.md:29
msgid "So why are macros useful?"
msgstr "그렇다면 왜 매크로가 유용할까요?"

#: src/macros.md:31
msgid ""
"Don't repeat yourself. There are many cases where you may need similar "
"functionality in multiple places but with different types. Often, writing a "
"macro is a useful way to avoid repeating code. (More on this later)"
msgstr ""
"반복하지 마세요(DRY, Don't repeat yourself). 여러 곳에서 서로 다른 타입에 대"
"해 유사한 기능이 필요할 수 있는 경우가 많습니다. 종종 매크로를 작성하는 것은 "
"코드 반복을 피하는 유용한 방법입니다. (이에 대해서는 나중에 자세히 다룹니다)"

#: src/macros.md:35
msgid ""
"Domain-specific languages. Macros allow you to define special syntax for a "
"specific purpose. (More on this later)"
msgstr ""
"도메인 특화 언어(DSL, Domain-specific languages). 매크로를 사용하면 특정 목적"
"을 위한 특정 구문을 정의할 수 있습니다. (이에 대해서는 나중에 자세히 다룹니"
"다)"

#: src/macros.md:38
msgid ""
"Variadic interfaces. Sometimes you want to define an interface that takes a "
"variable number of arguments. An example is `println!` which could take any "
"number of arguments, depending on the format string. (More on this later)"
msgstr ""
"가변 인자 인터페이스. 때로는 가변적인 개수의 인자를 취하는 인터페이스를 정의"
"하고 싶을 때가 있습니다. 예를 들어 `println!`은 형식 문자열에 따라 인자를 몇 "
"개든 취할 수 있습니다! (이에 대해서는 나중에 자세히 다룹니다)"

#: src/macros/syntax.md:3
msgid ""
"In following subsections, we will show how to define macros in Rust. There "
"are three basic ideas:"
msgstr ""
"이어지는 하위 섹션에서는 Rust에서 매크로를 정의하는 방법을 보여줄 것입니다. "
"여기에는 세 가지 기본 아이디어가 있습니다:"

#: src/macros/syntax.md:6
msgid "[Patterns and Designators](designators.md)"
msgstr "[패턴과 지시자](designators.md)"

#: src/macros/syntax.md:7
msgid "[Overloading](overload.md)"
msgstr "[오버로딩](overload.md)"

#: src/macros/syntax.md:8
msgid "[Repetition](repeat.md)"
msgstr "[반복](repeat.md)"

#: src/macros/designators.md:3
msgid ""
"The arguments of a macro are prefixed by a dollar sign `$` and type "
"annotated with a _designator_:"
msgstr ""
"매크로의 인자는 달러 기호 `$`가 접두사로 붙으며, 지시자(designator)로 타입이 "
"어노테이션됩니다:"

#: src/macros/designators.md:8
msgid ""
"// This macro takes an argument of designator `ident` and\n"
"    // creates a function named `$func_name`.\n"
"    // The `ident` designator is used for variable/function names.\n"
msgstr ""
"// 이 매크로는 지시자 `ident` 인자를 취하여\n"
"    // `$func_name`이라는 이름의 함수를 생성합니다.\n"
"    // `ident` 지시자는 변수/함수 이름에 사용됩니다.\n"

#: src/macros/designators.md:13
msgid "// The `stringify!` macro converts an `ident` into a string.\n"
msgstr "// `stringify!` 매크로는 `ident`를 문자열로 변환합니다.\n"

#: src/macros/designators.md:14
msgid "\"You called {:?}()\""
msgstr "\"당신은 {:?}()를 호출했습니다\""

#: src/macros/designators.md:19
msgid "// Create functions named `foo` and `bar` with the above macro.\n"
msgstr ""
"// 위의 매크로를 사용하여 `foo`와 `bar`라는 이름의 함수를 생성합니다.\n"

#: src/macros/designators.md:25
msgid ""
"// This macro takes an expression of type `expr` and prints\n"
"    // it as a string along with its result.\n"
"    // The `expr` designator is used for expressions.\n"
msgstr ""
"// 이 매크로는 `expr` 타입의 표현식을 취하여\n"
"    // 결과와 함께 문자열로 출력합니다.\n"
"    // `expr` 지시자는 표현식에 사용됩니다.\n"

#: src/macros/designators.md:29
msgid "// `stringify!` will convert the expression *as it is* into a string.\n"
msgstr "// `stringify!`는 표현식을 *있는 그대로* 문자열로 변환합니다.\n"

#: src/macros/designators.md:30
msgid "\"{:?} = {:?}\""
msgstr "\"{:?} = {:?}\""

#: src/macros/designators.md:42
msgid "// Recall that blocks are expressions too!\n"
msgstr "// 블록도 표현식이라는 점을 기억하세요!\n"

#: src/macros/designators.md:51
msgid "These are some of the available designators:"
msgstr "사용 가능한 지시자들의 일부는 다음과 같습니다:"

#: src/macros/designators.md:53
msgid "`block`"
msgstr "`block`"

#: src/macros/designators.md:54
msgid "`expr` is used for expressions"
msgstr "`expr`은 표현식에 사용됩니다"

#: src/macros/designators.md:55
msgid "`ident` is used for variable/function names"
msgstr "`ident`는 변수/함수 이름에 사용됩니다"

#: src/macros/designators.md:56
msgid "`item`"
msgstr "`item`"

#: src/macros/designators.md:57
msgid "`literal` is used for literal constants"
msgstr "`literal`은 리터럴 상수에 사용됩니다"

#: src/macros/designators.md:58
msgid "`pat` (_pattern_)"
msgstr "`pat` (패턴)"

#: src/macros/designators.md:59
msgid "`path`"
msgstr "`path`"

#: src/macros/designators.md:60
msgid "`stmt` (_statement_)"
msgstr "`stmt` (문장)"

#: src/macros/designators.md:61
msgid "`tt` (_token tree_)"
msgstr "`tt` (토큰 트리)"

#: src/macros/designators.md:62
msgid "`ty` (_type_)"
msgstr "`ty` (타입)"

#: src/macros/designators.md:63
msgid "`vis` (_visibility qualifier_)"
msgstr "`vis` (가시성 한정자)"

#: src/macros/designators.md:65
msgid ""
"For a complete list, see the [Rust Reference](https://doc.rust-lang.org/"
"reference/macros-by-example.html)."
msgstr ""
"전체 목록은 [Rust 레퍼런스](https://doc.rust-lang.org/reference/macros-by-"
"example.html)를 참조하세요."

#: src/macros/overload.md:3
msgid ""
"Macros can be overloaded to accept different combinations of arguments. In "
"that regard, `macro_rules!` can work similarly to a match block:"
msgstr ""
"매크로는 서로 다른 인자 조합을 수용하도록 오버로딩될 수 있습니다. 그런 점에서"
"는 `macro_rules!`는 `match` 블록과 비슷하게 작동할 수 있습니다:"

#: src/macros/overload.md:7
msgid ""
"// `test!` will compare `$left` and `$right`\n"
"// in different ways depending on how you invoke it:\n"
msgstr ""
"// `test!`는 호출 방식에 따라 `$left`와 `$right`를\n"
"// 서로 다른 방식으로 비교할 것입니다:\n"

#: src/macros/overload.md:10
msgid ""
"// Arguments don't need to be separated by a comma.\n"
"    // Any template can be used!\n"
msgstr ""
"// 인자들은 콤마로 구분될 필요가 없습니다.\n"
"    // 어떤 템플릿이든 사용될 수 있습니다!\n"

#: src/macros/overload.md:13
msgid "\"{:?} and {:?} is {:?}\""
msgstr "\"{:?} and {:?} is {:?}\""

#: src/macros/overload.md:18
msgid "// ^ each arm must end with a semicolon.\n"
msgstr "// ^ 각 팔(arm)은 세미콜론으로 끝나야 합니다.\n"

#: src/macros/overload.md:20
msgid "\"{:?} or {:?} is {:?}\""
msgstr "\"{:?} or {:?} is {:?}\""

#: src/macros/repeat.md:3
msgid ""
"Macros can use `+` in the argument list to indicate that an argument may "
"repeat at least once, or `*`, to indicate that the argument may repeat zero "
"or more times."
msgstr ""
"매크로는 인자 목록에서 `+`를 사용하여 인자가 한 번 이상 반복될 수 있음을 나타"
"내거나, `*`를 사용하여 인자가 0번 이상 반복될 수 있음을 나타낼 수 있습니다."

#: src/macros/repeat.md:7
msgid ""
"In the following example, surrounding the matcher with `$(...),+` will match "
"one or more expression, separated by commas. Also note that the semicolon is "
"optional on the last case."
msgstr ""
"다음 예제에서, 매처(matcher)를 `$(...),+`로 감싸면 콤마로 구분된 하나 이상의 "
"표현식과 매치됩니다. 또한 마지막 케이스에서는 세미콜론이 선택사항임에 유의하"
"세요."

#: src/macros/repeat.md:12
msgid "// `find_min!` will calculate the minimum of any number of arguments.\n"
msgstr "// `find_min!`은 임의 개수의 인자들 중 최솟값을 계산합니다.\n"

#: src/macros/repeat.md:14
msgid "// Base case:\n"
msgstr "// 기본 케이스:\n"

#: src/macros/repeat.md:16
msgid "// `$x` followed by at least one `$y,`\n"
msgstr "// `$x` 뒤에 최소 하나의 `$y,`가 오는 경우\n"

#: src/macros/repeat.md:18
msgid "// Call `find_min!` on the tail `$y`\n"
msgstr "// 나머지 `$y`들에 대해 `find_min!`을 호출합니다.\n"

#: src/macros/dry.md:3
msgid ""
"Macros allow writing DRY code by factoring out the common parts of functions "
"and/or test suites. Here is an example that implements and tests the `+=`, "
"`*=` and `-=` operators on `Vec<T>`:"
msgstr ""
"매크로는 함수나 테스트 스위트의 공통 부분을 추출함으로써 DRY(Don't Repeat "
"Yourself) 코드를 작성할 수 있게 해줍니다. 다음은 `Vec<T>`에 대해 `+=`, `*=` "
"및 `-=` 연산자를 구현하고 테스트하는 예제입니다:"

#: src/macros/dry.md:11
msgid ""
"// The `tt` (token tree) designator is used for\n"
"    // operators and tokens.\n"
msgstr ""
"// `tt`(토큰 트리) 지시자는\n"
"    // 연산자와 토큰에 사용됩니다.\n"

#: src/macros/dry.md:15
msgid "\"{:?}: dimension mismatch: {:?} {:?} {:?}\""
msgstr "\"{:?}: dimension mismatch: {:?} {:?} {:?}\""

#: src/macros/dry.md:30
msgid "// *x = x.$method(*y);\n"
msgstr "// *x = x.$method(*y);\n"

#: src/macros/dry.md:35
msgid "// Implement `add_assign`, `mul_assign`, and `sub_assign` functions.\n"
msgstr "// `add_assign`, `mul_assign`, `sub_assign` 함수를 구현합니다.\n"

#: src/macros/dry.md:60
msgid "// Test `add_assign`, `mul_assign`, and `sub_assign`.\n"
msgstr "// `add_assign`, `mul_assign`, `sub_assign`을 테스트합니다.\n"

#: src/macros/dsl.md:1
msgid "Domain Specific Languages (DSLs)"
msgstr "도메인 특화 언어 (DSL)"

#: src/macros/dsl.md:3
msgid ""
"A DSL is a mini \"language\" embedded in a Rust macro. It is completely "
"valid Rust because the macro system expands into normal Rust constructs, but "
"it looks like a small language. This allows you to define concise or "
"intuitive syntax for some special functionality (within bounds)."
msgstr ""
"DSL은 Rust 매크로에 내장된 미니 \"언어\"입니다. 매크로 시스템이 일반적인 "
"Rust 구문으로 확장되기 때문에 완전히 유효한 Rust 코드이지만, 작은 언어처럼 보"
"입니다. 이를 통해 (일정한 범위 내에서) 특정 기능을 위한 간결하거나 직관적인 "
"구문을 정의할 수 있습니다."

#: src/macros/dsl.md:8
msgid ""
"Suppose that I want to define a little calculator API. I would like to "
"supply an expression and have the output printed to console."
msgstr ""
"작은 계산기 API를 정의하고 싶다고 가정해 봅시다. 표현식을 입력하면 출력이 콘"
"솔에 인쇄되도록 하고 싶습니다."

#: src/macros/dsl.md:15
msgid "// Force types to be unsigned integers\n"
msgstr "// 타입을 부호 없는 정수로 강제합니다\n"

#: src/macros/dsl.md:16 src/macros/variadics.md:15
msgid "\"{} = {}\""
msgstr "\"{} = {}\""

#: src/macros/dsl.md:23
msgid "// hehehe `eval` is _not_ a Rust keyword!\n"
msgstr "// 히히히 `eval`은 Rust 키워드가 아닙니다!\n"

#: src/macros/dsl.md:32 src/macros/variadics.md:35
msgid "Output:"
msgstr "출력:"

#: src/macros/dsl.md:39
msgid ""
"This was a very simple example, but much more complex interfaces have been "
"developed, such as [`lazy_static`](https://crates.io/crates/lazy_static) or "
"[`clap`](https://crates.io/crates/clap)."
msgstr ""
"이것은 매우 간단한 예제였지만, [`lazy_static`](https://crates.io/crates/"
"lazy_static)이나 [`clap`](https://crates.io/crates/clap)과 같이 훨씬 더 복잡"
"한 인터페이스들이 개발되어 있습니다."

#: src/macros/dsl.md:43
msgid ""
"Also, note the two pairs of braces in the macro. The outer ones are part of "
"the syntax of `macro_rules!`, in addition to `()` or `[]`."
msgstr ""
"또한, 매크로에 두 쌍의 중괄호가 있음에 유의하세요. 바깥쪽 중괄호는 `()`나 "
"`[]` 외에 `macro_rules!` 문법의 일부입니다."

#: src/macros/variadics.md:1
msgid "Variadic Interfaces"
msgstr "가변 인자 인터페이스"

#: src/macros/variadics.md:3
msgid ""
"A _variadic_ interface takes an arbitrary number of arguments. For example, "
"`println!` can take an arbitrary number of arguments, as determined by the "
"format string."
msgstr ""
"가변 인자 인터페이스는 임의의 개수의 인자를 취합니다. 예를 들어, `println!`"
"은 형식 문자열에 따라 결정되는 임의의 개수의 인자를 취할 수 있습니다."

#: src/macros/variadics.md:7
msgid ""
"We can extend our `calculate!` macro from the previous section to be "
"variadic:"
msgstr ""
"이전 섹션의 `calculate!` 매크로를 가변 인자를 취하도록 확장할 수 있습니다:"

#: src/macros/variadics.md:11
msgid "// The pattern for a single `eval`\n"
msgstr "// 단일 `eval`을 위한 패턴\n"

#: src/macros/variadics.md:14
msgid "// Force types to be integers\n"
msgstr "// 타입을 정수로 강제합니다\n"

#: src/macros/variadics.md:19
msgid "// Decompose multiple `eval`s recursively\n"
msgstr "// 여러 개의 `eval`을 재귀적으로 분해합니다\n"

#: src/macros/variadics.md:27
msgid "// Look ma! Variadic `calculate!`!\n"
msgstr "// 보세요! 가변 인자 `calculate!`입니다!\n"

#: src/error.md:3
msgid ""
"Error handling is the process of handling the possibility of failure. For "
"example, failing to read a file and then continuing to use that _bad_ input "
"would clearly be problematic. Noticing and explicitly managing those errors "
"saves the rest of the program from various pitfalls."
msgstr ""
"에러 핸들링은 실패 가능성을 처리하는 과정입니다. 예를 들어, 파일을 읽는 데 실"
"패했는데도 그 *잘못된* 입력을 계속 사용하는 것은 분명히 문제가 될 것입니다. "
"이러한 에러를 인지하고 명시적으로 관리하면 프로그램의 나머지 부분을 다양한 함"
"정으로부터 보호할 수 있습니다."

#: src/error.md:8
msgid ""
"There are various ways to deal with errors in Rust, which are described in "
"the following subchapters. They all have more or less subtle differences and "
"different use cases. As a rule of thumb:"
msgstr ""
"Rust에는 에러를 처리하는 다양한 방법이 있으며, 이는 이어지는 하위 장에서 설명"
"합니다. 이들은 모두 어느 정도 미묘한 차이가 있으며 용도가 다릅니다. 일반적인 "
"원칙은 다음과 같습니다:"

#: src/error.md:12
msgid ""
"An explicit `panic` is mainly useful for tests and dealing with "
"unrecoverable errors. For prototyping it can be useful, for example when "
"dealing with functions that haven't been implemented yet, but in those cases "
"the more descriptive `unimplemented` is better. In tests `panic` is a "
"reasonable way to explicitly fail."
msgstr ""
"명시적인 `panic`은 주로 테스트와 복구 불가능한 에러를 처리하는 데 유용합니"
"다. 프로토타이핑을 할 때도 유용할 수 있는데, 예를 들어 아직 구현되지 않은 함"
"수를 다룰 때 유용하지만, 그런 경우에는 더 설명적인 `unimplemented`를 사용하"
"는 것이 좋습니다. 테스트에서 `panic`은 명시적으로 실패를 알리는 합리적인 방법"
"입니다."

#: src/error.md:17
msgid ""
"The `Option` type is for when a value is optional or when the lack of a "
"value is not an error condition. For example the parent of a directory - `/` "
"and `C:` don't have one. When dealing with `Option`s, `unwrap` is fine for "
"prototyping and cases where it's absolutely certain that there is guaranteed "
"to be a value. However `expect` is more useful since it lets you specify an "
"error message in case something goes wrong anyway."
msgstr ""
"`Option` 타입은 값이 선택적이거나 값의 부재가 에러 상황이 아닐 때 사용됩니"
"다. 예를 들어 디렉터리의 부모 - `/`와 `C:`는 부모가 없습니다. `Option`을 다"
"룰 때, `unwrap`은 프로토타이핑이나 값이 반드시 존재한다고 절대적으로 확신할 "
"수 있는 경우에 괜찮습니다. 하지만 `expect`는 무언가 잘못되었을 경우를 대비해 "
"에러 메시지를 지정할 수 있게 해주므로 더 유용합니다."

#: src/error.md:24
msgid ""
"When there is a chance that things do go wrong and the caller has to deal "
"with the problem, use `Result`. You can `unwrap` and `expect` them as well "
"(please don't do that unless it's a test or quick prototype)."
msgstr ""
"무언가 잘못될 가능성이 있고 호출자가 그 문제를 처리해야 할 때는 `Result`를 사"
"용하세요. `Result`에 대해서도 `unwrap`과 `expect`를 사용할 수 있지만 (테스트"
"나 빠른 프로토타입이 아니라면 제발 그렇게 하지 마세요)."

#: src/error.md:28
msgid ""
"For a more rigorous discussion of error handling, refer to the error "
"handling section in the [official book](https://doc.rust-lang.org/book/"
"ch09-00-error-handling.html)."
msgstr ""
"에러 핸들링에 대한 더 엄밀한 논의는 [공식 도서](https://doc.rust-lang.org/"
"book/ch09-00-error-handling.html)의 에러 핸들링 섹션을 참조하세요."

#: src/error/panic.md:3
msgid ""
"The simplest error handling mechanism we will see is `panic`. It prints an "
"error message, starts unwinding the stack, and usually exits the program. "
"Here, we explicitly call `panic` on our error condition:"
msgstr ""
"우리가 살펴볼 가장 단순한 에러 핸들링 메커니즘은 `panic`입니다. 이것은 에러 "
"메시지를 출력하고, 스택을 되감기(unwind) 시작하며, 보통 프로그램을 종료합니"
"다. 여기서는 에러 조건에 대해 명시적으로 `panic`을 호출합니다:"

#: src/error/panic.md:9
msgid "// You shouldn't drink too many sugary beverages.\n"
msgstr "// 설탕이 든 음료를 너무 많이 마시면 안 됩니다.\n"

#: src/error/panic.md:10 src/error/panic.md:17 src/error/abort_unwind.md:10
#: src/error/abort_unwind.md:23 src/error/abort_unwind.md:41
#: src/error/abort_unwind.md:50 src/error/option_unwrap.md:32
#: src/error/option_unwrap.md:43 src/error/option_unwrap.md:50
msgid "\"lemonade\""
msgstr "\"레모네이드\""

#: src/error/panic.md:10 src/error/option_unwrap.md:43
msgid "\"AAAaaaaa!!!!\""
msgstr "\"으아아아아!!!!\""

#: src/error/panic.md:12 src/error/abort_unwind.md:17
#: src/error/abort_unwind.md:44
msgid "\"Some refreshing {} is all I need.\""
msgstr "\"상쾌한 {}만 있으면 돼요.\""

#: src/error/panic.md:16 src/error/abort_unwind.md:22
#: src/error/abort_unwind.md:49 src/error/option_unwrap.md:49
msgid "\"water\""
msgstr "\"물\""

#: src/error/panic.md:18
msgid "\"still water\""
msgstr "\"생수\""

#: src/error/panic.md:22
msgid ""
"The first call to `drink` works. The second panics and thus the third is "
"never called."
msgstr ""
"첫 번째 `drink` 호출은 작동합니다. 두 번째는 패닉을 일으키며, 따라서 세 번째"
"는 결코 호출되지 않습니다."

#: src/error/abort_unwind.md:1
msgid "`abort` and `unwind`"
msgstr "`abort`와 `unwind`"

#: src/error/abort_unwind.md:3
msgid ""
"The previous section illustrates the error handling mechanism `panic`.  "
"Different code paths can be conditionally compiled based on the panic "
"setting. The current values available are `unwind` and `abort`."
msgstr ""
"이전 섹션에서는 에러 핸들링 메커니즘인 `panic`을 설명했습니다. 패닉 설정에 따"
"라 서로 다른 코드 경로를 조건부로 컴파일할 수 있습니다. 현재 사용 가능한 값"
"은 `unwind`와 `abort`입니다."

#: src/error/abort_unwind.md:5
msgid ""
"Building on the prior lemonade example, we explicitly use the panic strategy "
"to exercise different lines of code."
msgstr ""
"앞선 레모네이드 예제를 바탕으로, 서로 다른 코드 라인을 실행해 보기 위해 패닉 "
"전략을 명시적으로 사용합니다."

#: src/error/abort_unwind.md:9
msgid "// You shouldn't drink too much sugary beverages.\n"
msgstr "// 설탕이 든 음료를 너무 많이 마시면 안 됩니다.\n"

#: src/error/abort_unwind.md:11
msgid "\"abort\""
msgstr "\"abort\""

#: src/error/abort_unwind.md:12 src/error/abort_unwind.md:37
msgid "\"This is not your party. Run!!!!\""
msgstr "\"여긴 당신 파티가 아니에요. 도망쳐요!!!!\""

#: src/error/abort_unwind.md:14 src/error/abort_unwind.md:32
msgid "\"Spit it out!!!!\""
msgstr "\"뱉어내요!!!!\""

#: src/error/abort_unwind.md:27
msgid ""
"Here is another example focusing on rewriting `drink()` and explicitly use "
"the `unwind` keyword."
msgstr ""
"여기 `drink()`를 다시 작성하고 `unwind` 키워드를 명시적으로 사용하는 또 다른 "
"예제가 있습니다."

#: src/error/abort_unwind.md:30 src/error/abort_unwind.md:35
msgid "\"unwind\""
msgstr "\"unwind\""

#: src/error/abort_unwind.md:54
msgid ""
"The panic strategy can be set from the command line by using `abort` or "
"`unwind`."
msgstr ""
"패닉 전략은 커맨드 라인에서 `abort` 또는 `unwind`를 사용하여 설정할 수 있습니"
"다."

#: src/error/option_unwrap.md:3
msgid ""
"In the last example, we showed that we can induce program failure at will. "
"We told our program to `panic` if we drink a sugary lemonade. But what if we "
"expect _some_ drink but don't receive one? That case would be just as bad, "
"so it needs to be handled!"
msgstr ""
"지난 예제에서, 우리는 프로그램을 의도적으로 실패하게 만들 수 있음을 보여주었"
"습니다. 설탕이 든 레모네이드를 마시면 `panic`하도록 프로그램에 지시했습니다. "
"하지만 음료가 있을 것으로 예상했는데 아무것도 받지 못하면 어떨까요? 그 경우"
"도 마찬가지로 나쁠 것이므로, 처리가 필요합니다!"

#: src/error/option_unwrap.md:8
msgid ""
"We _could_ test this against the null string (`\"\"`) as we do with a "
"lemonade. Since we're using Rust, let's instead have the compiler point out "
"cases where there's no drink."
msgstr ""
"레모네이드의 경우처럼 빈 문자열(`\"\"`)인지 테스트할 수도 있습니다. 하지만 우"
"리는 Rust를 사용하고 있으니, 대신 컴파일러가 음료가 없는 경우를 지적하도록 해"
"봅시다."

#: src/error/option_unwrap.md:12
msgid ""
"An `enum` called `Option<T>` in the `std` library is used when absence is a "
"possibility. It manifests itself as one of two \"options\":"
msgstr ""
"표준 라이브러리의 `Option<T>`라는 열거형은 부재의 가능성이 있을 때 사용됩니"
"다. 이는 두 가지 \"옵션\" 중 하나로 나타납니다:"

#: src/error/option_unwrap.md:15
msgid "`Some(T)`: An element of type `T` was found"
msgstr "`Some(T)`: `T` 타입의 요소가 발견됨"

#: src/error/option_unwrap.md:16
msgid "`None`: No element was found"
msgstr "`None`: 요소가 발견되지 않음"

#: src/error/option_unwrap.md:18
msgid ""
"These cases can either be explicitly handled via `match` or implicitly with "
"`unwrap`. Implicit handling will either return the inner element or `panic`."
msgstr ""
"이러한 경우들은 `match`를 통해 명시적으로 처리하거나 `unwrap`을 통해 암시적으"
"로 처리할 수 있습니다. 암시적 처리는 내부 요소를 반환하거나 `panic`을 일으킵"
"니다."

#: src/error/option_unwrap.md:21
msgid ""
"Note that it's possible to manually customize `panic` with [expect](https://"
"doc.rust-lang.org/std/option/enum.Option.html#method.expect), but `unwrap` "
"otherwise leaves us with a less meaningful output than explicit handling. In "
"the following example, explicit handling yields a more controlled result "
"while retaining the option to `panic` if desired."
msgstr ""
"[expect](https://doc.rust-lang.org/std/option/enum.Option.html#method.expect)"
"를 사용하여 `panic`을 수동으로 커스터마이징할 수 있지만, 그렇지 않으면 "
"`unwrap`은 명시적 처리보다 덜 의미 있는 출력을 남깁니다. 다음 예제에서, 명시"
"적 처리는 원하는 경우 `panic`할 수 있는 옵션을 유지하면서도 더 제어된 결과를 "
"제공합니다."

#: src/error/option_unwrap.md:27
msgid ""
"// The adult has seen it all, and can handle any drink well.\n"
"// All drinks are handled explicitly using `match`.\n"
msgstr ""
"// 어른은 모든 것을 보았고, 어떤 음료든 잘 다룰 수 있습니다.\n"
"// 모든 음료는 `match`를 사용하여 명시적으로 처리됩니다.\n"

#: src/error/option_unwrap.md:30
msgid "// Specify a course of action for each case.\n"
msgstr "// 각 경우에 대한 행동 지침을 지정합니다.\n"

#: src/error/option_unwrap.md:32
msgid "\"Yuck! Too sugary.\""
msgstr "\"윽! 너무 달아요.\""

#: src/error/option_unwrap.md:33
msgid "\"{}? How nice.\""
msgstr "\"{}요? 좋네요.\""

#: src/error/option_unwrap.md:34
msgid "\"No drink? Oh well.\""
msgstr "\"음료가 없나요? 뭐, 어쩔 수 없죠.\""

#: src/error/option_unwrap.md:37
msgid ""
"// Others will `panic` before drinking sugary drinks.\n"
"// All drinks are handled implicitly using `unwrap`.\n"
msgstr ""
"// 다른 사람들은 단 음료를 마시기 전에 `panic`할 것입니다.\n"
"// 모든 음료는 `unwrap`을 사용하여 암시적으로 처리됩니다.\n"

#: src/error/option_unwrap.md:41
msgid "// `unwrap` returns a `panic` when it receives a `None`.\n"
msgstr "// `unwrap`은 `None`을 받으면 `panic`을 반환합니다.\n"

#: src/error/option_unwrap.md:45
msgid "\"I love {}s!!!!!\""
msgstr "\"난 {}가 너무 좋아요!!!!!\""

#: src/error/option_unwrap.md:57
msgid "\"coffee\""
msgstr "\"커피\""

#: src/error/option_unwrap/question_mark.md:3
msgid ""
"You can unpack `Option`s by using `match` statements, but it's often easier "
"to use the `?` operator. If `x` is an `Option`, then evaluating `x?` will "
"return the underlying value if `x` is `Some`, otherwise it will terminate "
"whatever function is being executed and return `None`."
msgstr ""
"`match` 문을 사용하여 `Option`을 풀 수(unpack) 있지만, `?` 연산자를 사용하는 "
"것이 더 쉬울 때가 많습니다. 만약 `x`가 `Option`이라면, `x?`를 평가할 때 `x`"
"가 `Some`이면 그 내부 값을 반환하고, 그렇지 않으면 실행 중인 함수를 종료하고 "
"`None`을 반환합니다."

#: src/error/option_unwrap/question_mark.md:10
msgid ""
"// If `current_age` is `None`, this returns `None`.\n"
"    // If `current_age` is `Some`, the inner `u8` value + 1\n"
"    // gets assigned to `next_age`\n"
msgstr ""
"// 만약 `current_age`가 `None`이면, 이는 `None`을 반환합니다.\n"
"    // 만약 `current_age`가 `Some`이면, 내부의 `u8` 값 + 1이\n"
"    // `next_age`에 할당됩니다.\n"

#: src/error/option_unwrap/question_mark.md:14
msgid "\"Next year I will be {}\""
msgstr "\"내년에 저는 {}살이 됩니다\""

#: src/error/option_unwrap/question_mark.md:18
msgid "You can chain many `?`s together to make your code much more readable."
msgstr ""
"여러 개의 `?`를 체인으로 연결하여 코드를 훨씬 더 읽기 쉽게 만들 수 있습니다."

#: src/error/option_unwrap/question_mark.md:38
msgid ""
"// Gets the area code of the phone number of the person's job, if it "
"exists.\n"
msgstr "// 사람의 직장 전화번호의 지역 번호가 존재한다면 가져옵니다.\n"

#: src/error/option_unwrap/question_mark.md:40
msgid ""
"// This would need many nested `match` statements without the `?` operator.\n"
"        // It would take a lot more code - try writing it yourself and see "
"which\n"
"        // is easier.\n"
msgstr ""
"// `?` 연산자가 없다면 많은 중첩된 `match` 문이 필요했을 것입니다.\n"
"        // 훨씬 더 많은 코드가 필요할 것입니다 - 직접 작성해 보고 어느 쪽이 "
"더 쉬운지\n"
"        // 확인해 보세요.\n"

#: src/error/option_unwrap/map.md:3
msgid ""
"`match` is a valid method for handling `Option`s. However, you may "
"eventually find heavy usage tedious, especially with operations only valid "
"with an input. In these cases, [combinators](https://doc.rust-lang.org/"
"reference/glossary.html#combinator) can be used to manage control flow in a "
"modular fashion."
msgstr ""
"`match`는 `Option`을 처리하는 유효한 방법입니다. 하지만 특히 입력이 있을 때"
"만 유효한 연산들의 경우, 과도한 사용은 지루할 수 있습니다. 이런 경우, [콤비네"
"이터(combinators)](https://doc.rust-lang.org/reference/"
"glossary.html#combinator)를 사용하여 모듈식으로 제어 흐름을 관리할 수 있습니"
"다."

#: src/error/option_unwrap/map.md:8
msgid ""
"`Option` has a built in method called `map()`, a combinator for the simple "
"mapping of `Some -> Some` and `None -> None`. Multiple `map()` calls can be "
"chained together for even more flexibility."
msgstr ""
"`Option`에는 `Some -> Some` 및 `None -> None`의 단순 매핑을 위한 콤비네이터"
"인 `map()` 메서드가 내장되어 있습니다. 여러 개의 `map()` 호출을 체인으로 연결"
"하여 훨씬 더 유연하게 사용할 수 있습니다."

#: src/error/option_unwrap/map.md:12
msgid ""
"In the following example, `process()` replaces all functions previous to it "
"while staying compact."
msgstr ""
"다음 예제에서 `process()`는 간결함을 유지하면서 그 이전의 모든 함수들을 대체"
"합니다."

#: src/error/option_unwrap/map.md:23
msgid ""
"// Peeling food. If there isn't any, then return `None`.\n"
"// Otherwise, return the peeled food.\n"
msgstr ""
"// 음식을 껍질 벗깁니다. 음식이 없다면 `None`을 반환합니다.\n"
"// 그렇지 않으면 껍질을 벗긴 음식을 반환합니다.\n"

#: src/error/option_unwrap/map.md:32
msgid ""
"// Chopping food. If there isn't any, then return `None`.\n"
"// Otherwise, return the chopped food.\n"
msgstr ""
"// 음식을 썹니다. 음식이 없다면 `None`을 반환합니다.\n"
"// 그렇지 않으면 썬 음식을 반환합니다.\n"

#: src/error/option_unwrap/map.md:41
msgid ""
"// Cooking food. Here, we showcase `map()` instead of `match` for case "
"handling.\n"
msgstr ""
"// 음식을 요리합니다. 여기서는 케이스 처리를 위해 `match` 대신 `map()`을 보여"
"줍니다.\n"

#: src/error/option_unwrap/map.md:46
msgid ""
"// A function to peel, chop, and cook food all in sequence.\n"
"// We chain multiple uses of `map()` to simplify the code.\n"
msgstr ""
"// 음식을 순서대로 껍질 벗기고, 썰고, 요리하는 함수입니다.\n"
"// 코드를 단순화하기 위해 `map()`을 여러 번 체인으로 연결합니다.\n"

#: src/error/option_unwrap/map.md:54
msgid "// Check whether there's food or not before trying to eat it!\n"
msgstr "// 먹기 전에 음식이 있는지 없는지 확인합니다!\n"

#: src/error/option_unwrap/map.md:58
msgid "\"Mmm. I love {:?}\""
msgstr "\"음~ 전 {:?}가 정말 좋아요\""

#: src/error/option_unwrap/map.md:59
msgid "\"Oh no! It wasn't edible.\""
msgstr "\"오 이런! 먹을 수 있는 게 아니었어요.\""

#: src/error/option_unwrap/map.md:70
msgid "// Let's try the simpler looking `process()` now.\n"
msgstr "// 이제 더 간단해 보이는 `process()`를 시도해 봅시다.\n"

#: src/error/option_unwrap/map.md:81
msgid ""
"[closures](../../fn/closures.md), [`Option`](https://doc.rust-lang.org/std/"
"option/enum.Option.html), [`Option::map()`](https://doc.rust-lang.org/std/"
"option/enum.Option.html#method.map)"
msgstr ""
"[클로저](../../fn/closures.md), [`Option`](https://doc.rust-lang.org/std/"
"option/enum.Option.html), [`Option::map()`](https://doc.rust-lang.org/std/"
"option/enum.Option.html#method.map)"

#: src/error/option_unwrap/and_then.md:3
msgid ""
"`map()` was described as a chainable way to simplify `match` statements. "
"However, using `map()` on a function that returns an `Option<T>` results in "
"the nested `Option<Option<T>>`. Chaining multiple calls together can then "
"become confusing. That's where another combinator called `and_then()`, known "
"in some languages as flatmap, comes in."
msgstr ""
"`map()`은 `match` 문을 단순화하기 위한 체인 가능한 방법으로 설명되었습니다. "
"하지만 `Option<T>`를 반환하는 함수에 `map()`을 사용하면 중첩된 "
"`Option<Option<T>>`가 생성됩니다. 여러 호출을 함께 체인으로 연결하는 것은 혼"
"란스러울 수 있습니다. 이때 다른 언어에서 `flatmap`으로 알려진 `and_then()`이"
"라는 또 다른 콤비네이터가 등장합니다."

#: src/error/option_unwrap/and_then.md:9
msgid ""
"`and_then()` calls its function input with the wrapped value and returns the "
"result. If the `Option` is `None`, then it returns `None` instead."
msgstr ""
"`and_then()`은 래핑된 값을 가지고 함수 입력을 호출하고 그 결과를 반환합니다. "
"만약 `Option`이 `None`이라면, 대신 `None`을 반환합니다."

#: src/error/option_unwrap/and_then.md:11
msgid ""
"In the following example, `cookable_v3()` results in an `Option<Food>`. "
"Using `map()` instead of `and_then()` would have given an "
"`Option<Option<Food>>`, which is an invalid type for `eat()`."
msgstr ""
"다음 예제에서, `cookable_v3()`는 `Option<Food>`를 결과로 냅니다. "
"`and_then()` 대신 `map()`을 사용했다면 `Option<Option<Food>>`를 얻었을 것이"
"며, 이는 `eat()`에 대해 유효하지 않은 타입입니다."

#: src/error/option_unwrap/and_then.md:20
msgid "// We don't have the ingredients to make Sushi.\n"
msgstr "// 우리는 스시를 만들 재료가 없습니다.\n"

#: src/error/option_unwrap/and_then.md:28
msgid "// We have the recipe for everything except Cordon Bleu.\n"
msgstr ""
"// 우리는 코르동 블뢰(Cordon Bleu)를 제외한 모든 것의 레시피를 가지고 있습니"
"다.\n"

#: src/error/option_unwrap/and_then.md:36
msgid ""
"// To make a dish, we need both the recipe and the ingredients.\n"
"// We can represent the logic with a chain of `match`es:\n"
msgstr ""
"// 요리를 하려면 레시피와 재료가 모두 필요합니다.\n"
"// 우리는 이 로직을 `match`들의 체인으로 표현할 수 있습니다:\n"

#: src/error/option_unwrap/and_then.md:45
msgid ""
"// This can conveniently be rewritten more compactly with `and_then()`:\n"
msgstr "// 이는 `and_then()`을 사용하여 더 간결하게 다시 작성될 수 있습니다:\n"

#: src/error/option_unwrap/and_then.md:50
msgid ""
"// Otherwise we'd need to `flatten()` an `Option<Option<Food>>`\n"
"// to get an `Option<Food>`:\n"
msgstr ""
"// 그렇지 않다면 `Option<Food>`를 얻기 위해 `Option<Option<Food>>`를 "
"`flatten()`해야 할 것입니다:\n"

#: src/error/option_unwrap/and_then.md:59
msgid "\"Yay! On {:?} we get to eat {:?}.\""
msgstr "\"야호! {:?}에 우리는 {:?}를 먹게 되었어요.\""

#: src/error/option_unwrap/and_then.md:60
msgid "\"Oh no. We don't get to eat on {:?}?\""
msgstr "\"오 이런. {:?}에는 못 먹는 건가요?\""

#: src/error/option_unwrap/and_then.md:75
msgid ""
"[closures](../../fn/closures.md), [`Option`](https://doc.rust-lang.org/std/"
"option/enum.Option.html), [`Option::and_then()`](https://doc.rust-lang.org/"
"std/option/enum.Option.html#method.and_then), and [`Option::flatten()`]"
"(https://doc.rust-lang.org/std/option/enum.Option.html#method.flatten)"
msgstr ""
"[클로저](../../fn/closures.md), [`Option`](https://doc.rust-lang.org/std/"
"option/enum.Option.html), [`Option::and_then()`](https://doc.rust-lang.org/"
"std/option/enum.Option.html#method.and_then), 그리고 [`Option::flatten()`]"
"(https://doc.rust-lang.org/std/option/enum.Option.html#method.flatten)"

#: src/error/option_unwrap/defaults.md:1
msgid "Unpacking options and defaults"
msgstr "Option 풀기와 기본값"

#: src/error/option_unwrap/defaults.md:3
msgid ""
"There is more than one way to unpack an `Option` and fall back on a default "
"if it is `None`. To choose the one that meets our needs, we need to consider "
"the following:"
msgstr ""
"`Option`이 `None`일 때 이를 풀고 기본값으로 돌아가는 방법은 여러 가지가 있습"
"니다. 우리의 필요에 맞는 것을 선택하려면 다음을 고려해야 합니다:"

#: src/error/option_unwrap/defaults.md:5
msgid "do we need eager or lazy evaluation?"
msgstr ""
"조급한(eager) 평가가 필요한가요, 아니면 느긋한(lazy) 평가가 필요한가요?"

#: src/error/option_unwrap/defaults.md:6
msgid ""
"do we need to keep the original empty value intact, or modify it in place?"
msgstr ""
"원래의 빈 값을 그대로 두어야 하나요, 아니면 그 자리에서 수정해야 하나요?"

#: src/error/option_unwrap/defaults.md:8
msgid "`or()` is chainable, evaluates eagerly, keeps empty value intact"
msgstr "`or()`은 체인 가능하며, 조급하게 평가하고, 빈 값을 그대로 유지합니다."

#: src/error/option_unwrap/defaults.md:10
msgid ""
"`or()`is chainable and eagerly evaluates its argument, as is shown in the "
"following example. Note that because `or`'s arguments are evaluated eagerly, "
"the variable passed to `or` is moved."
msgstr ""
"`or()`은 체인 가능하며 다음 예제에서 보듯 인자를 조급하게 평가합니다. `or`의 "
"인자들은 조급하게 평가되기 때문에, `or`에 전달된 변수는 이동(move)된다는 점"
"에 유의하세요."

#: src/error/option_unwrap/defaults.md:22
#: src/error/option_unwrap/defaults.md:55
msgid "\"first_available_fruit: {:?}\""
msgstr "\"first_available_fruit: {:?}\""

#: src/error/option_unwrap/defaults.md:23
msgid "// first_available_fruit: Some(Orange)\n"
msgstr "// first_available_fruit: Some(Orange)\n"

#: src/error/option_unwrap/defaults.md:25
msgid ""
"// `or` moves its argument.\n"
"    // In the example above, `or(orange)` returned a `Some`, so `or(apple)` "
"was not invoked.\n"
"    // But the variable named `apple` has been moved regardless, and cannot "
"be used anymore.\n"
"    // println!(\"Variable apple was moved, so this line won't compile: {:?}"
"\", apple);\n"
"    // TODO: uncomment the line above to see the compiler error\n"
msgstr ""
"// `or`는 인자를 이동시킵니다.\n"
"    // 위 예제에서 `or(orange)`가 `Some`을 반환했으므로 `or(apple)`은 호출되"
"지 않았습니다.\n"
"    // 하지만 `apple`이라는 이름의 변수는 상관없이 이동되었으며, 더 이상 사용"
"할 수 없습니다.\n"
"    // println!(\"Variable apple was moved, so this line won't compile: {:?}"
"\", apple);\n"
"    // TODO: 위 줄의 주석을 해제하여 컴파일러 에러를 확인해 보세요.\n"

#: src/error/option_unwrap/defaults.md:33
msgid "`or_else()` is chainable, evaluates lazily, keeps empty value intact"
msgstr ""
"`or_else()`는 체인 가능하며, 느긋하게 평가하고, 빈 값을 그대로 유지합니다."

#: src/error/option_unwrap/defaults.md:35
msgid ""
"Another alternative is to use `or_else`, which is also chainable, and "
"evaluates lazily, as is shown in the following example:"
msgstr ""
"또 다른 대안은 `or_else`를 사용하는 것입니다. 이 역시 체인 가능하며 다음 예제"
"에서 보듯 느긋하게 평가합니다:"

#: src/error/option_unwrap/defaults.md:44
msgid "\"Providing kiwi as fallback\""
msgstr "\"키위를 대체값으로 제공함\""

#: src/error/option_unwrap/defaults.md:48
#: src/error/option_unwrap/defaults.md:93
msgid "\"Providing lemon as fallback\""
msgstr "\"레몬을 대체값으로 제공함\""

#: src/error/option_unwrap/defaults.md:56
msgid ""
"// Providing kiwi as fallback\n"
"    // first_available_fruit: Some(Kiwi)\n"
msgstr ""
"// 키위를 대체값으로 제공함\n"
"    // first_available_fruit: Some(Kiwi)\n"

#: src/error/option_unwrap/defaults.md:61
msgid "`get_or_insert()` evaluates eagerly, modifies empty value in place"
msgstr "`get_or_insert()`는 조급하게 평가하며, 빈 값을 그 자리에서 수정합니다."

#: src/error/option_unwrap/defaults.md:63
msgid ""
"To make sure that an `Option` contains a value, we can use `get_or_insert` "
"to modify it in place with a fallback value, as is shown in the following "
"example. Note that `get_or_insert` eagerly evaluates its parameter, so "
"variable `apple` is moved:"
msgstr ""
"`Option`에 값이 포함되도록 보장하기 위해, 다음 예제에서 보듯 `get_or_insert`"
"를 사용하여 대체값으로 그 자리에서 수정할 수 있습니다. `get_or_insert`는 파라"
"미터를 조급하게 평가하므로, `apple` 변수는 이동된다는 점에 유의하세요."

#: src/error/option_unwrap/defaults.md:73
#: src/error/option_unwrap/defaults.md:98
msgid "\"first_available_fruit is: {:?}\""
msgstr "\"first_available_fruit is: {:?}\""

#: src/error/option_unwrap/defaults.md:74
#: src/error/option_unwrap/defaults.md:99
msgid "\"my_fruit is: {:?}\""
msgstr "\"my_fruit is: {:?}\""

#: src/error/option_unwrap/defaults.md:75
msgid ""
"// first_available_fruit is: Apple\n"
"    // my_fruit is: Some(Apple)\n"
"    //println!(\"Variable named `apple` is moved: {:?}\", apple);\n"
"    // TODO: uncomment the line above to see the compiler error\n"
msgstr ""
"// first_available_fruit is: Apple\n"
"    // my_fruit is: Some(Apple)\n"
"    //println!(\"apple이라는 이름의 변수는 이동되었습니다: {:?}\", apple);\n"
"    // TODO: 위 줄의 주석을 해제하여 컴파일러 에러를 확인해 보세요.\n"

#: src/error/option_unwrap/defaults.md:82
msgid "`get_or_insert_with()` evaluates lazily, modifies empty value in place"
msgstr ""
"`get_or_insert_with()`는 느긋하게 평가하며, 빈 값을 그 자리에서 수정합니다."

#: src/error/option_unwrap/defaults.md:84
msgid ""
"Instead of explicitly providing a value to fall back on, we can pass a "
"closure to `get_or_insert_with`, as follows:"
msgstr ""
"대체할 값을 명시적으로 제공하는 대신, 다음과 같이 `get_or_insert_with`에 클로"
"저를 전달할 수 있습니다:"

#: src/error/option_unwrap/defaults.md:100
msgid ""
"// Providing lemon as fallback\n"
"    // first_available_fruit is: Lemon\n"
"    // my_fruit is: Some(Lemon)\n"
msgstr ""
"// 레몬을 대체값으로 제공함\n"
"    // first_available_fruit is: Lemon\n"
"    // my_fruit is: Some(Lemon)\n"

#: src/error/option_unwrap/defaults.md:104
msgid ""
"// If the Option has a value, it is left unchanged, and the closure is not "
"invoked\n"
msgstr ""
"// Option에 값이 있으면 변경되지 않은 채로 유지되며, 클로저는 호출되지 않습니"
"다.\n"

#: src/error/option_unwrap/defaults.md:107
msgid "\"should_be_apple is: {:?}\""
msgstr "\"should_be_apple is: {:?}\""

#: src/error/option_unwrap/defaults.md:108
msgid "\"my_apple is unchanged: {:?}\""
msgstr "\"my_apple is unchanged: {:?}\""

#: src/error/option_unwrap/defaults.md:109
msgid ""
"// The output is a follows. Note that the closure `get_lemon_as_fallback` is "
"not invoked\n"
"    // should_be_apple is: Apple\n"
"    // my_apple is unchanged: Some(Apple)\n"
msgstr ""
"// 출력은 다음과 같습니다. `get_lemon_as_fallback` 클로저가 호출되지 않았음"
"에 유의하세요.\n"
"    // should_be_apple is: Apple\n"
"    // my_apple is unchanged: Some(Apple)\n"

#: src/error/option_unwrap/defaults.md:117
msgid ""
"[`closures`](https://doc.rust-lang.org/book/ch13-01-closures.html), "
"[`get_or_insert`](https://doc.rust-lang.org/core/option/"
"enum.Option.html#method.get_or_insert), [`get_or_insert_with`](https://"
"doc.rust-lang.org/core/option/enum.Option.html#method.get_or_insert_with), "
"[`moved variables`](https://doc.rust-lang.org/book/ch04-02-references-and-"
"borrowing.html), [`or`](https://doc.rust-lang.org/core/option/"
"enum.Option.html#method.or), [`or_else`](https://doc.rust-lang.org/core/"
"option/enum.Option.html#method.or_else)"
msgstr ""
"[`클로저(closures)`](https://doc.rust-lang.org/book/ch13-01-closures.html), "
"[`get_or_insert`](https://doc.rust-lang.org/core/option/"
"enum.Option.html#method.get_or_insert), [`get_or_insert_with`](https://"
"doc.rust-lang.org/core/option/enum.Option.html#method.get_or_insert_with), [`"
"이동된 변수(moved variables)`](https://doc.rust-lang.org/book/ch04-02-"
"references-and-borrowing.html), [`or`](https://doc.rust-lang.org/core/option/"
"enum.Option.html#method.or), [`or_else`](https://doc.rust-lang.org/core/"
"option/enum.Option.html#method.or_else)"

#: src/error/result.md:3
msgid ""
"[`Result`](https://doc.rust-lang.org/std/result/enum.Result.html) is a "
"richer version of the [`Option`](https://doc.rust-lang.org/std/option/"
"enum.Option.html) type that describes possible _error_ instead of possible "
"_absence_."
msgstr ""
"[`Result`](https://doc.rust-lang.org/std/result/enum.Result.html)은 발생 가능"
"한 *에러*를 설명하는, [`Option`](https://doc.rust-lang.org/std/option/"
"enum.Option.html) 타입의 더 풍부한 버전입니다."

#: src/error/result.md:6
msgid "That is, `Result<T, E>` could have one of two outcomes:"
msgstr "즉, `Result<T, E>`는 다음 두 가지 결과 중 하나를 가질 수 있습니다:"

#: src/error/result.md:8
msgid "`Ok(T)`: An element `T` was found"
msgstr "`Ok(T)`: 요소 `T`가 발견됨"

#: src/error/result.md:9
msgid "`Err(E)`: An error was found with element `E`"
msgstr "`Err(E)`: 요소 `E`와 함께 에러가 발견됨"

#: src/error/result.md:11
msgid ""
"By convention, the expected outcome is `Ok` while the unexpected outcome is "
"`Err`."
msgstr "관례적으로 기대되는 결과는 `Ok`이며, 기대하지 않은 결과는 `Err`입니다."

#: src/error/result.md:13
msgid ""
"Like `Option`, `Result` has many methods associated with it. `unwrap()`, for "
"example, either yields the element `T` or `panic`s. For case handling, there "
"are many combinators between `Result` and `Option` that overlap."
msgstr ""
"`Option`과 마찬가지로, `Result`도 많은 메서드들을 가지고 있습니다. 예를 들어 "
"`unwrap()`은 요소 `T`를 내놓거나 `panic`을 일으킵니다. 케이스 처리를 위해 "
"`Result`와 `Option` 사이에는 겹치는 많은 콤비네이터들이 있습니다."

#: src/error/result.md:17
msgid ""
"In working with Rust, you will likely encounter methods that return the "
"`Result` type, such as the [`parse()`](https://doc.rust-lang.org/std/"
"primitive.str.html#method.parse) method. It might not always be possible to "
"parse a string into the other type, so `parse()` returns a `Result` "
"indicating possible failure."
msgstr ""
"Rust로 작업하다 보면 [`parse()`](https://doc.rust-lang.org/std/"
"primitive.str.html#method.parse) 메서드와 같이 `Result` 타입을 반환하는 메서"
"드들을 자주 만나게 될 것입니다. 문자열을 다른 타입으로 파싱하는 것이 항상 가"
"능한 것은 아니므로, `parse()`는 실패 가능성을 나타내는 `Result`를 반환합니다."

#: src/error/result.md:22
msgid ""
"Let's see what happens when we successfully and unsuccessfully `parse()` a "
"string:"
msgstr ""
"문자열을 `parse()` 하는 데 성공했을 때와 실패했을 때 어떤 일이 일어나는지 봅"
"시다:"

#: src/error/result.md:26
msgid "// Let's try using `unwrap()` to get the number out. Will it bite us?\n"
msgstr "// `unwrap()`을 사용하여 숫자를 꺼내봅시다. 문제가 생길까요?\n"

#: src/error/result.md:33 src/error/result.md:36
#: src/error/result/result_map.md:42 src/error/result/result_map.md:46
#: src/error/result/result_map.md:75 src/error/result/result_map.md:79
#: src/error/result/result_alias.md:36 src/error/result/result_alias.md:37
#: src/error/result/early_returns.md:36 src/error/result/early_returns.md:37
#: src/error/result/enter_question_mark.md:34
#: src/error/result/enter_question_mark.md:35
#: src/error/result/enter_question_mark.md:67
#: src/error/result/enter_question_mark.md:68
msgid "\"2\""
msgstr "\"2\""

#: src/error/result.md:34 src/error/result.md:37
msgid "\"double is {}\""
msgstr "\"두 배는 {}\""

#: src/error/result.md:36 src/error/result/result_map.md:46
#: src/error/result/result_map.md:79 src/error/result/result_alias.md:37
#: src/error/result/early_returns.md:37
#: src/error/result/enter_question_mark.md:35
#: src/error/result/enter_question_mark.md:68
msgid "\"t\""
msgstr "\"t\""

#: src/error/result.md:41
msgid ""
"In the unsuccessful case, `parse()` leaves us with an error for `unwrap()` "
"to `panic` on. Additionally, the `panic` exits our program and provides an "
"unpleasant error message."
msgstr ""
"실패한 경우, `parse()`는 `unwrap()`이 `panic`을 일으킬 수 있도록 에러를 남깁"
"니다. 게다가 이 `panic`은 프로그램을 종료시키고 불쾌한 에러 메시지를 제공합니"
"다."

#: src/error/result.md:45
msgid ""
"To improve the quality of our error message, we should be more specific "
"about the return type and consider explicitly handling the error."
msgstr ""
"에러 메시지의 품질을 높이려면, 반환 타입에 대해 더 구체적이어야 하며 에러를 "
"명시적으로 처리하는 것을 고려해야 합니다."

#: src/error/result.md:48
msgid "Using `Result` in `main`"
msgstr "`main`에서 `Result` 사용하기"

#: src/error/result.md:50
msgid ""
"The `Result` type can also be the return type of the `main` function if "
"specified explicitly. Typically the `main` function will be of the form:"
msgstr ""
"`Result` 타입은 명시적으로 지정될 경우 `main` 함수의 반환 타입이 될 수도 있습"
"니다. 일반적으로 `main` 함수는 다음과 같은 형태입니다:"

#: src/error/result.md:59
msgid ""
"However `main` is also able to have a return type of `Result`. If an error "
"occurs within the `main` function it will return an error code and print a "
"debug representation of the error (using the [`Debug`](https://doc.rust-"
"lang.org/std/fmt/trait.Debug.html) trait). The following example shows such "
"a scenario and touches on aspects covered in [the following section](result/"
"early_returns.md)."
msgstr ""
"하지만 `main`은 반환 타입으로 `Result`를 가질 수도 있습니다. 만약 `main` 함"
"수 내에서 에러가 발생하면, 에러 코드를 반환하고 에러의 디버그 표현([`Debug`]"
"(https://doc.rust-lang.org/std/fmt/trait.Debug.html) 트레이트 사용)을 출력합"
"니다. 다음 예제는 그러한 시나리오를 보여주며 [다음 섹션](result/"
"early_returns.md)에서 다루는 측면들을 언급합니다."

#: src/error/result/result_map.md:3
msgid ""
"Panicking in the previous example's `multiply` does not make for robust "
"code. Generally, we want to return the error to the caller so it can decide "
"what is the right way to respond to errors."
msgstr ""
"이전 예제의 `multiply`에서 패닉을 일으키는 것은 견고한 코드가 아닙니다. 일반"
"적으로 우리는 호출자가 에러에 대응하는 올바른 방법을 결정할 수 있도록 에러를 "
"호출자에게 반환하기를 원합니다."

#: src/error/result/result_map.md:7
msgid ""
"We first need to know what kind of error type we are dealing with. To "
"determine the `Err` type, we look to [`parse()`](https://doc.rust-lang.org/"
"std/primitive.str.html#method.parse), which is implemented with the "
"[`FromStr`](https://doc.rust-lang.org/std/str/trait.FromStr.html) trait for "
"[`i32`](https://doc.rust-lang.org/std/primitive.i32.html). As a result, the "
"`Err` type is specified as [`ParseIntError`](https://doc.rust-lang.org/std/"
"num/struct.ParseIntError.html)."
msgstr ""
"먼저 우리가 어떤 종류의 에러 타입을 다루고 있는지 알아야 합니다. `Err` 타입"
"을 결정하기 위해, [`i32`](https://doc.rust-lang.org/std/primitive.i32.html)"
"에 대해 [`FromStr`](https://doc.rust-lang.org/std/str/trait.FromStr.html) 트"
"레이트로 구현된 [`parse()`](https://doc.rust-lang.org/std/"
"primitive.str.html#method.parse)를 살펴봅니다. 그 결과, `Err` 타입은 "
"[`ParseIntError`](https://doc.rust-lang.org/std/num/"
"struct.ParseIntError.html)로 지정됩니다."

#: src/error/result/result_map.md:12
msgid ""
"In the example below, the straightforward `match` statement leads to code "
"that is overall more cumbersome."
msgstr ""
"아래 예제에서, 단순한 `match` 문은 전체적으로 더 번거로운 코드로 이어집니다."

#: src/error/result/result_map.md:17
msgid ""
"// With the return type rewritten, we use pattern matching without "
"`unwrap()`.\n"
msgstr ""
"// 반환 타입을 다시 작성했으므로, `unwrap()` 없이 패턴 매칭을 사용합니다.\n"

#: src/error/result/result_map.md:35 src/error/result/result_map.md:68
#: src/error/result/result_alias.md:30 src/error/result/early_returns.md:30
#: src/error/result/enter_question_mark.md:28
#: src/error/result/enter_question_mark.md:61
msgid "\"n is {}\""
msgstr "\"n은 {}입니다\""

#: src/error/result/result_map.md:36 src/error/result/result_map.md:69
#: src/error/result/result_alias.md:31 src/error/result/early_returns.md:31
#: src/error/result/enter_question_mark.md:29
#: src/error/result/enter_question_mark.md:62
#: src/error/multiple_error_types/define_error_type.md:55
#: src/error/multiple_error_types/boxing_errors.md:42
#: src/error/multiple_error_types/reenter_question_mark.md:54
#: src/error/multiple_error_types/wrap_error.md:68
msgid "\"Error: {}\""
msgstr "\"에러: {}\""

#: src/error/result/result_map.md:41 src/error/result/result_map.md:74
msgid "// This still presents a reasonable answer.\n"
msgstr "// 이는 여전히 합리적인 답을 제시합니다.\n"

#: src/error/result/result_map.md:45 src/error/result/result_map.md:78
msgid "// The following now provides a much more helpful error message.\n"
msgstr "// 다음은 이제 훨씬 더 도움이 되는 에러 메시지를 제공합니다.\n"

#: src/error/result/result_map.md:51
msgid ""
"Luckily, `Option`'s `map`, `and_then`, and many other combinators are also "
"implemented for `Result`. [`Result`](https://doc.rust-lang.org/std/result/"
"enum.Result.html) contains a complete listing."
msgstr ""
"다행히도 `Option`의 `map`, `and_then` 및 다른 많은 콤비네이터들이 `Result`에 "
"대해서도 구현되어 있습니다. [`Result`](https://doc.rust-lang.org/std/result/"
"enum.Result.html) 문서에 전체 목록이 나와 있습니다."

#: src/error/result/result_map.md:56
msgid ""
"// As with `Option`, we can use combinators such as `map()`.\n"
"// This function is otherwise identical to the one above and reads:\n"
"// Multiply if both values can be parsed from str, otherwise pass on the "
"error.\n"
msgstr ""
"// `Option`과 마찬가지로 `map()`과 같은 콤비네이터를 사용할 수 있습니다.\n"
"// 이 함수는 위와 동일하며 다음과 같이 읽힙니다:\n"
"// 두 값 모두 문자열에서 파싱될 수 있으면 곱하고, 그렇지 않으면 에러를 넘깁니"
"다.\n"

#: src/error/result/result_alias.md:3
msgid ""
"How about when we want to reuse a specific `Result` type many times? Recall "
"that Rust allows us to create [aliases](../../types/alias.md). Conveniently, "
"we can define one for the specific `Result` in question."
msgstr ""
"특정한 `Result` 타입을 여러 번 재사용하고 싶을 때는 어떨까요? Rust는 [별칭"
"(aliases)](../../types/alias.md)을 만들 수 있게 해준다는 점을 기억하세요. 편"
"리하게도 문제의 특정 `Result`에 대해 별칭을 정의할 수 있습니다."

#: src/error/result/result_alias.md:7
msgid ""
"At a module level, creating aliases can be particularly helpful. Errors "
"found in a specific module often have the same `Err` type, so a single alias "
"can succinctly define _all_ associated `Results`. This is so useful that the "
"`std` library even supplies one: [`io::Result`](https://doc.rust-lang.org/"
"std/io/type.Result.html)!"
msgstr ""
"모듈 수준에서 별칭을 만드는 것은 특히 유용할 수 있습니다. 특정 모듈에서 발견"
"되는 에러들은 종종 동일한 `Err` 타입을 가지므로, 단일 별칭으로 모든 연관된 "
"`Result`들을 간결하게 정의할 수 있습니다. 이는 매우 유용하여 표준 라이브러리"
"에서도 하나를 제공합니다: [`io::Result`](https://doc.rust-lang.org/std/io/"
"type.Result.html)!"

#: src/error/result/result_alias.md:12
msgid "Here's a quick example to show off the syntax:"
msgstr "다음은 문법을 보여주는 간단한 예제입니다:"

#: src/error/result/result_alias.md:16
msgid ""
"// Define a generic alias for a `Result` with the error type "
"`ParseIntError`.\n"
msgstr ""
"// 에러 타입이 `ParseIntError`인 `Result`에 대한 제네릭 별칭을 정의합니다.\n"

#: src/error/result/result_alias.md:19
msgid "// Use the above alias to refer to our specific `Result` type.\n"
msgstr "// 위 별칭을 사용하여 우리의 특정한 `Result` 타입을 참조합니다.\n"

#: src/error/result/result_alias.md:26
msgid "// Here, the alias again allows us to save some space.\n"
msgstr "// 여기서도 별칭을 사용하여 공간을 절약할 수 있습니다.\n"

#: src/error/result/result_alias.md:43
msgid "[`io::Result`](https://doc.rust-lang.org/std/io/type.Result.html)"
msgstr "[`io::Result`](https://doc.rust-lang.org/std/io/type.Result.html)"

#: src/error/result/early_returns.md:3
msgid ""
"In the previous example, we explicitly handled the errors using combinators. "
"Another way to deal with this case analysis is to use a combination of "
"`match` statements and _early returns_."
msgstr ""
"이전 예제에서 우리는 콤비네이터를 사용하여 에러를 명시적으로 처리했습니다. 이"
"러한 케이스 분석을 처리하는 또 다른 방법은 `match` 문과 *조기 리턴(early "
"returns)*을 조합하여 사용하는 것입니다."

#: src/error/result/early_returns.md:7
msgid ""
"That is, we can simply stop executing the function and return the error if "
"one occurs. For some, this form of code can be easier to both read and "
"write. Consider this version of the previous example, rewritten using early "
"returns:"
msgstr ""
"즉, 에러가 발생하면 단순히 함수의 실행을 멈추고 에러를 반환할 수 있습니다. 어"
"떤 이들에게는 이런 형태의 코드가 읽고 쓰기에 더 쉬울 수 있습니다. 이전 예제"
"를 조기 리턴을 사용하여 다시 작성한 버전을 살펴보세요:"

#: src/error/result/early_returns.md:41
msgid ""
"At this point, we've learned to explicitly handle errors using combinators "
"and early returns. While we generally want to avoid panicking, explicitly "
"handling all of our errors is cumbersome."
msgstr ""
"지금까지 우리는 콤비네이터와 조기 리턴을 사용하여 에러를 명시적으로 처리하는 "
"방법을 배웠습니다. 일반적으로 패닉은 피하고 싶지만, 모든 에러를 명시적으로 처"
"리하는 것은 번거로운 일입니다."

#: src/error/result/early_returns.md:45
msgid ""
"In the next section, we'll introduce `?` for the cases where we simply need "
"to `unwrap` without possibly inducing `panic`."
msgstr ""
"다음 섹션에서는 `panic`을 일으키지 않고 단순히 `unwrap`이 필요한 경우를 위한 "
"`?`를 소개하겠습니다."

#: src/error/result/enter_question_mark.md:3
msgid ""
"Sometimes we just want the simplicity of `unwrap` without the possibility of "
"a `panic`. Until now, `unwrap` has forced us to nest deeper and deeper when "
"what we really wanted was to get the variable _out_. This is exactly the "
"purpose of `?`."
msgstr ""
"때로는 `panic`의 가능성 없이 `unwrap`의 단순함만을 원할 때가 있습니다. 지금까"
"지 `unwrap`은 우리가 정말 원했던 것이 변수를 꺼내는 것임에도 불구하고 점점 "
"더 깊게 중첩하도록 강제해 왔습니다. 이것이 바로 `?`의 목적입니다."

#: src/error/result/enter_question_mark.md:7
msgid "Upon finding an `Err`, there are two valid actions to take:"
msgstr "`Err`을 발견했을 때 취할 수 있는 유효한 조치는 두 가지입니다:"

#: src/error/result/enter_question_mark.md:9
msgid "`panic!` which we already decided to try to avoid if possible"
msgstr "가능하다면 피하기로 이미 결정한 `panic!`"

#: src/error/result/enter_question_mark.md:10
msgid "`return` because an `Err` means it cannot be handled"
msgstr "`Err`은 처리될 수 없음을 의미하므로 `return`"

#: src/error/result/enter_question_mark.md:12
msgid ""
"`?` is _almost_[^†] exactly equivalent to an `unwrap` which `return`s "
"instead of `panic`king on `Err`s. Let's see how we can simplify the earlier "
"example that used combinators:"
msgstr ""
"`?`는 `Err`에 대해 `panic`을 일으키는 대신 `return`하는 `unwrap`과 거의[^†] "
"정확히 동일합니다. 콤비네이터를 사용했던 이전 예제를 어떻게 단순화할 수 있는"
"지 봅시다:"

#: src/error/result/enter_question_mark.md:39
msgid "The `try!` macro"
msgstr "`try!` 매크로"

#: src/error/result/enter_question_mark.md:41
msgid ""
"Before there was `?`, the same functionality was achieved with the `try!` "
"macro. The `?` operator is now recommended, but you may still find `try!` "
"when looking at older code. The same `multiply` function from the previous "
"example would look like this using `try!`:"
msgstr ""
"`?`가 나오기 전에는 동일한 기능을 `try!` 매크로로 구현했습니다. 현재는 `?` 연"
"산자가 권장되지만, 오래된 코드를 볼 때 여전히 `try!`를 발견할 수도 있습니다. "
"이전 예제의 동일한 `multiply` 함수는 `try!`를 사용하면 다음과 같습니다:"

#: src/error/result/enter_question_mark.md:47
msgid ""
"// To compile and run this example without errors, while using Cargo, change "
"the value\n"
"// of the `edition` field, in the `[package]` section of the `Cargo.toml` "
"file, to \"2015\".\n"
msgstr ""
"// Cargo를 사용하면서 이 예제를 에러 없이 컴파일하고 실행하려면,\n"
"// `Cargo.toml` 파일의 `[package]` 섹션에 있는 `edition` 필드 값을 "
"\"2015\"로 변경하세요.\n"

#: src/error/result/enter_question_mark.md:72
msgid ""
"See [re-enter ?](../multiple_error_types/reenter_question_mark.md) for more "
"details."
msgstr ""
"자세한 내용은 [? 다시 보기](../multiple_error_types/reenter_question_mark.md)"
"를 참조하세요."

#: src/error/multiple_error_types.md:3
msgid ""
"The previous examples have always been very convenient; `Result`s interact "
"with other `Result`s and `Option`s interact with other `Option`s."
msgstr ""
"이전 예제들은 항상 매우 편리했습니다. `Result`는 다른 `Result`와 상호작용하"
"고, `Option`은 다른 `Option`과 상호작용했습니다."

#: src/error/multiple_error_types.md:6
msgid ""
"Sometimes an `Option` needs to interact with a `Result`, or a `Result<T, "
"Error1>` needs to interact with a `Result<T, Error2>`. In those cases, we "
"want to manage our different error types in a way that makes them composable "
"and easy to interact with."
msgstr ""
"때때로는 `Option`이 `Result`와 상호작용해야 하거나, `Result<T, Error1>`이 "
"`Result<T, Error2>`와 상호작용해야 할 때가 있습니다. 그런 경우, 우리는 서로 "
"다른 에러 타입들을 구성 가능하고 상호작용하기 쉬운 방식으로 관리하고 싶어 합"
"니다."

#: src/error/multiple_error_types.md:11
msgid ""
"In the following code, two instances of `unwrap` generate different error "
"types. `Vec::first` returns an `Option`, while `parse::<i32>` returns a "
"`Result<i32, ParseIntError>`:"
msgstr ""
"다음 코드에서, 두 개의 `unwrap` 인스턴스는 서로 다른 에러 타입을 생성합니다. "
"`Vec::first`는 `Option`을 반환하는 반면, `parse::<i32>`는 `Result<i32, "
"ParseIntError>`를 반환합니다:"

#: src/error/multiple_error_types.md:17
msgid "// Generate error 1\n"
msgstr "// 에러 1 발생\n"

#: src/error/multiple_error_types.md:18
msgid "// Generate error 2\n"
msgstr "// 에러 2 발생\n"

#: src/error/multiple_error_types.md:22
#: src/error/multiple_error_types/option_result.md:16
#: src/error/multiple_error_types/option_result.md:45
#: src/error/multiple_error_types/define_error_type.md:60
#: src/error/multiple_error_types/boxing_errors.md:47
#: src/error/multiple_error_types/reenter_question_mark.md:59
#: src/error/multiple_error_types/wrap_error.md:77 src/error/iter_result.md:40
msgid "\"42\""
msgstr "\"42\""

#: src/error/multiple_error_types.md:22 src/error/multiple_error_types.md:24
#: src/error/multiple_error_types/option_result.md:16
#: src/error/multiple_error_types/option_result.md:18
#: src/error/multiple_error_types/option_result.md:45
#: src/error/multiple_error_types/option_result.md:47
#: src/error/multiple_error_types/define_error_type.md:60
#: src/error/multiple_error_types/define_error_type.md:62
#: src/error/multiple_error_types/boxing_errors.md:47
#: src/error/multiple_error_types/boxing_errors.md:49
#: src/error/multiple_error_types/reenter_question_mark.md:59
#: src/error/multiple_error_types/reenter_question_mark.md:61
#: src/error/multiple_error_types/wrap_error.md:77
#: src/error/multiple_error_types/wrap_error.md:79 src/error/iter_result.md:7
#: src/error/iter_result.md:24 src/error/iter_result.md:40
#: src/error/iter_result.md:60 src/error/iter_result.md:75
#: src/error/iter_result.md:90
msgid "\"93\""
msgstr "\"93\""

#: src/error/multiple_error_types.md:22 src/error/multiple_error_types.md:24
#: src/error/multiple_error_types/option_result.md:16
#: src/error/multiple_error_types/option_result.md:18
#: src/error/multiple_error_types/option_result.md:45
#: src/error/multiple_error_types/option_result.md:47
#: src/error/multiple_error_types/define_error_type.md:60
#: src/error/multiple_error_types/define_error_type.md:62
#: src/error/multiple_error_types/boxing_errors.md:47
#: src/error/multiple_error_types/boxing_errors.md:49
#: src/error/multiple_error_types/reenter_question_mark.md:59
#: src/error/multiple_error_types/reenter_question_mark.md:61
#: src/error/multiple_error_types/wrap_error.md:77
#: src/error/multiple_error_types/wrap_error.md:79 src/error/iter_result.md:7
#: src/error/iter_result.md:24 src/error/iter_result.md:40
#: src/error/iter_result.md:60 src/error/iter_result.md:75
#: src/error/iter_result.md:90
msgid "\"18\""
msgstr "\"18\""

#: src/error/multiple_error_types.md:24
#: src/error/multiple_error_types/option_result.md:18
#: src/error/multiple_error_types/option_result.md:47
#: src/error/multiple_error_types/define_error_type.md:62
#: src/error/multiple_error_types/boxing_errors.md:49
#: src/error/multiple_error_types/reenter_question_mark.md:61
#: src/error/multiple_error_types/wrap_error.md:79 src/error/iter_result.md:7
#: src/error/iter_result.md:24 src/error/iter_result.md:40
#: src/error/iter_result.md:60 src/error/iter_result.md:75
#: src/error/iter_result.md:90
msgid "\"tofu\""
msgstr "\"두부\""

#: src/error/multiple_error_types.md:26 src/error/multiple_error_types.md:28
#: src/error/multiple_error_types.md:31
#: src/error/multiple_error_types/define_error_type.md:54
#: src/error/multiple_error_types/boxing_errors.md:41
#: src/error/multiple_error_types/reenter_question_mark.md:53
#: src/error/multiple_error_types/wrap_error.md:66
msgid "\"The first doubled is {}\""
msgstr "\"두 배가 된 첫 번째 값은 {}입니다\""

#: src/error/multiple_error_types.md:29
#: src/error/multiple_error_types/option_result.md:23
msgid "// Error 1: the input vector is empty\n"
msgstr "// 에러 1: 입력 벡터가 비어 있습니다\n"

#: src/error/multiple_error_types.md:32
#: src/error/multiple_error_types/option_result.md:26
msgid "// Error 2: the element doesn't parse to a number\n"
msgstr "// 에러 2: 요소를 숫자로 파싱할 수 없습니다\n"

#: src/error/multiple_error_types.md:36
msgid ""
"Over the next sections, we'll see several strategies for handling these kind "
"of problems."
msgstr ""
"다음 섹션들에서 이러한 종류의 문제들을 처리하기 위한 몇 가지 전략을 살펴볼 것"
"입니다."

#: src/error/multiple_error_types/option_result.md:3
msgid ""
"The most basic way of handling mixed error types is to just embed them in "
"each other."
msgstr ""
"혼합된 에러 타입들을 처리하는 가장 기본적인 방법은 단순히 서로를 내포시키는 "
"것입니다."

#: src/error/multiple_error_types/option_result.md:20
#: src/error/multiple_error_types/option_result.md:22
#: src/error/multiple_error_types/option_result.md:25
#: src/error/multiple_error_types/option_result.md:49
#: src/error/multiple_error_types/option_result.md:50
#: src/error/multiple_error_types/option_result.md:51
msgid "\"The first doubled is {:?}\""
msgstr "\"두 배가 된 첫 번째 값은 {:?}입니다\""

#: src/error/multiple_error_types/option_result.md:30
msgid ""
"There are times when we'll want to stop processing on errors (like with [`?`]"
"(../result/enter_question_mark.md)) but keep going when the `Option` is "
"`None`. The `transpose` function comes in handy to swap the `Result` and "
"`Option`."
msgstr ""
"에러가 발생하면 처리를 중단하고 싶지만([?](../result/enter_question_mark.md)"
"와 같이), `Option`이 `None`일 때는 계속 진행하고 싶을 때가 있습니다. 이럴 때 "
"`Result`와 `Option`을 서로 바꾸어 주는 `transpose` 함수가 유용합니다."

#: src/error/multiple_error_types/define_error_type.md:3
msgid ""
"Sometimes it simplifies the code to mask all of the different errors with a "
"single type of error.  We'll show this with a custom error."
msgstr ""
"때로는 모든 서로 다른 에러들을 하나의 에러 타입으로 마스킹하는 것이 코드를 단"
"순화합니다. 이를 커스텀 에러를 통해 보여주겠습니다."

#: src/error/multiple_error_types/define_error_type.md:6
msgid ""
"Rust allows us to define our own error types. In general, a \"good\" error "
"type:"
msgstr ""
"Rust에서는 우리만의 에러 타입을 정의할 수 있습니다. 일반적으로 \"좋은\" 에러 "
"타입은 다음과 같습니다:"

#: src/error/multiple_error_types/define_error_type.md:8
msgid "Represents different errors with the same type"
msgstr "서로 다른 에러들을 동일한 타입으로 표현합니다"

#: src/error/multiple_error_types/define_error_type.md:9
msgid "Presents nice error messages to the user"
msgstr "사용자에게 보기 좋은 에러 메시지를 제공합니다"

#: src/error/multiple_error_types/define_error_type.md:10
msgid "Is easy to compare with other types"
msgstr "다른 타입들과 비교하기 쉽습니다"

#: src/error/multiple_error_types/define_error_type.md:11
msgid "Good: `Err(EmptyVec)`"
msgstr "좋은 예: `Err(EmptyVec)`"

#: src/error/multiple_error_types/define_error_type.md:12
msgid ""
"Bad: `Err(\"Please use a vector with at least one element\".to_owned())`"
msgstr ""
"나쁜 예: `Err(\"Please use a vector with at least one element\".to_owned())`"

#: src/error/multiple_error_types/define_error_type.md:13
msgid "Can hold information about the error"
msgstr "에러에 대한 정보를 담을 수 있습니다"

#: src/error/multiple_error_types/define_error_type.md:14
msgid "Good: `Err(BadChar(c, position))`"
msgstr "좋은 예: `Err(BadChar(c, position))`"

#: src/error/multiple_error_types/define_error_type.md:15
msgid "Bad: `Err(\"+ cannot be used here\".to_owned())`"
msgstr "나쁜 예: `Err(\"+ cannot be used here\".to_owned())`"

#: src/error/multiple_error_types/define_error_type.md:16
msgid "Composes well with other errors"
msgstr "다른 에러들과 잘 구성(compose)됩니다"

#: src/error/multiple_error_types/define_error_type.md:22
msgid ""
"// Define our error types. These may be customized for our error handling "
"cases.\n"
"// Now we will be able to write our own errors, defer to an underlying "
"error\n"
"// implementation, or do something in between.\n"
msgstr ""
"// 우리의 에러 타입들을 정의합니다. 이들은 우리의 에러 처리 케이스에 맞게 커"
"스터마이징될 수 있습니다.\n"
"// 이제 우리만의 에러를 작성하거나, 기저 에러 구현에 위임하거나, 혹은 그 사이"
"의 작업을 수행할 수 있습니다.\n"

#: src/error/multiple_error_types/define_error_type.md:28
msgid ""
"// Generation of an error is completely separate from how it is displayed.\n"
"// There's no need to be concerned about cluttering complex logic with the "
"display style.\n"
"//\n"
"// Note that we don't store any extra info about the errors. This means we "
"can't state\n"
"// which string failed to parse without modifying our types to carry that "
"information.\n"
msgstr ""
"// 에러의 생성은 표시 방식과 완전히 분리되어 있습니다.\n"
"// 표시 스타일 때문에 복잡한 로직이 어지러워질까 봐 걱정할 필요가 없습니다.\n"
"//\n"
"// 참고로 우리는 에러에 대한 추가 정보를 저장하지 않습니다. 즉, 정보를 담도"
"록 타입을 수정하지 않고서는\n"
"// 어떤 문자열이 파싱에 실패했는지 알 수 없습니다.\n"

#: src/error/multiple_error_types/define_error_type.md:36
#: src/error/multiple_error_types/boxing_errors.md:23
#: src/error/multiple_error_types/reenter_question_mark.md:37
msgid "\"invalid first item to double\""
msgstr "\"두 배로 만들 첫 번째 항목이 유효하지 않습니다\""

#: src/error/multiple_error_types/define_error_type.md:42
msgid "// Change the error to our new type.\n"
msgstr "// 에러를 우리의 새로운 타입으로 변경합니다.\n"

#: src/error/multiple_error_types/define_error_type.md:46
msgid "// Update to the new error type here also.\n"
msgstr "// 여기서도 새로운 에러 타입으로 업데이트합니다.\n"

#: src/error/multiple_error_types/boxing_errors.md:3
msgid ""
"A way to write simple code while preserving the original errors is to [`Box`]"
"(https://doc.rust-lang.org/std/boxed/struct.Box.html) them.  The drawback is "
"that the underlying error type is only known at runtime and not [statically "
"determined](https://doc.rust-lang.org/book/ch17-02-trait-objects.html#trait-"
"objects-perform-dynamic-dispatch)."
msgstr ""
"원본 에러를 보존하면서 단순한 코드를 작성하는 방법은 에러들을 [`Box`]"
"(https://doc.rust-lang.org/std/boxed/struct.Box.html)하는 것입니다. 단점은 기"
"저 에러 타입을 런타임에만 알 수 있고 [정적으로 결정](https://doc.rust-"
"lang.org/book/ch17-02-trait-objects.html#trait-objects-perform-dynamic-"
"dispatch)되지 않는다는 것입니다."

#: src/error/multiple_error_types/boxing_errors.md:7
msgid ""
"The stdlib helps in boxing our errors by having `Box` implement conversion "
"from any type that implements the `Error` trait into the trait object "
"`Box<Error>`, via [`From`](https://doc.rust-lang.org/std/convert/"
"trait.From.html)."
msgstr ""
"표준 라이브러리는 `Box`가 [`From`](https://doc.rust-lang.org/std/convert/"
"trait.From.html)을 통해 `Error` 트레이트를 구현하는 모든 타입으로부터 트레이"
"트 객체 `Box<Error>`로의 변환을 구현하도록 함으로써 에러를 박싱하는 것을 돕습"
"니다."

#: src/error/multiple_error_types/boxing_errors.md:14
#: src/error/multiple_error_types/reenter_question_mark.md:28
msgid "// Change the alias to use `Box<dyn error::Error>`.\n"
msgstr "// 별칭이 `Box<dyn error::Error>`를 사용하도록 변경합니다.\n"

#: src/error/multiple_error_types/boxing_errors.md:31
msgid "// Converts to Box using Into trait.\n"
msgstr "// Into 트레이트를 사용하여 Box로 변환합니다.\n"

#: src/error/multiple_error_types/boxing_errors.md:34
msgid "// Converts to Box using From::from fn pointer.\n"
msgstr "// From::from 함수 포인터를 사용하여 Box로 변환합니다.\n"

#: src/error/multiple_error_types/boxing_errors.md:59
msgid ""
"[Dynamic dispatch](https://doc.rust-lang.org/book/ch17-02-trait-"
"objects.html#trait-objects-perform-dynamic-dispatch) and [`Error` trait]"
"(https://doc.rust-lang.org/std/error/trait.Error.html)"
msgstr ""
"[동적 디스패치(Dynamic dispatch)](https://doc.rust-lang.org/book/ch17-02-"
"trait-objects.html#trait-objects-perform-dynamic-dispatch)와 [`Error` 트레이"
"트](https://doc.rust-lang.org/std/error/trait.Error.html)"

#: src/error/multiple_error_types/reenter_question_mark.md:3
msgid ""
"Notice in the previous example that our immediate reaction to calling "
"`parse` is to `map` the error from a library error into a boxed error:"
msgstr ""
"이전 예제에서 `parse`를 호출했을 때 우리의 즉각적인 반응은 라이브러리 에러를 "
"박싱된 에러로 `map`하는 것이었습니다:"

#: src/error/multiple_error_types/reenter_question_mark.md:12
msgid ""
"Since this is a simple and common operation, it would be convenient if it "
"could be elided. Alas, because `and_then` is not sufficiently flexible, it "
"cannot. However, we can instead use `?`."
msgstr ""
"이는 단순하고 흔한 작업이므로 생략할 수 있다면 편리할 것입니다. 아쉽게도 "
"`and_then`은 충분히 유연하지 못해 생략할 수 없습니다. 하지만 대신 `?`를 사용"
"할 수 있습니다."

#: src/error/multiple_error_types/reenter_question_mark.md:16
msgid ""
"`?` was previously explained as either `unwrap` or `return Err(err)`. This "
"is only mostly true. It actually means `unwrap` or `return "
"Err(From::from(err))`. Since `From::from` is a conversion utility between "
"different types, this means that if you `?` where the error is convertible "
"to the return type, it will convert automatically."
msgstr ""
"`?`는 이전에 `unwrap` 또는 `return Err(err)`로 설명되었습니다. 이는 거의 맞지"
"만 전부는 아닙니다. 실제로는 `unwrap` 또는 `return Err(From::from(err))`를 의"
"미합니다. `From::from`은 서로 다른 타입 간의 변환 유틸리티이므로, 에러가 반"
"환 타입으로 변환 가능한 곳에서 `?`를 사용하면 자동으로 변환됩니다."

#: src/error/multiple_error_types/reenter_question_mark.md:22
msgid ""
"Here, we rewrite the previous example using `?`. As a result, the `map_err` "
"will go away when `From::from` is implemented for our error type:"
msgstr ""
"여기서는 이전 예제를 `?`를 사용하여 다시 작성합니다. 결과적으로, 우리의 에러 "
"타입에 대해 `From::from`이 구현되면 `map_err`이 사라질 것입니다:"

#: src/error/multiple_error_types/reenter_question_mark.md:42
msgid ""
"// The same structure as before but rather than chain all `Results`\n"
"// and `Options` along, we `?` to get the inner value out immediately.\n"
msgstr ""
"// 이전과 동일한 구조이지만 모든 `Result`와 `Option`을 체인으로 연결하는 대"
"신,\n"
"// `?`를 사용하여 즉시 내부 값을 꺼냅니다.\n"

#: src/error/multiple_error_types/reenter_question_mark.md:69
msgid ""
"This is actually fairly clean now. Compared with the original `panic`, it is "
"very similar to replacing the `unwrap` calls with `?` except that the return "
"types are `Result`. As a result, they must be destructured at the top level."
msgstr ""
"이제 상당히 깔끔해졌습니다. 원본 `panic` 예제와 비교하면, 반환 타입이 "
"`Result`라는 점을 제외하고는 `unwrap` 호출을 `?`로 대체한 것과 매우 유사합니"
"다. 그 결과, 이들은 최상위 레벨에서 구조 분해(destructure)되어야 합니다."

#: src/error/multiple_error_types/reenter_question_mark.md:76
msgid ""
"[`From::from`](https://doc.rust-lang.org/std/convert/trait.From.html) and [`?"
"`](https://doc.rust-lang.org/reference/expressions/operator-expr.html#the-"
"question-mark-operator)"
msgstr ""
"[`From::from`](https://doc.rust-lang.org/std/convert/trait.From.html)과 [`?`]"
"(https://doc.rust-lang.org/reference/expressions/operator-expr.html#the-"
"question-mark-operator)"

#: src/error/multiple_error_types/wrap_error.md:3
msgid "An alternative to boxing errors is to wrap them in your own error type."
msgstr ""
"에러를 박싱하는 것의 대안은 에러를 여러분만의 에러 타입으로 감싸는 것입니다."

#: src/error/multiple_error_types/wrap_error.md:16
msgid ""
"// We will defer to the parse error implementation for their error.\n"
"    // Supplying extra info requires adding more data to the type.\n"
msgstr ""
"// 파싱 에러에 대해서는 해당 에러 구현에 위임할 것입니다.\n"
"// 추가 정보를 제공하려면 타입에 더 많은 데이터를 추가해야 합니다.\n"

#: src/error/multiple_error_types/wrap_error.md:25
msgid "\"please use a vector with at least one element\""
msgstr "\"최소한 하나의 요소를 가진 벡터를 사용하세요\""

#: src/error/multiple_error_types/wrap_error.md:26
msgid ""
"// The wrapped error contains additional information and is available\n"
"            // via the source() method.\n"
msgstr ""
"// 감싸진 에러는 추가 정보를 포함하며 `source()` 메서드를 통해\n"
"// 사용할 수 있습니다.\n"

#: src/error/multiple_error_types/wrap_error.md:29
msgid "\"the provided string could not be parsed as int\""
msgstr "\"제공된 문자열을 정수로 파싱할 수 없습니다\""

#: src/error/multiple_error_types/wrap_error.md:38
msgid ""
"// The cause is the underlying implementation error type. Is implicitly\n"
"            // cast to the trait object `&error::Error`. This works because "
"the\n"
"            // underlying type already implements the `Error` trait.\n"
msgstr ""
"// 원인은 기저 구현 에러 타입입니다. 이는 트레이트 객체 `&error::Error`로\n"
"// 암시적으로 캐스팅됩니다. 기저 타입이 이미 `Error` 트레이트를\n"
"// 구현하고 있기 때문에 작동합니다.\n"

#: src/error/multiple_error_types/wrap_error.md:45
msgid ""
"// Implement the conversion from `ParseIntError` to `DoubleError`.\n"
"// This will be automatically called by `?` if a `ParseIntError`\n"
"// needs to be converted into a `DoubleError`.\n"
msgstr ""
"// `ParseIntError`에서 `DoubleError`로의 변환을 구현합니다.\n"
"// `ParseIntError`를 `DoubleError`로 변환해야 할 때 `?`에 의해\n"
"// 자동으로 호출됩니다.\n"

#: src/error/multiple_error_types/wrap_error.md:57
msgid ""
"// Here we implicitly use the `ParseIntError` implementation of `From` "
"(which\n"
"    // we defined above) in order to create a `DoubleError`.\n"
msgstr ""
"// 여기서 우리는 `DoubleError`를 생성하기 위해 (위에서 정의한)\n"
"// `From`의 `ParseIntError` 구현을 암시적으로 사용합니다.\n"

#: src/error/multiple_error_types/wrap_error.md:70
msgid "\"  Caused by: {}\""
msgstr "\"  원인: {}\""

#: src/error/multiple_error_types/wrap_error.md:87
msgid ""
"This adds a bit more boilerplate for handling errors and might not be needed "
"in all applications. There are some libraries that can take care of the "
"boilerplate for you."
msgstr ""
"이는 에러 처리를 위해 상용구(boilerplate) 코드를 조금 더 추가하며, 모든 애플"
"리케이션에서 필요하지는 않을 수 있습니다. 상용구 코드를 대신 처리해 주는 몇"
"몇 라이브러리들이 있습니다."

#: src/error/multiple_error_types/wrap_error.md:93
msgid ""
"[`From::from`](https://doc.rust-lang.org/std/convert/trait.From.html) and "
"[`Enums`](../../custom_types/enum.md)"
msgstr ""
"[`From::from`](https://doc.rust-lang.org/std/convert/trait.From.html)과 [열거"
"형(Enums)](../../custom_types/enum.md)"

#: src/error/multiple_error_types/wrap_error.md:95
msgid ""
"[`Crates for handling errors`](https://crates.io/keywords/error-handling)"
msgstr ""
"[에러 처리를 위한 크레이트들](https://crates.io/keywords/error-handling)"

#: src/error/iter_result.md:3
msgid "An `Iter::map` operation might fail, for example:"
msgstr "예를 들어, `Iter::map` 연산은 실패할 수 있습니다:"

#: src/error/iter_result.md:12 src/error/iter_result.md:29
#: src/error/iter_result.md:65
msgid "\"Results: {:?}\""
msgstr "\"결과: {:?}\""

#: src/error/iter_result.md:16
msgid "Let's step through strategies for handling this."
msgstr "이를 처리하기 위한 전략들을 단계별로 살펴봅시다."

#: src/error/iter_result.md:18
msgid "Ignore the failed items with `filter_map()`"
msgstr "`filter_map()`으로 실패한 항목 무시하기"

#: src/error/iter_result.md:20
msgid ""
"`filter_map` calls a function and filters out the results that are `None`."
msgstr "`filter_map`은 함수를 호출하고 그 결과가 `None`인 것들을 걸러냅니다."

#: src/error/iter_result.md:33
msgid "Collect the failed items with `map_err()` and `filter_map()`"
msgstr "`map_err()`와 `filter_map()`으로 실패한 항목 수집하기"

#: src/error/iter_result.md:35
msgid ""
"`map_err` calls a function with the error, so by adding that to the previous "
"`filter_map` solution we can save them off to the side while iterating."
msgstr ""
"`map_err`은 에러와 함께 함수를 호출하므로, 이를 이전의 `filter_map` 방식에 추"
"가하여 순회하는 동안 에러들을 따로 저장해둘 수 있습니다."

#: src/error/iter_result.md:40
msgid "\"999\""
msgstr "\"999\""

#: src/error/iter_result.md:47 src/error/iter_result.md:80
#: src/error/iter_result.md:97
msgid "\"Numbers: {:?}\""
msgstr "\"숫자: {:?}\""

#: src/error/iter_result.md:48 src/error/iter_result.md:81
#: src/error/iter_result.md:98
msgid "\"Errors: {:?}\""
msgstr "\"에러: {:?}\""

#: src/error/iter_result.md:52
msgid "Fail the entire operation with `collect()`"
msgstr "`collect()`를 사용하여 전체 연산을 실패로 처리하기"

#: src/error/iter_result.md:54
msgid ""
"`Result` implements `FromIterator` so that a vector of results "
"(`Vec<Result<T, E>>`) can be turned into a result with a vector "
"(`Result<Vec<T>, E>`). Once an `Result::Err` is found, the iteration will "
"terminate."
msgstr ""
"`Result`는 `FromIterator`를 구현하므로 결과들의 벡터(`Vec<Result<T, E>>`)를 "
"벡터를 가진 결과(`Result<Vec<T>, E>`)로 바꿀 수 있습니다. `Result::Err`이 발"
"견되면 즉시 순회가 종료됩니다."

#: src/error/iter_result.md:69
msgid "This same technique can be used with `Option`."
msgstr "동일한 기술을 `Option`에 대해서도 사용할 수 있습니다."

#: src/error/iter_result.md:71
msgid "Collect all valid values and failures with `partition()`"
msgstr "`partition()`을 사용하여 모든 유효한 값과 실패를 수집하기"

#: src/error/iter_result.md:85
msgid ""
"When you look at the results, you'll note that everything is still wrapped "
"in `Result`.  A little more boilerplate is needed for this."
msgstr ""
"결과를 보면 모든 것이 여전히 `Result`로 감싸져 있음을 알 수 있습니다. 이를 위"
"해서는 상용구 코드가 조금 더 필요합니다."

#: src/std.md:3
msgid ""
"The `std` library provides many custom types which expands drastically on "
"the `primitives`. Some of these include:"
msgstr ""
"표준 라이브러리는 `기본 자료형`을 대폭 확장한 많은 사용자 정의 타입을 제공합"
"니다. 이들 중 일부는 다음과 같습니다:"

#: src/std.md:6
msgid "growable `String`s like: `\"hello world\"`"
msgstr "가변 크기 `String`: 예: `\"hello world\"`"

#: src/std.md:7
msgid "growable vectors: `[1, 2, 3]`"
msgstr "가변 크기 벡터: `[1, 2, 3]`"

#: src/std.md:8
msgid "optional types: `Option<i32>`"
msgstr "선택적 타입: `Option<i32>`"

#: src/std.md:9
msgid "error handling types: `Result<i32, i32>`"
msgstr "에러 핸들링 타입: `Result<i32, i32>`"

#: src/std.md:10
msgid "heap allocated pointers: `Box<i32>`"
msgstr "힙 할당 포인터: `Box<i32>`"

#: src/std.md:14 src/std_misc.md:14
msgid ""
"[primitives](primitives.md) and [the std library](https://doc.rust-lang.org/"
"std/)"
msgstr ""
"[기본 자료형](primitives.md)과 [표준 라이브러리](https://doc.rust-lang.org/"
"std/)"

#: src/std/box.md:3
msgid ""
"All values in Rust are stack allocated by default. Values can be _boxed_ "
"(allocated on the heap) by creating a `Box<T>`. A box is a smart pointer to "
"a heap allocated value of type `T`. When a box goes out of scope, its "
"destructor is called, the inner object is destroyed, and the memory on the "
"heap is freed."
msgstr ""
"Rust의 모든 값은 기본적으로 스택에 할당됩니다. `Box<T>`를 생성함으로써 값을 *"
"박싱*(힙에 할당)할 수 있습니다. 박스는 힙에 할당된 `T` 타입 값을 가리키는 스"
"마트 포인터입니다. 박스가 스코프를 벗어나면 데스트럭터가 호출되어 내부 객체"
"가 파괴되고 힙 메모리가 해제됩니다."

#: src/std/box.md:8
msgid ""
"Boxed values can be dereferenced using the `*` operator; this removes one "
"layer of indirection."
msgstr ""
"박싱된 값은 `*` 연산자를 사용하여 역참조할 수 있습니다. 이는 한 단계의 간접 "
"참조를 제거합니다."

#: src/std/box.md:20
msgid ""
"// A Rectangle can be specified by where its top left and bottom right\n"
"// corners are in space\n"
msgstr ""
"// 사각형은 공간상에서의 왼쪽 상단과 오른쪽 하단\n"
"// 꼭짓점 위치로 지정될 수 있습니다\n"

#: src/std/box.md:34
msgid "// Allocate this point on the heap, and return a pointer to it\n"
msgstr "// 이 점을 힙에 할당하고, 그에 대한 포인터를 반환합니다\n"

#: src/std/box.md:39
msgid ""
"// (all the type annotations are superfluous)\n"
"    // Stack allocated variables\n"
msgstr ""
"// (모든 타입 어노테이션은 불필요합니다)\n"
"    // 스택에 할당된 변수들\n"

#: src/std/box.md:47
msgid "// Heap allocated rectangle\n"
msgstr "// 힙에 할당된 사각형\n"

#: src/std/box.md:53
msgid "// The output of functions can be boxed\n"
msgstr "// 함수의 출력은 박싱될 수 있습니다\n"

#: src/std/box.md:56
msgid "// Double indirection\n"
msgstr "// 이중 간접 참조\n"

#: src/std/box.md:59
msgid "\"Point occupies {} bytes on the stack\""
msgstr "\"Point는 스택에서 {} 바이트를 차지합니다\""

#: src/std/box.md:61
msgid "\"Rectangle occupies {} bytes on the stack\""
msgstr "\"Rectangle은 스택에서 {} 바이트를 차지합니다\""

#: src/std/box.md:64
msgid "// box size == pointer size\n"
msgstr "// 박스 크기 == 포인터 크기\n"

#: src/std/box.md:65
msgid "\"Boxed point occupies {} bytes on the stack\""
msgstr "\"박싱된 point는 스택에서 {} 바이트를 차지합니다\""

#: src/std/box.md:67
msgid "\"Boxed rectangle occupies {} bytes on the stack\""
msgstr "\"박싱된 rectangle은 스택에서 {} 바이트를 차지합니다\""

#: src/std/box.md:69
msgid "\"Boxed box occupies {} bytes on the stack\""
msgstr "\"박싱된 박스는 스택에서 {} 바이트를 차지합니다\""

#: src/std/box.md:72
msgid "// Copy the data contained in `boxed_point` into `unboxed_point`\n"
msgstr "// `boxed_point`에 담긴 데이터를 `unboxed_point`로 복사합니다\n"

#: src/std/box.md:74
msgid "\"Unboxed point occupies {} bytes on the stack\""
msgstr "\"박싱 해제된 point는 스택에서 {} 바이트를 차지합니다\""

#: src/std/vec.md:3
msgid ""
"Vectors are re-sizable arrays. Like slices, their size is not known at "
"compile time, but they can grow or shrink at any time. A vector is "
"represented using 3 parameters:"
msgstr ""
"벡터는 크기 조절이 가능한 배열입니다. 슬라이스와 마찬가지로 크기를 컴파일 타"
"임에 알 수 없지만, 언제든지 늘리거나 줄일 수 있습니다. 벡터는 3개의 파라미터"
"로 표현됩니다:"

#: src/std/vec.md:7
msgid "pointer to the data"
msgstr "데이터에 대한 포인터"

#: src/std/vec.md:8
msgid "length"
msgstr "길이"

#: src/std/vec.md:9
msgid "capacity"
msgstr "용량"

#: src/std/vec.md:11
msgid ""
"The capacity indicates how much memory is reserved for the vector. The "
"vector can grow as long as the length is smaller than the capacity. When "
"this threshold needs to be surpassed, the vector is reallocated with a "
"larger capacity."
msgstr ""
"용량은 벡터를 위해 예약된 메모리 양을 나타냅니다. 벡터는 길이가 용량보다 작"
"은 동안에는 계속 늘어날 수 있습니다. 이 임계값을 넘어야 할 때, 벡터는 더 큰 "
"용량으로 재할당됩니다."

#: src/std/vec.md:17
msgid "// Iterators can be collected into vectors\n"
msgstr "// 이터레이터는 벡터로 수집(collect)될 수 있습니다\n"

#: src/std/vec.md:19
msgid "\"Collected (0..10) into: {:?}\""
msgstr "\"(0..10)을 다음으로 수집함: {:?}\""

#: src/std/vec.md:21
msgid "// The `vec!` macro can be used to initialize a vector\n"
msgstr "// `vec!` 매크로는 벡터를 초기화하는 데 사용될 수 있습니다\n"

#: src/std/vec.md:23
msgid "\"Initial vector: {:?}\""
msgstr "\"초기 벡터: {:?}\""

#: src/std/vec.md:25
msgid "// Insert new element at the end of the vector\n"
msgstr "// 벡터 끝에 새로운 요소를 삽입합니다\n"

#: src/std/vec.md:26
msgid "\"Push 4 into the vector\""
msgstr "\"벡터에 4를 푸시합니다\""

#: src/std/vec.md:28
msgid "\"Vector: {:?}\""
msgstr "\"벡터: {:?}\""

#: src/std/vec.md:30
msgid "// Error! Immutable vectors can't grow\n"
msgstr "// 에러! 불변 벡터는 늘어날 수 없습니다\n"

#: src/std/vec.md:34
msgid ""
"// The `len` method yields the number of elements currently stored in a "
"vector\n"
msgstr "// `len` 메서드는 현재 벡터에 저장된 요소의 개수를 반환합니다\n"

#: src/std/vec.md:35
msgid "\"Vector length: {}\""
msgstr "\"벡터 길이: {}\""

#: src/std/vec.md:37
msgid "// Indexing is done using the square brackets (indexing starts at 0)\n"
msgstr "// 인덱싱은 대괄호를 사용하여 수행됩니다 (인덱싱은 0부터 시작합니다)\n"

#: src/std/vec.md:38
msgid "\"Second element: {}\""
msgstr "\"두 번째 요소: {}\""

#: src/std/vec.md:40
msgid "// `pop` removes the last element from the vector and returns it\n"
msgstr "// `pop`은 벡터에서 마지막 요소를 제거하고 이를 반환합니다\n"

#: src/std/vec.md:41
msgid "\"Pop last element: {:?}\""
msgstr "\"마지막 요소 팝: {:?}\""

#: src/std/vec.md:43
msgid "// Out of bounds indexing yields a panic\n"
msgstr "// 범위를 벗어난 인덱싱은 패닉을 일으킵니다\n"

#: src/std/vec.md:44
msgid "\"Fourth element: {}\""
msgstr "\"네 번째 요소: {}\""

#: src/std/vec.md:47
msgid "// `Vector`s can be easily iterated over\n"
msgstr "// 벡터는 쉽게 순회(iterate)될 수 있습니다\n"

#: src/std/vec.md:48
msgid "\"Contents of xs:\""
msgstr "\"xs의 내용:\""

#: src/std/vec.md:53
msgid ""
"// A `Vector` can also be iterated over while the iteration\n"
"    // count is enumerated in a separate variable (`i`)\n"
msgstr ""
"// 벡터는 반복 횟수가 별도의 변수(`i`)에 열거되면서 순회될 수도 있습니다\n"

#: src/std/vec.md:56
msgid "\"In position {} we have value {}\""
msgstr "\"{} 위치에 {} 값이 있습니다\""

#: src/std/vec.md:59
msgid ""
"// Thanks to `iter_mut`, mutable `Vector`s can also be iterated\n"
"    // over in a way that allows modifying each value\n"
msgstr ""
"// `iter_mut` 덕분에 가변 벡터도 각 값을 수정할 수 있는 방식으로\n"
"    // 순회될 수 있습니다\n"

#: src/std/vec.md:64
msgid "\"Updated vector: {:?}\""
msgstr "\"업데이트된 벡터: {:?}\""

#: src/std/vec.md:68
msgid ""
"More `Vec` methods can be found under the [std::vec](https://doc.rust-"
"lang.org/std/vec/) module"
msgstr ""
"더 많은 `Vec` 메서드는 [std::vec](https://doc.rust-lang.org/std/vec/) 모듈에"
"서 찾을 수 있습니다"

#: src/std/str.md:3
msgid "The two most used string types in Rust are `String` and `&str`."
msgstr ""
"Rust에서 가장 많이 사용되는 두 가지 문자열 타입은 `String`과 `&str`입니다."

#: src/std/str.md:5
msgid ""
"A `String` is stored as a vector of bytes (`Vec<u8>`), but guaranteed to "
"always be a valid UTF-8 sequence. `String` is heap allocated, growable and "
"not null terminated."
msgstr ""
"`String`은 바이트 벡터(`Vec<u8>`)로 저장되지만, 항상 유효한 UTF-8 시퀀스임이 "
"보장됩니다. `String`은 힙에 할당되며, 크기 조절이 가능하고 널 종료(null "
"terminated)되지 않습니다."

#: src/std/str.md:9
msgid ""
"`&str` is a slice (`&[u8]`) that always points to a valid UTF-8 sequence, "
"and can be used to view into a `String`, just like `&[T]` is a view into "
"`Vec<T>`."
msgstr ""
"`&str`은 항상 유효한 UTF-8 시퀀스를 가리키는 슬라이스(`&[u8]`)이며, `&[T]`가 "
"`Vec<T>`를 들여다보는 창(view)인 것과 마찬가지로 `String`을 들여다보는 데 사"
"용될 수 있습니다."

#: src/std/str.md:14
msgid ""
"// (all the type annotations are superfluous)\n"
"    // A reference to a string allocated in read only memory\n"
msgstr ""
"// (모든 타입 어노테이션은 불필요합니다)\n"
"    // 읽기 전용 메모리에 할당된 문자열에 대한 참조\n"

#: src/std/str.md:16
msgid "\"the quick brown fox jumps over the lazy dog\""
msgstr "\"the quick brown fox jumps over the lazy dog\""

#: src/std/str.md:17
msgid "\"Pangram: {}\""
msgstr "\"팬그램(Pangram): {}\""

#: src/std/str.md:19
msgid "// Iterate over words in reverse, no new string is allocated\n"
msgstr "// 단어들을 역순으로 순회합니다. 새로운 문자열은 할당되지 않습니다\n"

#: src/std/str.md:20
msgid "\"Words in reverse\""
msgstr "\"역순 단어들\""

#: src/std/str.md:25
msgid "// Copy chars into a vector, sort and remove duplicates\n"
msgstr "// 문자들을 벡터로 복사하고, 정렬한 뒤 중복을 제거합니다\n"

#: src/std/str.md:30
msgid "// Create an empty and growable `String`\n"
msgstr "// 비어 있고 크기 조절 가능한 `String`을 생성합니다\n"

#: src/std/str.md:33
msgid "// Insert a char at the end of string\n"
msgstr "// 문자열 끝에 문자를 삽입합니다\n"

#: src/std/str.md:35
msgid "// Insert a string at the end of string\n"
msgstr "// 문자열 끝에 문자열을 삽입합니다\n"

#: src/std/str.md:39
msgid ""
"// The trimmed string is a slice to the original string, hence no new\n"
"    // allocation is performed\n"
msgstr ""
"// 트림된 문자열은 원본 문자열에 대한 슬라이스이므로,\n"
"// 새로운 할당이 수행되지 않습니다\n"

#: src/std/str.md:43
msgid "\"Used characters: {}\""
msgstr "\"사용된 문자들: {}\""

#: src/std/str.md:45
msgid "// Heap allocate a string\n"
msgstr "// 문자열을 힙에 할당합니다\n"

#: src/std/str.md:46
msgid "\"I like dogs\""
msgstr "\"I like dogs\""

#: src/std/str.md:47
msgid "// Allocate new memory and store the modified string there\n"
msgstr "// 새로운 메모리를 할당하고 수정된 문자열을 그곳에 저장합니다\n"

#: src/std/str.md:48
msgid "\"dog\""
msgstr "\"dog\""

#: src/std/str.md:48
msgid "\"cat\""
msgstr "\"cat\""

#: src/std/str.md:50
msgid "\"Alice says: {}\""
msgstr "\"앨리스가 말합니다: {}\""

#: src/std/str.md:51
msgid "\"Bob says: {}\""
msgstr "\"밥이 말합니다: {}\""

#: src/std/str.md:55
msgid ""
"More `str`/`String` methods can be found under the [std::str](https://"
"doc.rust-lang.org/std/str/) and [std::string](https://doc.rust-lang.org/std/"
"string/) modules"
msgstr ""
"더 많은 `str`/`String` 메서드는 [std::str](https://doc.rust-lang.org/std/"
"str/) 및 [std::string](https://doc.rust-lang.org/std/string/) 모듈에서 찾을 "
"수 있습니다"

#: src/std/str.md:60
msgid "Literals and escapes"
msgstr "리터럴과 이스케이프"

#: src/std/str.md:62
msgid ""
"There are multiple ways to write string literals with special characters in "
"them. All result in a similar `&str` so it's best to use the form that is "
"the most convenient to write. Similarly there are multiple ways to write "
"byte string literals, which all result in `&[u8; N]`."
msgstr ""
"특수 문자가 포함된 문자열 리터럴을 작성하는 방법은 여러 가지가 있습니다. 모"
"두 비슷한 `&str`을 결과로 내므로 가장 작성하기 편리한 형식을 사용하는 것이 좋"
"습니다. 마찬가지로 바이트 문자열 리터럴을 작성하는 방법도 여러 가지가 있으"
"며, 모두 `&[u8; N]` 결과를 냅니다."

#: src/std/str.md:67
msgid ""
"Generally special characters are escaped with a backslash character: `\\`. "
"This way you can add any character to your string, even unprintable ones and "
"ones that you don't know how to type. If you want a literal backslash, "
"escape it with another one: `\\\\`"
msgstr ""
"일반적으로 특수 문자는 백슬래시 문자 `\\`로 이스케이프됩니다. 이 방법을 통해 "
"출력 불가능한 문자나 입력 방법을 모르는 문자 등 어떤 문자든 문자열에 추가할 "
"수 있습니다. 백슬래시 자체를 리터럴로 원한다면 백슬래시 하나를 더 붙여 `\\\\`"
"와 같이 이스케이프하세요."

#: src/std/str.md:72
msgid ""
"String or character literal delimiters occurring within a literal must be "
"escaped: `\"\\\"\"`, `'\\''`."
msgstr ""
"리터럴 내에 나타나는 문자열 또는 문자 리터럴 구분자는 반드시 이스케이프해야 "
"합니다: `\"\\\"\"`, `'\\''`."

#: src/std/str.md:76
msgid "// You can use escapes to write bytes by their hexadecimal values...\n"
msgstr ""
"// 16진수 값을 사용하여 바이트를 작성하기 위해 이스케이프를 사용할 수 있습니"
"다...\n"

#: src/std/str.md:77
msgid "\"I'm writing \\x52\\x75\\x73\\x74!\""
msgstr "\"I'm writing \\x52\\x75\\x73\\x74!\""

#: src/std/str.md:78
msgid "\"What are you doing\\x3F (\\\\x3F means ?) {}\""
msgstr "\"What are you doing\\x3F (\\\\x3F는 ?를 의미합니다) {}\""

#: src/std/str.md:80
msgid "// ...or Unicode code points.\n"
msgstr "// ...또는 유니코드 코드 포인트.\n"

#: src/std/str.md:81
msgid "\"\\u{211D}\""
msgstr "\"\\u{211D}\""

#: src/std/str.md:82
msgid "\"\\\"DOUBLE-STRUCK CAPITAL R\\\"\""
msgstr "\"\\\"DOUBLE-STRUCK CAPITAL R\\\"\""

#: src/std/str.md:84
msgid "\"Unicode character {} (U+211D) is called {}\""
msgstr "\"유니코드 문자 {} (U+211D)는 {}라고 불립니다\""

#: src/std/str.md:88
msgid ""
"\"String literals\n"
"                        can span multiple lines.\n"
"                        The linebreak and indentation here ->\\\n"
"                        <- can be escaped too!\""
msgstr ""
"\"문자열 리터럴은\n"
"                        여러 줄에 걸쳐 있을 수 있습니다.\n"
"                        여기서의 줄바꿈과 들여쓰기 ->\\\n"
"                        <- 역시 이스케이프될 수 있습니다!\""

#: src/std/str.md:96
msgid ""
"Sometimes there are just too many characters that need to be escaped or it's "
"just much more convenient to write a string out as-is. This is where raw "
"string literals come into play."
msgstr ""
"때때로 이스케이프해야 할 문자가 너무 많거나 문자열을 있는 그대로 작성하는 것"
"이 훨씬 더 편리할 때가 있습니다. 이때 로우(raw) 문자열 리터럴이 사용됩니다."

#: src/std/str.md:101
msgid "r\"Escapes don't work here: \\x3F \\u{211D}\""
msgstr "r\"이스케이프가 여기선 작동하지 않습니다: \\x3F \\u{211D}\""

#: src/std/str.md:104
msgid "// If you need quotes in a raw string, add a pair of #s\n"
msgstr "// 로우 문자열에서 따옴표가 필요하다면, # 쌍을 추가하세요\n"

#: src/std/str.md:105
msgid "r#\"And then I said: \"There is no escape!\"\"#"
msgstr "r#\"And then I said: \"There is no escape!\"\"#"

#: src/std/str.md:108
msgid ""
"// If you need \"# in your string, just use more #s in the delimiter.\n"
"    // You can use up to 255 #s.\n"
msgstr ""
"// 문자열 내에 \"#가 필요하다면, 구분자에 더 많은 #를 사용하세요.\n"
"    // 최대 255개의 #를 사용할 수 있습니다.\n"

#: src/std/str.md:110
msgid "r###\"A string with \"# in it. And even \"##!\"###"
msgstr "r###\"A string with \"# in it. And even \"##!\"###"

#: src/std/str.md:115
msgid ""
"Want a string that's not UTF-8? (Remember, `str` and `String` must be valid "
"UTF-8). Or maybe you want an array of bytes that's mostly text? Byte strings "
"to the rescue!"
msgstr ""
"UTF-8이 아닌 문자열을 원하시나요? (`str`과 `String`은 반드시 유효한 UTF-8이어"
"야 함을 기억하세요). 아니면 대부분이 텍스트인 바이트 배열을 원하시나요? 바이"
"트 문자열이 해결해 드립니다!"

#: src/std/str.md:122
msgid "// Note that this is not actually a `&str`\n"
msgstr "// 이는 실제로 `&str`이 아님에 유의하세요\n"

#: src/std/str.md:123
msgid "b\"this is a byte string\""
msgstr "b\"this is a byte string\""

#: src/std/str.md:125
msgid ""
"// Byte arrays don't have the `Display` trait, so printing them is a bit "
"limited\n"
msgstr ""
"// 바이트 배열은 `Display` 트레이트를 가지고 있지 않으므로, 출력에 다소 제한"
"이 있습니다\n"

#: src/std/str.md:126
msgid "\"A byte string: {:?}\""
msgstr "\"바이트 문자열: {:?}\""

#: src/std/str.md:128
msgid "// Byte strings can have byte escapes...\n"
msgstr "// 바이트 문자열은 바이트 이스케이프를 가질 수 있습니다...\n"

#: src/std/str.md:129
msgid "b\"\\x52\\x75\\x73\\x74 as bytes\""
msgstr "b\"\\x52\\x75\\x73\\x74 as bytes\""

#: src/std/str.md:130
msgid ""
"// ...but no unicode escapes\n"
"    // let escaped = b\"\\u{211D} is not allowed\";\n"
msgstr ""
"// ...하지만 유니코드 이스케이프는 허용되지 않습니다\n"
"    // let escaped = b\"\\u{211D} is not allowed\";\n"

#: src/std/str.md:132
msgid "\"Some escaped bytes: {:?}\""
msgstr "\"일부 이스케이프된 바이트: {:?}\""

#: src/std/str.md:135
msgid "// Raw byte strings work just like raw strings\n"
msgstr "// 로우 바이트 문자열은 로우 문자열과 똑같이 작동합니다\n"

#: src/std/str.md:136
msgid "br\"\\u{211D} is not escaped here\""
msgstr "br\"\\u{211D} is not escaped here\""

#: src/std/str.md:139
msgid "// Converting a byte array to `str` can fail\n"
msgstr "// 바이트 배열을 `str`로 변환하는 것은 실패할 수 있습니다\n"

#: src/std/str.md:141
msgid "\"And the same as text: '{}'\""
msgstr "\"그리고 텍스트로 변환하면: '{}'\""

#: src/std/str.md:144
msgid ""
"br#\"You can also use \"fancier\" formatting, \\\n"
"                    like with normal raw strings\"#"
msgstr ""
"br#\"일반 로우 문자열처럼, \\\n"
"                    더 \"화려한\" 포맷팅을 사용할 수도 있습니다\"#"

#: src/std/str.md:147
msgid "// Byte strings don't have to be UTF-8\n"
msgstr "// 바이트 문자열은 UTF-8일 필요가 없습니다\n"

#: src/std/str.md:148
msgid "b\"\\x82\\xe6\\x82\\xa8\\x82\\xb1\\x82\\xbb\""
msgstr "b\"\\x82\\xe6\\x82\\xa8\\x82\\xb1\\x82\\xbb\""

#: src/std/str.md:148
msgid "// \"ようこそ\" in SHIFT-JIS\n"
msgstr "// SHIFT-JIS 인코딩의 \"ようこそ\"(환영합니다)\n"

#: src/std/str.md:150
msgid "// But then they can't always be converted to `str`\n"
msgstr "// 그런 경우에는 항상 `str`로 변환될 수는 없습니다\n"

#: src/std/str.md:152
msgid "\"Conversion successful: '{}'\""
msgstr "\"변환 성공: '{}'\""

#: src/std/str.md:153
msgid "\"Conversion failed: {:?}\""
msgstr "\"변환 실패: {:?}\""

#: src/std/str.md:158
msgid ""
"For conversions between character encodings check out the [encoding](https://"
"crates.io/crates/encoding) crate."
msgstr ""
"문자 인코딩 간의 변환에 대해서는 [encoding](https://crates.io/crates/"
"encoding) 크레이트를 확인해 보세요."

#: src/std/str.md:160
msgid ""
"A more detailed listing of the ways to write string literals and escape "
"characters is given in the ['Tokens' chapter](https://doc.rust-lang.org/"
"reference/tokens.html) of the Rust Reference."
msgstr ""
"문자열 리터럴을 작성하고 문자를 이스케이프하는 방법에 대한 더 자세한 목록은 "
"Rust 레퍼런스의 ['Tokens' 장](https://doc.rust-lang.org/reference/"
"tokens.html)에 나와 있습니다."

#: src/std/option.md:3
msgid ""
"Sometimes it's desirable to catch the failure of some parts of a program "
"instead of calling `panic!`; this can be accomplished using the `Option` "
"enum."
msgstr ""
"때로는 프로그램의 일부에서 발생하는 실패를 `panic!`을 호출하는 대신 포착하고 "
"싶을 때가 있습니다. 이는 `Option` 열거형을 사용하여 수행할 수 있습니다."

#: src/std/option.md:6
msgid "The `Option<T>` enum has two variants:"
msgstr "`Option<T>` 열거형은 두 가지 변체를 가집니다:"

#: src/std/option.md:8
msgid "`None`, to indicate failure or lack of value, and"
msgstr "`None`: 실패나 값의 부재를 나타냄"

#: src/std/option.md:9
msgid "`Some(value)`, a tuple struct that wraps a `value` with type `T`."
msgstr "`Some(value)`: `T` 타입의 `value`를 감싸는 튜플 구조체"

#: src/std/option.md:12
msgid "// An integer division that doesn't `panic!`\n"
msgstr "// `panic!`을 일으키지 않는 정수 나눗셈\n"

#: src/std/option.md:15
msgid "// Failure is represented as the `None` variant\n"
msgstr "// 실패는 `None` 변체로 표현됩니다\n"

#: src/std/option.md:18
msgid "// Result is wrapped in a `Some` variant\n"
msgstr "// 결과는 `Some` 변체로 감싸집니다\n"

#: src/std/option.md:22
msgid "// This function handles a division that may not succeed\n"
msgstr "// 이 함수는 성공하지 않을 수 있는 나눗셈을 처리합니다\n"

#: src/std/option.md:25
msgid "// `Option` values can be pattern matched, just like other enums\n"
msgstr "// `Option` 값은 다른 열거형과 마찬가지로 패턴 매칭될 수 있습니다\n"

#: src/std/option.md:27
msgid "\"{} / {} failed!\""
msgstr "\"{} / {} 실패!\""

#: src/std/option.md:29
msgid "\"{} / {} = {}\""
msgstr "\"{} / {} = {}\""

#: src/std/option.md:38
msgid "// Binding `None` to a variable needs to be type annotated\n"
msgstr "// `None`을 변수에 바인딩할 때는 타입 어노테이션이 필요합니다\n"

#: src/std/option.md:44
msgid "// Unwrapping a `Some` variant will extract the value wrapped.\n"
msgstr "// `Some` 변체의 래핑을 해제(unwrap)하면 감싸진 값을 추출합니다.\n"

#: src/std/option.md:45 src/std/option.md:48
msgid "\"{:?} unwraps to {:?}\""
msgstr "\"{:?}의 래핑을 해제하면 {:?}가 됩니다\""

#: src/std/option.md:47
msgid "// Unwrapping a `None` variant will `panic!`\n"
msgstr "// `None` 변체의 래핑을 해제하면 `panic!`이 발생합니다\n"

#: src/std/result.md:3
msgid ""
"We've seen that the `Option` enum can be used as a return value from "
"functions that may fail, where `None` can be returned to indicate failure. "
"However, sometimes it is important to express _why_ an operation failed. To "
"do this we have the `Result` enum."
msgstr ""
"우리는 실패할 수 있는 함수로부터 `None`을 반환하여 실패를 나타낼 때 `Option` "
"열거형이 사용될 수 있음을 보았습니다. 하지만 때로는 작업이 *왜* 실패했는지 표"
"현하는 것이 중요합니다. 이를 위해 우리는 `Result` 열거형을 가지고 있습니다."

#: src/std/result.md:8
msgid "The `Result<T, E>` enum has two variants:"
msgstr "`Result<T, E>` 열거형은 두 가지 변체를 가집니다:"

#: src/std/result.md:10
msgid ""
"`Ok(value)` which indicates that the operation succeeded, and wraps the "
"`value` returned by the operation. (`value` has type `T`)"
msgstr ""
"`Ok(value)`: 작업이 성공했음을 나타내며, 작업에 의해 반환된 `value`를 감쌉니"
"다. (`value`는 `T` 타입을 가집니다)"

#: src/std/result.md:12
msgid ""
"`Err(why)`, which indicates that the operation failed, and wraps `why`, "
"which (hopefully) explains the cause of the failure. (`why` has type `E`)"
msgstr ""
"`Err(why)`: 작업이 실패했음을 나타내며, 실패의 원인을 설명하는 (바라건대) "
"`why`를 감쌉니다. (`why`는 `E` 타입을 가집니다)"

#: src/std/result.md:17
msgid "// Mathematical \"errors\" we want to catch\n"
msgstr "// 우리가 포착하고 싶은 수학적 \"에러\"들\n"

#: src/std/result.md:29
msgid ""
"// This operation would `fail`, instead let's return the reason of\n"
"            // the failure wrapped in `Err`\n"
msgstr ""
"// 이 작업은 실패하게 되므로, 대신 실패의 원인을\n"
"// `Err`로 감싸서 반환합시다\n"

#: src/std/result.md:33
msgid "// This operation is valid, return the result wrapped in `Ok`\n"
msgstr "// 이 작업은 유효하므로, 결과를 `Ok`로 감싸서 반환합니다\n"

#: src/std/result.md:54
msgid "// `op(x, y)` === `sqrt(ln(x / y))`\n"
msgstr "// `op(x, y)` === `sqrt(ln(x / y))`\n"

#: src/std/result.md:57
msgid "// This is a three level match pyramid!\n"
msgstr "// 이것은 3단계 `match` 피라미드입니다!\n"

#: src/std/result.md:71
msgid "// Will this fail?\n"
msgstr "// 이것은 실패할까요?\n"

#: src/std/result/question_mark.md:3
msgid ""
"Chaining results using match can get pretty untidy; luckily, the `?` "
"operator can be used to make things pretty again. `?` is used at the end of "
"an expression returning a `Result`, and is equivalent to a match expression, "
"where the `Err(err)` branch expands to an early `return "
"Err(From::from(err))`, and the `Ok(ok)` branch expands to an `ok` expression."
msgstr ""
"`match`를 사용하여 결과를 체인으로 연결하는 것은 꽤 지저분해질 수 있습니다. "
"다행히 `?` 연산자를 사용하여 다시 깔끔하게 만들 수 있습니다. `?`는 `Result`"
"를 반환하는 표현식의 끝에 사용되며, `match` 표현식과 동일하게 작동합니다. 여"
"기서 `Err(err)` 가지는 조기 리턴인 `return Err(From::from(err))`로 확장되고, "
"`Ok(ok)` 가지는 `ok` 표현식으로 확장됩니다."

#: src/std/result/question_mark.md:44
msgid "// Intermediate function\n"
msgstr "// 중간 함수\n"

#: src/std/result/question_mark.md:46
msgid "// if `div` \"fails\", then `DivisionByZero` will be `return`ed\n"
msgstr "// 만약 `div`가 \"실패\"하면, `DivisionByZero`가 반환됩니다\n"

#: src/std/result/question_mark.md:49
msgid "// if `ln` \"fails\", then `NonPositiveLogarithm` will be `return`ed\n"
msgstr "// 만약 `ln`가 \"실패\"하면, `NonPositiveLogarithm`이 반환됩니다\n"

#: src/std/result/question_mark.md:59
msgid "\"logarithm of non-positive number\""
msgstr "\"0 이하의 수에 대한 로그\""

#: src/std/result/question_mark.md:61 src/std/panic.md:15
msgid "\"division by zero\""
msgstr "\"0으로 나누기\""

#: src/std/result/question_mark.md:63
msgid "\"square root of negative number\""
msgstr "\"음수의 제곱근\""

#: src/std/result/question_mark.md:75
msgid ""
"Be sure to check the [documentation](https://doc.rust-lang.org/std/result/"
"index.html), as there are many methods to map/compose `Result`."
msgstr ""
"`Result`를 매핑하거나 구성(compose)하는 많은 메서드들이 있으니, 반드시 [문서]"
"(https://doc.rust-lang.org/std/result/index.html)를 확인해 보세요."

#: src/std/panic.md:3
msgid ""
"The `panic!` macro can be used to generate a panic and start unwinding its "
"stack. While unwinding, the runtime will take care of freeing all the "
"resources _owned_ by the thread by calling the destructor of all its objects."
msgstr ""
"`panic!` 매크로는 패닉을 생성하고 스택 되감기(unwinding)를 시작하는 데 사용"
"될 수 있습니다. 되감기를 하는 동안, 런타임은 모든 객체의 데스트럭터를 호출하"
"여 해당 스레드가 소유한 모든 리소스를 해제합니다."

#: src/std/panic.md:7
msgid ""
"Since we are dealing with programs with only one thread, `panic!` will cause "
"the program to report the panic message and exit."
msgstr ""
"우리는 단일 스레드 프로그램만 다루고 있으므로, `panic!`은 프로그램이 패닉 메"
"시지를 보고하고 종료하게 만듭니다."

#: src/std/panic.md:11
msgid "// Re-implementation of integer division (/)\n"
msgstr "// 정수 나눗셈(/)의 재구현\n"

#: src/std/panic.md:14
msgid "// Division by zero triggers a panic\n"
msgstr "// 0으로 나누기는 패닉을 트리거합니다\n"

#: src/std/panic.md:20
msgid "// The `main` task\n"
msgstr "// 메인 태스크\n"

#: src/std/panic.md:23
msgid "// Heap allocated integer\n"
msgstr "// 힙 할당 정수\n"

#: src/std/panic.md:26
msgid "// This operation will trigger a task failure\n"
msgstr "// 이 작업은 태스크 실패를 트리거합니다\n"

#: src/std/panic.md:29
msgid "\"This point won't be reached!\""
msgstr "\"이 지점에는 도달하지 않습니다!\""

#: src/std/panic.md:31
msgid "// `_x` should get destroyed at this point\n"
msgstr "// 이 지점에서 `_x`가 파괴되어야 합니다\n"

#: src/std/panic.md:35
msgid "Let's check that `panic!` doesn't leak memory."
msgstr "`panic!`이 메모리를 누수하지 않는지 확인해 봅시다."

#: src/std/hash.md:3
msgid ""
"Where vectors store values by an integer index, `HashMap`s store values by "
"key. `HashMap` keys can be booleans, integers, strings, or any other type "
"that implements the `Eq` and `Hash` traits. More on this in the next section."
msgstr ""
"벡터가 정수 인덱스로 값을 저장하는 반면, `HashMap`은 키(key)로 값을 저장합니"
"다. `HashMap`의 키는 불리언, 정수, 문자열 또는 `Eq`와 `Hash` 트레이트를 구현"
"하는 임의의 다른 타입이 될 수 있습니다. 이에 대해서는 다음 섹션에서 자세히 다"
"룹니다."

#: src/std/hash.md:8
msgid ""
"Like vectors, `HashMap`s are growable, but HashMaps can also shrink "
"themselves when they have excess space. You can create a HashMap with a "
"certain starting capacity using `HashMap::with_capacity(uint)`, or use "
"`HashMap::new()` to get a HashMap with a default initial capacity "
"(recommended)."
msgstr ""
"벡터와 마찬가지로 `HashMap`은 늘어날 수 있지만, 공간이 남을 때는 스스로 줄어"
"들 수도 있습니다. `HashMap::with_capacity(uint)`를 사용하여 특정 시작 용량으"
"로 HashMap을 생성하거나, `HashMap::new()`를 사용하여 기본 초기 용량을 가진 "
"HashMap을 얻을 수 있습니다(권장됨)."

#: src/std/hash.md:19 src/std/hash.md:30
msgid "\"798-1364\""
msgstr "\"798-1364\""

#: src/std/hash.md:19
msgid ""
"\"We're sorry, the call cannot be completed as dialed.\n"
"            Please hang up and try again.\""
msgstr ""
"\"죄송합니다, 전화 연결을 할 수 없습니다.\n"
"            전화를 끊고 다시 시도해 주세요.\""

#: src/std/hash.md:21 src/std/hash.md:31
msgid "\"645-7689\""
msgstr "\"645-7689\""

#: src/std/hash.md:21
msgid ""
"\"Hello, this is Mr. Awesome's Pizza. My name is Fred.\n"
"            What can I get for you today?\""
msgstr ""
"\"안녕하세요, 어썸 피자입니다. 저는 프레드라고 합니다.\n"
"            오늘 무엇을 도와드릴까요?\""

#: src/std/hash.md:23
msgid "\"Hi! Who is this again?\""
msgstr "\"안녕! 누구시더라?\""

#: src/std/hash.md:30 src/std/hash.md:36 src/std/hash.md:43
msgid "\"Daniel\""
msgstr "\"다니엘\""

#: src/std/hash.md:31 src/std/hash.md:45 src/std/hash.md:50
msgid "\"Ashley\""
msgstr "\"애슐리\""

#: src/std/hash.md:32
msgid "\"Katie\""
msgstr "\"케이티\""

#: src/std/hash.md:32
msgid "\"435-8291\""
msgstr "\"435-8291\""

#: src/std/hash.md:33
msgid "\"Robert\""
msgstr "\"로버트\""

#: src/std/hash.md:33
msgid "\"956-1745\""
msgstr "\"956-1745\""

#: src/std/hash.md:35
msgid "// Takes a reference and returns Option<&V>\n"
msgstr "// 참조를 인자로 받아 `Option<&V>`를 반환합니다\n"

#: src/std/hash.md:37
msgid "\"Calling Daniel: {}\""
msgstr "\"다니엘에게 전화 거는 중: {}\""

#: src/std/hash.md:38
msgid "\"Don't have Daniel's number.\""
msgstr "\"다니엘의 번호가 없습니다.\""

#: src/std/hash.md:41
msgid ""
"// `HashMap::insert()` returns `None`\n"
"    // if the inserted value is new, `Some(value)` otherwise\n"
msgstr ""
"// `HashMap::insert()`는 삽입된 값이 새로운 것이면 `None`을,\n"
"    // 그렇지 않으면 `Some(value)`를 반환합니다\n"

#: src/std/hash.md:43
msgid "\"164-6743\""
msgstr "\"164-6743\""

#: src/std/hash.md:46
msgid "\"Calling Ashley: {}\""
msgstr "\"애슐리에게 전화 거는 중: {}\""

#: src/std/hash.md:47
msgid "\"Don't have Ashley's number.\""
msgstr "\"애슐리의 번호가 없습니다.\""

#: src/std/hash.md:52
msgid ""
"// `HashMap::iter()` returns an iterator that yields\n"
"    // (&'a key, &'a value) pairs in arbitrary order.\n"
msgstr ""
"// `HashMap::iter()`는 (&'a key, &'a value) 쌍을\n"
"    // 임의의 순서로 내놓는 이터레이터를 반환합니다.\n"

#: src/std/hash.md:55
msgid "\"Calling {}: {}\""
msgstr "\"{}에게 전화 거는 중: {}\""

#: src/std/hash.md:60
msgid ""
"For more information on how hashing and hash maps (sometimes called hash "
"tables) work, have a look at [Hash Table Wikipedia](https://en.wikipedia.org/"
"wiki/Hash_table)"
msgstr ""
"해싱과 해시 맵(때때로 해시 테이블이라고도 불림)이 어떻게 작동하는지에 대한 "
"더 자세한 정보는 [Wikipedia의 해시 테이블](https://en.wikipedia.org/wiki/"
"Hash_table)을 참조하세요."

#: src/std/hash/alt_key_types.md:3
msgid ""
"Any type that implements the `Eq` and `Hash` traits can be a key in "
"`HashMap`. This includes:"
msgstr ""
"`Eq`와 `Hash` 트레이트를 구현하는 어떤 타입이든 `HashMap`의 키가 될 수 있습니"
"다. 여기에는 다음이 포함됩니다:"

#: src/std/hash/alt_key_types.md:6
msgid "`bool` (though not very useful since there are only two possible keys)"
msgstr "`bool` (가능한 키가 두 개뿐이라 그리 유용하진 않지만요)"

#: src/std/hash/alt_key_types.md:7
msgid "`int`, `uint`, and all variations thereof"
msgstr "`int`, `uint` 및 그 모든 변형들"

#: src/std/hash/alt_key_types.md:8
msgid ""
"`String` and `&str` (protip: you can have a `HashMap` keyed by `String` and "
"call `.get()` with an `&str`)"
msgstr ""
"`String`과 `&str` (꿀팁: `String`을 키로 하는 `HashMap`을 만들고 `&str`을 사"
"용하여 `.get()`을 호출할 수 있습니다)"

#: src/std/hash/alt_key_types.md:11
msgid ""
"Note that `f32` and `f64` do _not_ implement `Hash`, likely because "
"[floating-point precision errors](https://en.wikipedia.org/wiki/"
"Floating_point#Accuracy_problems) would make using them as hashmap keys "
"horribly error-prone."
msgstr ""
"`f32`와 `f64`는 `Hash`를 구현하지 않는다는 점에 유의하세요. 아마도 [부동 소수"
"점 정밀도 에러](https://en.wikipedia.org/wiki/"
"Floating_point#Accuracy_problems)로 인해 이들을 해시 맵 키로 사용하는 것이 극"
"도로 에러에 취약해질 수 있기 때문일 것입니다."

#: src/std/hash/alt_key_types.md:15
msgid ""
"All collection classes implement `Eq` and `Hash` if their contained type "
"also respectively implements `Eq` and `Hash`. For example, `Vec<T>` will "
"implement `Hash` if `T` implements `Hash`."
msgstr ""
"모든 컬렉션 클래스는 포함된 타입이 각각 `Eq`와 `Hash`를 구현한다면 `Eq`와 "
"`Hash`를 구현합니다. 예를 들어, `Vec<T>`는 `T`가 `Hash`를 구현한다면 `Hash`"
"를 구현합니다."

#: src/std/hash/alt_key_types.md:19
msgid ""
"You can easily implement `Eq` and `Hash` for a custom type with just one "
"line: `#[derive(PartialEq, Eq, Hash)]`"
msgstr ""
"단 한 줄의 코드로 커스텀 타입에 대해 `Eq`와 `Hash`를 쉽게 구현할 수 있습니"
"다: `#[derive(PartialEq, Eq, Hash)]`"

#: src/std/hash/alt_key_types.md:22
msgid ""
"The compiler will do the rest. If you want more control over the details, "
"you can implement `Eq` and/or `Hash` yourself. This guide will not cover the "
"specifics of implementing `Hash`."
msgstr ""
"컴파일러가 나머지를 알아서 할 것입니다. 만약 세부 사항을 더 제어하고 싶다면, "
"`Eq`나 `Hash`를 직접 구현할 수 있습니다. 이 가이드에서는 `Hash` 구현의 구체적"
"인 내용은 다루지 않습니다."

#: src/std/hash/alt_key_types.md:26
msgid ""
"To play around with using a `struct` in `HashMap`, let's try making a very "
"simple user logon system:"
msgstr ""
"`HashMap`에서 `struct`를 사용하는 것을 연습해 보기 위해, 매우 간단한 사용자 "
"로그인 시스템을 만들어 봅시다:"

#: src/std/hash/alt_key_types.md:31
msgid "// Eq requires that you derive PartialEq on the type.\n"
msgstr "// Eq는 해당 타입에 대해 PartialEq를 유도(derive)할 것을 요구합니다.\n"

#: src/std/hash/alt_key_types.md:48
msgid "\"Username: {}\""
msgstr "\"사용자 이름: {}\""

#: src/std/hash/alt_key_types.md:49
msgid "\"Password: {}\""
msgstr "\"비밀번호: {}\""

#: src/std/hash/alt_key_types.md:50
msgid "\"Attempting logon...\""
msgstr "\"로그인 시도 중...\""

#: src/std/hash/alt_key_types.md:59
msgid "\"Successful logon!\""
msgstr "\"로그인 성공!\""

#: src/std/hash/alt_key_types.md:60
msgid "\"Name: {}\""
msgstr "\"이름: {}\""

#: src/std/hash/alt_key_types.md:61
msgid "\"Email: {}\""
msgstr "\"이메일: {}\""

#: src/std/hash/alt_key_types.md:63
msgid "\"Login failed!\""
msgstr "\"로그인 실패!\""

#: src/std/hash/alt_key_types.md:71 src/std/hash/alt_key_types.md:82
#: src/std/hash/alt_key_types.md:84
msgid "\"j.everyman\""
msgstr "\"j.everyman\""

#: src/std/hash/alt_key_types.md:72 src/std/hash/alt_key_types.md:84
msgid "\"password123\""
msgstr "\"password123\""

#: src/std/hash/alt_key_types.md:76
msgid "\"John Everyman\""
msgstr "\"John Everyman\""

#: src/std/hash/alt_key_types.md:77
msgid "\"j.everyman@email.com\""
msgstr "\"j.everyman@email.com\""

#: src/std/hash/alt_key_types.md:82
msgid "\"psasword123\""
msgstr "\"psasword123\""

#: src/std/hash/hashset.md:3
msgid ""
"Consider a `HashSet` as a `HashMap` where we just care about the keys "
"( `HashSet<T>` is, in actuality, just a wrapper around `HashMap<T, ()>`)."
msgstr ""
"`HashSet`을 키에만 관심이 있는 `HashMap`이라고 생각해보세요 (`HashSet<T>`는 "
"실제로 `HashMap<T, ()>`의 래퍼(wrapper)일 뿐입니다)."

#: src/std/hash/hashset.md:6
msgid ""
"\"What's the point of that?\" you ask. \"I could just store the keys in a "
"`Vec`.\""
msgstr ""
"\"그게 무슨 소용이죠?\"라고 물으실 수 있습니다. \"그냥 키를 `Vec`에 저장할 수"
"도 있잖아요.\""

#: src/std/hash/hashset.md:8
msgid ""
"A `HashSet`'s unique feature is that it is guaranteed to not have duplicate "
"elements. That's the contract that any set collection fulfills. `HashSet` is "
"just one implementation. (see also: [`BTreeSet`](https://doc.rust-lang.org/"
"std/collections/struct.BTreeSet.html))"
msgstr ""
"`HashSet`의 고유한 특징은 중복된 요소가 없음을 보장한다는 것입니다. 이는 모"
"든 집합(set) 컬렉션이 지키는 계약입니다. `HashSet`은 그 중 하나의 구현일 뿐입"
"니다. (참고: [`BTreeSet`](https://doc.rust-lang.org/std/collections/"
"struct.BTreeSet.html))"

#: src/std/hash/hashset.md:13
msgid ""
"If you insert a value that is already present in the `HashSet`, (i.e. the "
"new value is equal to the existing and they both have the same hash), then "
"the new value will replace the old."
msgstr ""
"이미 `HashSet`에 존재하는 값을 삽입하면 (즉, 새 값이 기존 값과 같고 해시도 같"
"다면), 새 값이 기존 값을 대체하게 됩니다."

#: src/std/hash/hashset.md:17
msgid ""
"This is great for when you never want more than one of something, or when "
"you want to know if you've already got something."
msgstr ""
"이는 무언가를 중복 없이 유지하고 싶을 때나, 이미 가지고 있는지 알고 싶을 때 "
"매우 유용합니다."

#: src/std/hash/hashset.md:20
msgid "But sets can do more than that."
msgstr "하지만 집합은 그 이상의 일을 할 수 있습니다."

#: src/std/hash/hashset.md:22
msgid ""
"Sets have 4 primary operations (all of the following calls return an "
"iterator):"
msgstr ""
"집합은 4가지 주요 연산을 가집니다 (다음 호출들은 모두 이터레이터를 반환합니"
"다):"

#: src/std/hash/hashset.md:24
msgid "`union`: get all the unique elements in both sets."
msgstr "`union`(합집합): 두 집합에 있는 모든 고유한 요소들을 가져옵니다."

#: src/std/hash/hashset.md:26
msgid ""
"`difference`: get all the elements that are in the first set but not the "
"second."
msgstr ""
"`difference`(차집합): 첫 번째 집합에는 있지만 두 번째 집합에는 없는 모든 요소"
"들을 가져옵니다."

#: src/std/hash/hashset.md:28
msgid "`intersection`: get all the elements that are only in _both_ sets."
msgstr ""
"`intersection`(교집합): 오직 *양쪽* 집합 모두에 있는 모든 요소들을 가져옵니"
"다."

#: src/std/hash/hashset.md:30
msgid ""
"`symmetric_difference`: get all the elements that are in one set or the "
"other, but _not_ both."
msgstr ""
"`symmetric_difference`(대칭차집합): 한쪽 집합에는 있지만 *양쪽 모두*에 있지"
"는 않은 모든 요소들을 가져옵니다."

#: src/std/hash/hashset.md:33
msgid "Try all of these in the following example:"
msgstr "다음 예제에서 이들 모두를 시도해 보세요:"

#: src/std/hash/hashset.md:45
msgid ""
"// `HashSet::insert()` returns false if\n"
"    // there was a value already present.\n"
msgstr "// `HashSet::insert()`는 값이 이미 존재하면 false를 반환합니다.\n"

#: src/std/hash/hashset.md:47
msgid "\"Value 4 is already in set B!\""
msgstr "\"값 4는 이미 집합 B에 있습니다!\""

#: src/std/hash/hashset.md:52
msgid ""
"// If a collection's element type implements `Debug`,\n"
"    // then the collection implements `Debug`.\n"
"    // It usually prints its elements in the format `[elem1, elem2, ...]`\n"
msgstr ""
"// 컬렉션의 요소 타입이 `Debug`를 구현한다면,\n"
"// 컬렉션도 `Debug`를 구현합니다.\n"
"// 보통 `[elem1, elem2, ...]` 형식으로 요소를 출력합니다.\n"

#: src/std/hash/hashset.md:55
msgid "\"A: {:?}\""
msgstr "\"A: {:?}\""

#: src/std/hash/hashset.md:56
msgid "\"B: {:?}\""
msgstr "\"B: {:?}\""

#: src/std/hash/hashset.md:58
msgid "// Print [1, 2, 3, 4, 5] in arbitrary order\n"
msgstr "// [1, 2, 3, 4, 5]를 임의의 순서로 출력합니다\n"

#: src/std/hash/hashset.md:59
msgid "\"Union: {:?}\""
msgstr "\"합집합: {:?}\""

#: src/std/hash/hashset.md:61
msgid "// This should print [1]\n"
msgstr "// 이는 [1]을 출력해야 합니다\n"

#: src/std/hash/hashset.md:62
msgid "\"Difference: {:?}\""
msgstr "\"차집합: {:?}\""

#: src/std/hash/hashset.md:64
msgid "// Print [2, 3, 4] in arbitrary order.\n"
msgstr "// [2, 3, 4]를 임의의 순서로 출력합니다.\n"

#: src/std/hash/hashset.md:65
msgid "\"Intersection: {:?}\""
msgstr "\"교집합: {:?}\""

#: src/std/hash/hashset.md:67
msgid "// Print [1, 5]\n"
msgstr "// [1, 5]를 출력합니다\n"

#: src/std/hash/hashset.md:68
msgid "\"Symmetric Difference: {:?}\""
msgstr "\"대칭차집합: {:?}\""

#: src/std/hash/hashset.md:73
msgid ""
"(Examples are adapted from the [documentation.](https://doc.rust-lang.org/"
"std/collections/struct.HashSet.html#method.difference))"
msgstr ""
"(예제는 [문서](https://doc.rust-lang.org/std/collections/"
"struct.HashSet.html#method.difference)에서 발췌 및 수정되었습니다.)"

#: src/std/rc.md:3
msgid ""
"When multiple ownership is needed, `Rc`(Reference Counting) can be used. "
"`Rc` keeps track of the number of the references which means the number of "
"owners of the value wrapped inside an `Rc`."
msgstr ""
"다중 소유권이 필요한 경우, `Rc`(참조 횟수 계산, Reference Counting)를 사용할 "
"수 있습니다. `Rc`는 참조의 개수를 추적하며, 이는 `Rc` 내부에 감싸진 값의 소유"
"자 수를 의미합니다."

#: src/std/rc.md:7
msgid ""
"Reference count of an `Rc` increases by 1 whenever an `Rc` is cloned, and "
"decreases by 1 whenever one cloned `Rc` is dropped out of the scope. When an "
"`Rc`'s reference count becomes zero (which means there are no remaining "
"owners), both the `Rc` and the value are all dropped."
msgstr ""
"`Rc`의 참조 횟수는 `Rc`가 클론될 때마다 1씩 증가하고, 클론된 `Rc`가 스코프를 "
"벗어날 때마다 1씩 감소합니다. `Rc`의 참조 횟수가 0이 되면 (즉, 남은 소유자가 "
"없으면), `Rc`와 그 내부의 값 모두 해제됩니다."

#: src/std/rc.md:12
msgid ""
"Cloning an `Rc` never performs a deep copy. Cloning creates just another "
"pointer to the wrapped value, and increments the count."
msgstr ""
"`Rc`를 클론하는 것은 결코 깊은 복사(deep copy)를 수행하지 않습니다. 클론은 단"
"지 감싸진 값을 가리키는 또 다른 포인터를 생성하고, 횟수를 증가시킬 뿐입니다."

#: src/std/rc.md:19
msgid "\"Rc examples\""
msgstr "\"Rc 예제\""

#: src/std/rc.md:21
msgid "\"--- rc_a is created ---\""
msgstr "\"--- rc_a가 생성됨 ---\""

#: src/std/rc.md:24 src/std/rc.md:31 src/std/rc.md:43
msgid "\"Reference Count of rc_a: {}\""
msgstr "\"rc_a의 참조 횟수: {}\""

#: src/std/rc.md:27
msgid "\"--- rc_a is cloned to rc_b ---\""
msgstr "\"--- rc_a가 rc_b로 클론됨 ---\""

#: src/std/rc.md:30
msgid "\"Reference Count of rc_b: {}\""
msgstr "\"rc_b의 참조 횟수: {}\""

#: src/std/rc.md:33
msgid "// Two `Rc`s are equal if their inner values are equal\n"
msgstr "// 두 `Rc`는 내부 값이 같으면 같습니다\n"

#: src/std/rc.md:34
msgid "\"rc_a and rc_b are equal: {}\""
msgstr "\"rc_a와 rc_b는 같음: {}\""

#: src/std/rc.md:36
msgid "// We can use methods of a value directly\n"
msgstr "// 값의 메서드들을 직접 사용할 수 있습니다\n"

#: src/std/rc.md:37
msgid "\"Length of the value inside rc_a: {}\""
msgstr "\"rc_a 내부 값의 길이: {}\""

#: src/std/rc.md:38
msgid "\"Value of rc_b: {}\""
msgstr "\"rc_b의 값: {}\""

#: src/std/rc.md:40
msgid "\"--- rc_b is dropped out of scope ---\""
msgstr "\"--- rc_b가 스코프를 벗어나 해제됨 ---\""

#: src/std/rc.md:45
msgid "\"--- rc_a is dropped out of scope ---\""
msgstr "\"--- rc_a가 스코프를 벗어나 해제됨 ---\""

#: src/std/rc.md:48
msgid ""
"// Error! `rc_examples` already moved into `rc_a`\n"
"    // And when `rc_a` is dropped, `rc_examples` is dropped together\n"
"    // println!(\"rc_examples: {}\", rc_examples);\n"
"    // TODO ^ Try uncommenting this line\n"
msgstr ""
"// 에러! `rc_examples`는 이미 `rc_a`로 이동되었습니다\n"
"    // 그리고 `rc_a`가 해제될 때, `rc_examples`도 함께 해제됩니다\n"
"    // println!(\"rc_examples: {}\", rc_examples);\n"
"    // TODO ^ 이 줄의 주석을 해제해 보세요\n"

#: src/std/rc.md:57
msgid ""
"[std::rc](https://doc.rust-lang.org/std/rc/index.html) and [std::sync::arc]"
"(https://doc.rust-lang.org/std/sync/struct.Arc.html)."
msgstr ""
"[std::rc](https://doc.rust-lang.org/std/rc/index.html)와 [std::sync::arc]"
"(https://doc.rust-lang.org/std/sync/struct.Arc.html)."

#: src/std/arc.md:1
msgid "Arc"
msgstr "Arc"

#: src/std/arc.md:3
msgid ""
"When shared ownership between threads is needed, `Arc`(Atomically Reference "
"Counted) can be used. This struct, via the `Clone` implementation can create "
"a reference pointer for the location of a value in the memory heap while "
"increasing the reference counter. As it shares ownership between threads, "
"when the last reference pointer to a value is out of scope, the variable is "
"dropped."
msgstr ""
"스레드 간의 공유 소유권이 필요한 경우, `Arc`(원자적 참조 횟수 계산, "
"Atomically Reference Counted)를 사용할 수 있습니다. 이 구조체는 `Clone` 구현"
"을 통해 힙 메모리에 있는 값의 위치를 가리키는 참조 포인터를 생성하고 참조 횟"
"수를 증가시킵니다. 스레드 간에 소유권을 공유하므로, 값에 대한 마지막 참조 포"
"인터가 스코프를 벗어날 때 변수가 해제됩니다."

#: src/std/arc.md:15
msgid "// This variable declaration is where its value is specified.\n"
msgstr "// 이 변수 선언에서 값이 지정됩니다.\n"

#: src/std/arc.md:16
msgid "\"the same apple\""
msgstr "\"같은 사과\""

#: src/std/arc.md:19
msgid ""
"// Here there is no value specification as it is a pointer to a\n"
"        // reference in the memory heap.\n"
msgstr ""
"// 여기서는 힙 메모리의 참조를 가리키는 포인터이므로 별도의 값 지정이 없습니"
"다.\n"

#: src/std/arc.md:24
msgid ""
"// As Arc was used, threads can be spawned using the value allocated\n"
"            // in the Arc variable pointer's location.\n"
msgstr ""
"// `Arc`를 사용했으므로, `Arc` 변수 포인터 위치에 할당된 값을 사용하여 스레드"
"를 생성할 수 있습니다.\n"

#: src/std/arc.md:30
msgid "// Make sure all Arc instances are printed from spawned threads.\n"
msgstr "// 모든 `Arc` 인스턴스가 생성된 스레드에서 출력되도록 합니다.\n"

#: src/std_misc.md:3
msgid ""
"Many other types are provided by the std library to support things such as:"
msgstr ""
"표준 라이브러리는 다음과 같은 것들을 지원하기 위해 많은 다른 타입들을 제공합"
"니다:"

#: src/std_misc.md:10
msgid "These expand beyond what the [primitives](primitives.md) provide."
msgstr "이들은 [기본 자료형](primitives.md)이 제공하는 것 이상으로 확장됩니다."

#: src/std_misc/threads.md:3
msgid ""
"Rust provides a mechanism for spawning native OS threads via the `spawn` "
"function, the argument of this function is a moving closure."
msgstr ""
"Rust는 `spawn` 함수를 통해 네이티브 OS 스레드를 생성하는 메커니즘을 제공합니"
"다. 이 함수의 인자는 이동(moving) 클로저입니다."

#: src/std_misc/threads.md:10 src/std_misc/threads/testcase_mapreduce.md:28
msgid "// This is the `main` thread\n"
msgstr "// 메인 스레드입니다\n"

#: src/std_misc/threads.md:13
msgid "// Make a vector to hold the children which are spawned.\n"
msgstr "// 생성된 자식 스레드들을 담을 벡터를 만듭니다.\n"

#: src/std_misc/threads.md:17
msgid "// Spin up another thread\n"
msgstr "// 또 다른 스레드를 생성합니다\n"

#: src/std_misc/threads.md:19
msgid "\"this is thread number {}\""
msgstr "\"이것은 {}번 스레드입니다\""

#: src/std_misc/threads.md:24
msgid "// Wait for the thread to finish. Returns a result.\n"
msgstr "// 스레드가 종료될 때까지 기다립니다. 결과를 반환합니다.\n"

#: src/std_misc/threads.md:30
msgid "These threads will be scheduled by the OS."
msgstr "이러한 스레드들은 OS에 의해 스케줄링됩니다."

#: src/std_misc/threads/testcase_mapreduce.md:3
msgid ""
"Rust makes it very easy to parallelize data processing, without many of the "
"headaches traditionally associated with such an attempt."
msgstr ""
"Rust는 전통적으로 이러한 시도와 관련된 많은 골칫거리 없이 데이터 처리를 병렬"
"화하는 것을 매우 쉽게 만들어 줍니다."

#: src/std_misc/threads/testcase_mapreduce.md:5
msgid ""
"The standard library provides great threading primitives out of the box. "
"These, combined with Rust's concept of Ownership and aliasing rules, "
"automatically prevent data races."
msgstr ""
"표준 라이브러리는 훌륭한 스레딩 프리미티브를 즉시 제공합니다. 이들은 Rust의 "
"소유권 개념 및 에일리어싱 규칙과 결합하여 자동으로 데이터 경합(data races)을 "
"방지합니다."

#: src/std_misc/threads/testcase_mapreduce.md:9
msgid ""
"The aliasing rules (one writable reference XOR many readable references) "
"automatically prevent you from manipulating state that is visible to other "
"threads. (Where synchronization is needed, there are synchronization "
"primitives like `Mutex`es or `Channel`s.)"
msgstr ""
"에일리어싱 규칙(하나의 쓰기 가능 참조 XOR 여러 개의 읽기 가능 참조)은 다른 스"
"레드에 보이는 상태를 조작하는 것을 자동으로 방지합니다. (동기화가 필요한 곳에"
"는 `Mutex`나 `Channel`과 같은 동기화 프리미티브가 있습니다.)"

#: src/std_misc/threads/testcase_mapreduce.md:14
msgid ""
"In this example, we will calculate the sum of all digits in a block of "
"numbers. We will do this by parcelling out chunks of the block into "
"different threads. Each thread will sum its tiny block of digits, and "
"subsequently we will sum the intermediate sums produced by each thread."
msgstr ""
"이 예제에서, 우리는 숫자 블록에 있는 모든 숫자의 합을 계산할 것입니다. 블록"
"의 덩어리들을 서로 다른 스레드에 할당하여 이를 수행할 것입니다. 각 스레드는 "
"자신의 작은 숫자 블록의 합을 구하고, 이어서 각 스레드에서 생성된 중간 합계들"
"을 모두 더할 것입니다."

#: src/std_misc/threads/testcase_mapreduce.md:19
msgid ""
"Note that, although we're passing references across thread boundaries, Rust "
"understands that we're only passing read-only references, and that thus no "
"unsafety or data races can occur. Also because the references we're passing "
"have `'static` lifetimes, Rust understands that our data won't be destroyed "
"while these threads are still running. (When you need to share non-`static` "
"data between threads, you can use a smart pointer like `Arc` to keep the "
"data alive and avoid non-`static` lifetimes.)"
msgstr ""
"스레드 경계를 넘어 참조를 전달하고 있지만, Rust는 우리가 읽기 전용 참조만 전"
"달하고 있음을 이해하며, 따라서 안전하지 않은 상황이나 데이터 경합이 발생할 "
"수 없음을 알고 있습니다. 또한 우리가 전달하는 참조들이 `'static` 라이프타임"
"을 가지고 있기 때문에, Rust는 이 스레드들이 실행되는 동안 데이터가 파괴되지 "
"않을 것임을 이해합니다. (스레드 간에 `static`이 아닌 데이터를 공유해야 할 때"
"는 `Arc`와 같은 스마트 포인터를 사용하여 데이터를 유지하고 `static`이 아닌 라"
"이프타임 문제를 피할 수 있습니다.)"

#: src/std_misc/threads/testcase_mapreduce.md:32
msgid ""
"// This is our data to process.\n"
"    // We will calculate the sum of all digits via a threaded map-reduce "
"algorithm.\n"
"    // Each whitespace separated chunk will be handled in a different "
"thread.\n"
"    //\n"
"    // TODO: see what happens to the output if you insert spaces!\n"
msgstr ""
"// 처리할 데이터입니다.\n"
"    // 스레드된 맵-리듀스(map-reduce) 알고리즘을 통해 모든 숫자의 합을 계산"
"할 것입니다.\n"
"    // 공백으로 구분된 각 덩어리는 서로 다른 스레드에서 처리될 것입니다.\n"
"    //\n"
"    // TODO: 공백을 삽입하면 출력에 어떤 변화가 생기는지 확인해 보세요!\n"

#: src/std_misc/threads/testcase_mapreduce.md:37
msgid ""
"\"86967897737416471853297327050364959\n"
"11861322575564723963297542624962850\n"
"70856234701860851907960690014725639\n"
"38397966707106094172783238747669219\n"
"52380795257888236525459303330302837\n"
"58495327135744041048897885734297812\n"
"69920216438980873548808413720956532\n"
"16278424637452589860345374828574668\""
msgstr ""
"\"86967897737416471853297327050364959\n"
"11861322575564723963297542624962850\n"
"70856234701860851907960690014725639\n"
"38397966707106094172783238747669219\n"
"52380795257888236525459303330302837\n"
"58495327135744041048897885734297812\n"
"69920216438980873548808413720956532\n"
"16278424637452589860345374828574668\""

#: src/std_misc/threads/testcase_mapreduce.md:46
msgid "// Make a vector to hold the child-threads which we will spawn.\n"
msgstr "// 우리가 생성할 자식 스레드들을 담을 벡터를 만듭니다.\n"

#: src/std_misc/threads/testcase_mapreduce.md:49
msgid ""
"/*************************************************************************\n"
"     * \"Map\" phase\n"
"     *\n"
"     * Divide our data into segments, and apply initial processing\n"
"     ************************************************************************/"
msgstr ""
"/*************************************************************************\n"
"     * \"Map\" 단계\n"
"     *\n"
"     * 데이터를 세그먼트로 나누고, 초기 처리를 적용합니다\n"
"     ************************************************************************/"

#: src/std_misc/threads/testcase_mapreduce.md:55
msgid ""
"// split our data into segments for individual calculation\n"
"    // each chunk will be a reference (&str) into the actual data\n"
msgstr ""
"// 개별 계산을 위해 데이터를 세그먼트로 나눕니다.\n"
"// 각 덩어리는 실제 데이터에 대한 참조(&str)가 될 것입니다.\n"

#: src/std_misc/threads/testcase_mapreduce.md:59
msgid ""
"// Iterate over the data segments.\n"
"    // .enumerate() adds the current loop index to whatever is iterated\n"
"    // the resulting tuple \"(index, element)\" is then immediately\n"
"    // \"destructured\" into two variables, \"i\" and \"data_segment\" with "
"a\n"
"    // \"destructuring assignment\"\n"
msgstr ""
"// 데이터 세그먼트들을 순회합니다.\n"
"// `.enumerate()`는 순회하는 대상에 현재 루프 인덱스를 추가합니다.\n"
"// 결과 튜플 \"(index, element)\"는 \"구조 분해 할당\"\n"
"// 을 통해 즉시 두 변수 \"i\"와 \"data_segment\"로 \"구조 분해\"됩니다.\n"

#: src/std_misc/threads/testcase_mapreduce.md:65
msgid "\"data segment {} is \\\"{}\\\"\""
msgstr "\"데이터 세그먼트 {}는 \\\"{}\\\"입니다\""

#: src/std_misc/threads/testcase_mapreduce.md:67
msgid ""
"// Process each data segment in a separate thread\n"
"        //\n"
"        // spawn() returns a handle to the new thread,\n"
"        // which we MUST keep to access the returned value\n"
"        //\n"
"        // 'move || -> u32' is syntax for a closure that:\n"
"        // * takes no arguments ('||')\n"
"        // * takes ownership of its captured variables ('move') and\n"
"        // * returns an unsigned 32-bit integer ('-> u32')\n"
"        //\n"
"        // Rust is smart enough to infer the '-> u32' from\n"
"        // the closure itself so we could have left that out.\n"
"        //\n"
"        // TODO: try removing the 'move' and see what happens\n"
msgstr ""
"// 각 데이터 세그먼트를 별도의 스레드에서 처리합니다\n"
"        //\n"
"        // spawn()은 새 스레드에 대한 핸들을 반환하며,\n"
"        // 반환된 값에 접근하려면 이 핸들을 반드시 보관해야 합니다\n"
"        //\n"
"        // 'move || -> u32'는 다음과 같은 클로저 문법입니다:\n"
"        // * 인자를 취하지 않음 ('||')\n"
"        // * 캡처한 변수의 소유권을 가져옴 ('move')\n"
"        // * 부호 없는 32비트 정수를 반환함 ('-> u32')\n"
"        //\n"
"        // Rust는 클로저 자체에서 '-> u32'를 추론할 수 있을 만큼 영리하므로\n"
"        // 이를 생략할 수도 있었습니다.\n"
"        //\n"
"        // TODO: 'move'를 제거해 보고 어떤 일이 일어나는지 확인해 보세요\n"

#: src/std_misc/threads/testcase_mapreduce.md:82
msgid "// Calculate the intermediate sum of this segment:\n"
msgstr "// 이 세그먼트의 중간 합계를 계산합니다:\n"

#: src/std_misc/threads/testcase_mapreduce.md:84
msgid "// iterate over the characters of our segment..\n"
msgstr "// 세그먼트의 문자들을 순회합니다..\n"

#: src/std_misc/threads/testcase_mapreduce.md:86
msgid "// .. convert text-characters to their number value..\n"
msgstr "// .. 텍스트 문자를 숫자 값으로 변환합니다..\n"

#: src/std_misc/threads/testcase_mapreduce.md:87
msgid "\"should be a digit\""
msgstr "\"숫자여야 합니다\""

#: src/std_misc/threads/testcase_mapreduce.md:88
msgid "// .. and sum the resulting iterator of numbers\n"
msgstr "// .. 그리고 결과 숫지 이터레이터의 합을 구합니다\n"

#: src/std_misc/threads/testcase_mapreduce.md:91
msgid "// println! locks stdout, so no text-interleaving occurs\n"
msgstr "// println!은 표준 출력을 잠그므로, 텍스트가 서로 섞이지 않습니다\n"

#: src/std_misc/threads/testcase_mapreduce.md:92
msgid "\"processed segment {}, result={}\""
msgstr "\"세그먼트 {} 처리됨, 결과={}\""

#: src/std_misc/threads/testcase_mapreduce.md:94
msgid ""
"// \"return\" not needed, because Rust is an \"expression language\", the\n"
"            // last evaluated expression in each block is automatically its "
"value.\n"
msgstr ""
"// Rust는 \"표현식 언어\"이므로 \"return\"이 필요하지 않습니다.\n"
"            // 각 블록에서 마지막으로 평가된 표현식이 자동으로 그 값이 됩니"
"다.\n"

#: src/std_misc/threads/testcase_mapreduce.md:102
msgid ""
"/*************************************************************************\n"
"     * \"Reduce\" phase\n"
"     *\n"
"     * Collect our intermediate results, and combine them into a final "
"result\n"
"     ************************************************************************/"
msgstr ""
"/*************************************************************************\n"
"     * \"Reduce\" 단계\n"
"     *\n"
"     * 중간 결과들을 수집하여 최종 결과로 결합합니다\n"
"     ************************************************************************/"

#: src/std_misc/threads/testcase_mapreduce.md:108
msgid ""
"// combine each thread's intermediate results into a single final sum.\n"
"    //\n"
"    // we use the \"turbofish\" ::<> to provide sum() with a type hint.\n"
"    //\n"
"    // TODO: try without the turbofish, by instead explicitly\n"
"    // specifying the type of final_result\n"
msgstr ""
"// 각 스레드의 중간 결과들을 하나의 최종 합계로 결합합니다.\n"
"//\n"
"// `sum()`에 타입 힌트를 제공하기 위해 \"터보피쉬(turbofish)\" `::<>`를 사용"
"합니다.\n"
"//\n"
"// TODO: 터보피쉬 대신 `final_result`의 타입을 명시적으로 지정하여 시도해 보"
"세요\n"

#: src/std_misc/threads/testcase_mapreduce.md:116
msgid "\"Final sum result: {}\""
msgstr "\"최종 합계 결과: {}\""

#: src/std_misc/threads/testcase_mapreduce.md:120
msgid "Assignments"
msgstr "과제"

#: src/std_misc/threads/testcase_mapreduce.md:122
msgid ""
"It is not wise to let our number of threads depend on user inputted data. "
"What if the user decides to insert a lot of spaces? Do we _really_ want to "
"spawn 2,000 threads? Modify the program so that the data is always chunked "
"into a limited number of chunks, defined by a static constant at the "
"beginning of the program."
msgstr ""
"스레드 개수가 사용자 입력 데이터에 의존하게 하는 것은 현명하지 않습니다. 사용"
"자가 많은 공백을 삽입하기로 한다면 어떨까요? 정말로 2,000개의 스레드를 생성하"
"고 싶으신가요? 프로그램 시작 부분에 정의된 정적 상수에 따라 데이터가 항상 제"
"한된 개수의 덩어리로 나뉘도록 프로그램을 수정해 보세요."

#: src/std_misc/threads/testcase_mapreduce.md:129
msgid "[Threads](../threads.md)"
msgstr "[스레드](../threads.md)"

#: src/std_misc/threads/testcase_mapreduce.md:130
msgid "[vectors](../../std/vec.md) and [iterators](../../trait/iter.md)"
msgstr "[벡터](../../std/vec.md)와 [이터레이터](../../trait/iter.md)"

#: src/std_misc/threads/testcase_mapreduce.md:131
msgid ""
"[closures](../../fn/closures.md), [move](../../scope/move.md) semantics and "
"[`move` closures](https://doc.rust-lang.org/book/ch13-01-"
"closures.html#closures-can-capture-their-environment)"
msgstr ""
"[클로저](../../fn/closures.md), [이동(move)](../../scope/move.md) 의미론 및 "
"[`move` 클로저](https://doc.rust-lang.org/book/ch13-01-"
"closures.html#closures-can-capture-their-environment)"

#: src/std_misc/threads/testcase_mapreduce.md:132
msgid ""
"[destructuring](https://doc.rust-lang.org/book/ch18-03-pattern-"
"syntax.html#destructuring-to-break-apart-values) assignments"
msgstr ""
"[구조 분해(destructuring)](https://doc.rust-lang.org/book/ch18-03-pattern-"
"syntax.html#destructuring-to-break-apart-values) 할당"

#: src/std_misc/threads/testcase_mapreduce.md:133
msgid ""
"[turbofish notation](https://doc.rust-lang.org/book/appendix-02-"
"operators.html?highlight=turbofish) to help type inference"
msgstr ""
"타입 추론을 돕기 위한 [터보피쉬 표기법](https://doc.rust-lang.org/book/"
"appendix-02-operators.html?highlight=turbofish)"

#: src/std_misc/threads/testcase_mapreduce.md:134
msgid "[unwrap vs. expect](../../error/option_unwrap.md)"
msgstr "[unwrap vs. expect](../../error/option_unwrap.md)"

#: src/std_misc/threads/testcase_mapreduce.md:135
msgid "[enumerate](https://doc.rust-lang.org/book/loops.html#enumerate)"
msgstr "[enumerate](https://doc.rust-lang.org/book/loops.html#enumerate)"

#: src/std_misc/channels.md:3
msgid ""
"Rust provides asynchronous `channels` for communication between threads. "
"Channels allow a unidirectional flow of information between two end-points: "
"the `Sender` and the `Receiver`."
msgstr ""
"Rust는 스레드 간 통신을 위한 비동기 `채널(channels)`을 제공합니다. 채널은 "
"`Sender`와 `Receiver`라는 두 끝점 사이에서 정보의 단방향 흐름을 가능하게 합니"
"다."

#: src/std_misc/channels.md:15
msgid ""
"// Channels have two endpoints: the `Sender<T>` and the `Receiver<T>`,\n"
"    // where `T` is the type of the message to be transferred\n"
"    // (type annotation is superfluous)\n"
msgstr ""
"// 채널에는 두 끝점이 있습니다: `Sender<T>`와 `Receiver<T>`.\n"
"// 여기서 `T`는 전송될 메시지의 타입입니다\n"
"// (타입 어노테이션은 불필요합니다)\n"

#: src/std_misc/channels.md:22
msgid "// The sender endpoint can be copied\n"
msgstr "// 발신자(sender) 끝점은 복사될 수 있습니다\n"

#: src/std_misc/channels.md:25
msgid "// Each thread will send its id via the channel\n"
msgstr "// 각 스레드는 채널을 통해 자신의 id를 보낼 것입니다\n"

#: src/std_misc/channels.md:27
msgid ""
"// The thread takes ownership over `thread_tx`\n"
"            // Each thread queues a message in the channel\n"
msgstr ""
"// 스레드가 `thread_tx`에 대한 소유권을 가져갑니다\n"
"// 각 스레드는 채널에 메시지를 큐에 넣습니다\n"

#: src/std_misc/channels.md:31
msgid ""
"// Sending is a non-blocking operation, the thread will continue\n"
"            // immediately after sending its message\n"
msgstr ""
"// 보내기는 비차단(non-blocking) 연산이므로, 스레드는\n"
"// 메시지를 보낸 직후 계속 실행됩니다\n"

#: src/std_misc/channels.md:33
msgid "\"thread {} finished\""
msgstr "\"{}번 스레드 종료\""

#: src/std_misc/channels.md:39
msgid "// Here, all the messages are collected\n"
msgstr "// 여기서 모든 메시지가 수집됩니다\n"

#: src/std_misc/channels.md:42
msgid ""
"// The `recv` method picks a message from the channel\n"
"        // `recv` will block the current thread if there are no messages "
"available\n"
msgstr ""
"// `recv` 메서드는 채널에서 메시지를 하나 꺼냅니다\n"
"// `recv`는 사용 가능한 메시지가 없으면 현재 스레드를 차단(block)합니다\n"

#: src/std_misc/channels.md:47
msgid "// Wait for the threads to complete any remaining work\n"
msgstr "// 스레드들이 남은 작업을 모두 완료할 때까지 기다립니다\n"

#: src/std_misc/channels.md:49
msgid "\"oops! the child thread panicked\""
msgstr "\"이런! 자식 스레드에서 패닉이 발생했습니다\""

#: src/std_misc/channels.md:52
msgid "// Show the order in which the messages were sent\n"
msgstr "// 메시지가 전송된 순서를 보여줍니다\n"

#: src/std_misc/path.md:3
msgid ""
"The `Path` type represents file paths in the underlying filesystem. Across "
"all platforms there is a single `std::path::Path` that abstracts over "
"platform-specific path semantics and separators. Bring it into scope with "
"`use std::path::Path;` when needed."
msgstr ""
"`Path` 타입은 기저 파일 시스템의 파일 경로를 나타냅니다. 모든 플랫폼에 걸쳐 "
"플랫폼별 경로 의미론과 구분자를 추상화하는 단일 `std::path::Path`가 존재합니"
"다. 필요할 때 `use std::path::Path;`를 사용하여 스코프로 가져오세요."

#: src/std_misc/path.md:8
msgid ""
"A `Path` can be created from an `OsStr`, and provides several methods to get "
"information from the file/directory the path points to."
msgstr ""
"`Path`는 `OsStr`로부터 생성될 수 있으며, 경로가 가리키는 파일/디렉터리로부터 "
"정보를 얻기 위한 여러 메서드를 제공합니다."

#: src/std_misc/path.md:11
msgid ""
"A `Path` is immutable. The owned version of `Path` is `PathBuf`. The "
"relation between `Path` and `PathBuf` is similar to that of `str` and "
"`String`: a `PathBuf` can be mutated in-place, and can be dereferenced to a "
"`Path`."
msgstr ""
"`Path`는 불변(immutable)입니다. `Path`의 소유형(owned) 버전은 `PathBuf`입니"
"다. `Path`와 `PathBuf`의 관계는 `str`과 `String`의 관계와 유사합니다. "
"`PathBuf`는 그 자리에서 수정될 수 있으며, `Path`로 역참조(dereference)될 수 "
"있습니다."

#: src/std_misc/path.md:15
msgid ""
"Note that a `Path` is _not_ internally represented as an UTF-8 string, but "
"instead is stored as an `OsString`. Therefore, converting a `Path` to a "
"`&str` is _not_ free and may fail (an `Option` is returned). However, a "
"`Path` can be freely converted to an `OsString` or `&OsStr` using "
"`into_os_string` and `as_os_str`, respectively."
msgstr ""
"`Path`는 내부적으로 UTF-8 문자열로 표현되지 않고, 대신 `OsString`으로 저장됩"
"니다. 따라서 `Path`를 `&str`로 변환하는 것은 비용이 들며 실패할 수도 있습니다"
"(`Option`이 반환됩니다). 하지만 `Path`는 각각 `into_os_string`과 `as_os_str`"
"을 사용하여 `OsString`이나 `&OsStr`로 자유롭게 변환될 수 있습니다."

#: src/std_misc/path.md:25
msgid "// Create a `Path` from an `&'static str`\n"
msgstr "// &'static str로부터 Path를 생성합니다\n"

#: src/std_misc/path.md:26
msgid "\".\""
msgstr "\".\""

#: src/std_misc/path.md:28
msgid "// The `display` method returns a `Display`able structure\n"
msgstr "// `display` 메서드는 `Display` 가능한 구조체를 반환합니다\n"

#: src/std_misc/path.md:31
msgid ""
"// `join` merges a path with a byte container using the OS specific\n"
"    // separator, and returns a `PathBuf`\n"
msgstr ""
"// `join`은 OS 전용 구분자를 사용하여 경로를 바이트 컨테이너와 병합하고, "
"`PathBuf`를 반환합니다.\n"

#: src/std_misc/path.md:35
msgid "// `push` extends the `PathBuf` with a `&Path`\n"
msgstr "// `push`는 `PathBuf`를 `&Path`로 확장합니다\n"

#: src/std_misc/path.md:37
msgid "\"myfile.tar.gz\""
msgstr "\"myfile.tar.gz\""

#: src/std_misc/path.md:39
msgid "// `set_file_name` updates the file name of the `PathBuf`\n"
msgstr "// `set_file_name`은 `PathBuf`의 파일 이름을 업데이트합니다\n"

#: src/std_misc/path.md:40
msgid "\"package.tgz\""
msgstr "\"package.tgz\""

#: src/std_misc/path.md:42
msgid "// Convert the `PathBuf` into a string slice\n"
msgstr "// `PathBuf`를 문자열 슬라이스로 변환합니다\n"

#: src/std_misc/path.md:44
msgid "\"new path is not a valid UTF-8 sequence\""
msgstr "\"새 경로가 유효한 UTF-8 시퀀스가 아닙니다\""

#: src/std_misc/path.md:45
msgid "\"new path is {}\""
msgstr "\"새 경로는 {}입니다\""

#: src/std_misc/path.md:50
msgid "Be sure to check other `Path` methods and the `Metadata` struct."
msgstr "다른 `Path` 메서드들과 `Metadata` 구조체도 반드시 확인해 보세요."

#: src/std_misc/path.md:54
msgid ""
"[OsStr](https://doc.rust-lang.org/std/ffi/struct.OsStr.html) and [Metadata]"
"(https://doc.rust-lang.org/std/fs/struct.Metadata.html)."
msgstr ""
"[OsStr](https://doc.rust-lang.org/std/ffi/struct.OsStr.html)와 [Metadata]"
"(https://doc.rust-lang.org/std/fs/struct.Metadata.html)."

#: src/std_misc/file.md:3
msgid ""
"The `File` struct represents a file that has been opened (it wraps a file "
"descriptor), and gives read and/or write access to the underlying file."
msgstr ""
"`File` 구조체는 열려 있는 파일을 나타내며(파일 디스크립터를 감쌉니다), 기저 "
"파일에 대해 읽기 및/또는 쓰기 접근 권한을 제공합니다."

#: src/std_misc/file.md:6
msgid ""
"Since many things can go wrong when doing file I/O, all the `File` methods "
"return the `io::Result<T>` type, which is an alias for `Result<T, "
"io::Error>`."
msgstr ""
"파일 입출력을 수행할 때는 많은 것들이 잘못될 수 있으므로, 모든 `File` 메서드"
"는 `Result<T, io::Error>`의 별칭인 `io::Result<T>` 타입을 반환합니다."

#: src/std_misc/file.md:9
msgid ""
"This makes the failure of all I/O operations _explicit_. Thanks to this, the "
"programmer can see all the failure paths, and is encouraged to handle them "
"in a proactive manner."
msgstr ""
"이는 모든 입출력 연산의 실패를 *명시적*으로 만듭니다. 덕분에 프로그래머는 모"
"든 실패 경로를 확인할 수 있으며, 이를 적극적인 방식으로 처리하도록 권장됩니"
"다."

#: src/std_misc/file/open.md:3
msgid "The `open` function can be used to open a file in read-only mode."
msgstr "`open` 함수는 파일을 읽기 전용 모드로 여는 데 사용될 수 있습니다."

#: src/std_misc/file/open.md:5
msgid ""
"A `File` owns a resource, the file descriptor and takes care of closing the "
"file when it is `drop`ed."
msgstr ""
"`File`은 리소스인 파일 디스크립터를 소유하며, `drop`될 때 파일을 닫는 것을 책"
"임집니다."

#: src/std_misc/file/open.md:14
msgid "// Create a path to the desired file\n"
msgstr "// 원하는 파일에 대한 경로를 생성합니다\n"

#: src/std_misc/file/open.md:15
msgid "\"hello.txt\""
msgstr "\"hello.txt\""

#: src/std_misc/file/open.md:18
msgid "// Open the path in read-only mode, returns `io::Result<File>`\n"
msgstr "// 경로를 읽기 전용 모드로 엽니다. `io::Result<File>`을 반환합니다\n"

#: src/std_misc/file/open.md:20
msgid "\"couldn't open {}: {}\""
msgstr "\"{}를 열 수 없습니다: {}\""

#: src/std_misc/file/open.md:24
msgid "// Read the file contents into a string, returns `io::Result<usize>`\n"
msgstr "// 파일 내용을 문자열로 읽어옵니다. `io::Result<usize>`를 반환합니다\n"

#: src/std_misc/file/open.md:27
msgid "\"couldn't read {}: {}\""
msgstr "\"{}를 읽을 수 없습니다: {}\""

#: src/std_misc/file/open.md:28
msgid "\"{} contains:\\n{}\""
msgstr "\"{}의 내용:\\n{}\""

#: src/std_misc/file/open.md:31
msgid "// `file` goes out of scope, and the \"hello.txt\" file gets closed\n"
msgstr "// `file`이 스코프를 벗어나고, \"hello.txt\" 파일이 닫힙니다\n"

#: src/std_misc/file/open.md:35 src/std_misc/file/create.md:39
#: src/std_misc/fs.md:108
msgid "Here's the expected successful output:"
msgstr "예상되는 성공적인 출력 결과는 다음과 같습니다:"

#: src/std_misc/file/open.md:37
msgid ""
"```shell\n"
"$ echo \"Hello World!\" > hello.txt\n"
"$ rustc open.rs && ./open\n"
"hello.txt contains:\n"
"Hello World!\n"
"```"
msgstr ""
"```shell\n"
"$ echo \"Hello World!\" > hello.txt\n"
"$ rustc open.rs && ./open\n"
"hello.txt의 내용:\n"
"Hello World!\n"
"```"

#: src/std_misc/file/open.md:44
msgid ""
"(You are encouraged to test the previous example under different failure "
"conditions: `hello.txt` doesn't exist, or `hello.txt` is not readable, etc.)"
msgstr ""
"(이전 예제를 `hello.txt`가 존재하지 않거나, 읽기 권한이 없는 등 다양한 실패 "
"조건에서 테스트해 보시길 권장합니다.)"

#: src/std_misc/file/create.md:3
msgid ""
"The `create` function opens a file in write-only mode. If the file already "
"existed, the old content is destroyed. Otherwise, a new file is created."
msgstr ""
"`create` 함수는 파일을 쓰기 전용 모드로 엽니다. 파일이 이미 존재한다면 이전 "
"내용은 파괴됩니다. 그렇지 않으면 새로운 파일이 생성됩니다."

#: src/std_misc/file/create.md:9
msgid ""
"\"Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod\n"
"tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim "
"veniam,\n"
"quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo\n"
"consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse\n"
"cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat "
"non\n"
"proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n"
"\""
msgstr ""
"\"Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod\n"
"tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim "
"veniam,\n"
"quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo\n"
"consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse\n"
"cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat "
"non\n"
"proident, sunt in culpa qui officia deserunt mollit anim id est laborum.\n"
"\""

#: src/std_misc/file/create.md:22
msgid "\"lorem_ipsum.txt\""
msgstr "\"lorem_ipsum.txt\""

#: src/std_misc/file/create.md:25
msgid "// Open a file in write-only mode, returns `io::Result<File>`\n"
msgstr "// 파일을 쓰기 전용 모드로 엽니다. `io::Result<File>`을 반환합니다\n"

#: src/std_misc/file/create.md:27
msgid "\"couldn't create {}: {}\""
msgstr "\"{}를 생성할 수 없습니다: {}\""

#: src/std_misc/file/create.md:31
msgid "// Write the `LOREM_IPSUM` string to `file`, returns `io::Result<()>`\n"
msgstr ""
"// `LOREM_IPSUM` 문자열을 `file`에 씁니다. `io::Result<()>`를 반환합니다\n"

#: src/std_misc/file/create.md:33
msgid "\"couldn't write to {}: {}\""
msgstr "\"{}에 쓸 수 없습니다: {}\""

#: src/std_misc/file/create.md:34
msgid "\"successfully wrote to {}\""
msgstr "\"{}에 성공적으로 썼습니다\""

#: src/std_misc/file/create.md:54
msgid ""
"(As in the previous example, you are encouraged to test this example under "
"failure conditions.)"
msgstr ""
"(이전 예제와 마찬가지로, 이 예제를 실패 조건에서 테스트해 보시길 권장합니다.)"

#: src/std_misc/file/create.md:57
msgid ""
"The [`OpenOptions`](https://doc.rust-lang.org/std/fs/"
"struct.OpenOptions.html) struct can be used to configure how a file is "
"opened."
msgstr ""
"[`OpenOptions`](https://doc.rust-lang.org/std/fs/struct.OpenOptions.html) 구"
"조체는 파일이 열리는 방식을 구성하는 데 사용될 수 있습니다."

#: src/std_misc/file/read_lines.md:3
msgid "A naive approach"
msgstr "단순한 접근 방식"

#: src/std_misc/file/read_lines.md:5
msgid ""
"This might be a reasonable first attempt for a beginner's first "
"implementation for reading lines from a file."
msgstr ""
"이는 초보자가 파일에서 줄을 읽기 위해 처음 시도해 볼 만한 합리적인 방식일 수 "
"있습니다."

#: src/std_misc/file/read_lines.md:22
msgid ""
"Since the method `lines()` returns an iterator over the lines in the file, "
"we can also perform a map inline and collect the results, yielding a more "
"concise and fluent expression."
msgstr ""
"`lines()` 메서드가 파일의 줄들에 대한 이터레이터를 반환하므로, 인라인에서 "
"`map`을 수행하고 결과를 `collect`하여 더 간결하고 유려한 표현식을 만들 수도 "
"있습니다."

#: src/std_misc/file/read_lines.md:31
msgid "// panic on possible file-reading errors\n"
msgstr "// 발생 가능한 파일 읽기 에러에 대해 패닉을 일으킵니다\n"

#: src/std_misc/file/read_lines.md:32
msgid "// split the string into an iterator of string slices\n"
msgstr "// 문자열을 문자열 슬라이스 이터레이터로 분할합니다\n"

#: src/std_misc/file/read_lines.md:33
msgid "// make each slice into a string\n"
msgstr "// 각 슬라이스를 String으로 만듭니다\n"

#: src/std_misc/file/read_lines.md:34
msgid "// gather them together into a vector\n"
msgstr "// 이들을 벡터로 모읍니다\n"

#: src/std_misc/file/read_lines.md:38
msgid ""
"Note that in both examples above, we must convert the `&str` reference "
"returned from `lines()` to the owned type `String`, using `.to_string()` and "
"`String::from` respectively."
msgstr ""
"위의 두 예제 모두에서, `lines()`가 반환한 `&str` 참조를 `.to_string()` 또는 "
"`String::from`을 사용하여 소유형인 `String`으로 변환해야 한다는 점에 유의하세"
"요."

#: src/std_misc/file/read_lines.md:42
msgid "A more efficient approach"
msgstr "더 효율적인 접근 방식"

#: src/std_misc/file/read_lines.md:44
msgid ""
"Here we pass ownership of the open `File` to a `BufReader` struct. "
"`BufReader` uses an internal buffer to reduce intermediate allocations."
msgstr ""
"여기서는 열려 있는 `File`의 소유권을 `BufReader` 구조체로 넘깁니다. "
"`BufReader`는 내부 버퍼를 사용하여 중간 할당을 줄입니다."

#: src/std_misc/file/read_lines.md:47
msgid ""
"We also update `read_lines` to return an iterator instead of allocating new "
"`String` objects in memory for each line."
msgstr ""
"또한 각 줄마다 메모리에 새로운 `String` 객체를 할당하는 대신 이터레이터를 반"
"환하도록 `read_lines`를 업데이트합니다."

#: src/std_misc/file/read_lines.md:56
msgid "// File hosts.txt must exist in the current path\n"
msgstr "// hosts.txt 파일이 현재 경로에 존재해야 합니다\n"

#: src/std_misc/file/read_lines.md:57
msgid "\"./hosts.txt\""
msgstr "\"./hosts.txt\""

#: src/std_misc/file/read_lines.md:58
msgid "// Consumes the iterator, returns an (Optional) String\n"
msgstr "// 이터레이터를 소비하여, (선택적인) String을 반환합니다\n"

#: src/std_misc/file/read_lines.md:64
msgid ""
"// The output is wrapped in a Result to allow matching on errors.\n"
"// Returns an Iterator to the Reader of the lines of the file.\n"
msgstr ""
"// 에러에 대한 매칭이 가능하도록 출력을 `Result`로 감쌉니다.\n"
"// 파일의 각 줄을 읽어오는 이터레이터를 반환합니다.\n"

#: src/std_misc/file/read_lines.md:74
msgid "Running this program simply prints the lines individually."
msgstr "이 프로그램을 실행하면 단순히 각 줄을 개별적으로 출력합니다."

#: src/std_misc/file/read_lines.md:76
msgid ""
"```shell\n"
"$ echo -e \"127.0.0.1\\n192.168.0.1\\n\" > hosts.txt\n"
"$ rustc read_lines.rs && ./read_lines\n"
"127.0.0.1\n"
"192.168.0.1\n"
"```"
msgstr ""
"```shell\n"
"$ echo -e \"127.0.0.1\\n192.168.0.1\\n\" > hosts.txt\n"
"$ rustc read_lines.rs && ./read_lines\n"
"127.0.0.1\n"
"192.168.0.1\n"
"```"

#: src/std_misc/file/read_lines.md:83
msgid ""
"(Note that since `File::open` expects a generic `AsRef<Path>` as argument, "
"we define our generic `read_lines()` method with the same generic "
"constraint, using the `where` keyword.)"
msgstr ""
"(`File::open`이 인자로 제네릭 `AsRef<Path>`를 요구하므로, 우리의 제네릭 "
"`read_lines()` 메서드도 `where` 키워드를 사용하여 동일한 제네릭 제약 조건을 "
"정의한다는 점에 유의하세요.)"

#: src/std_misc/file/read_lines.md:86
msgid ""
"This process is more efficient than creating a `String` in memory with all "
"of the file's contents. This can especially cause performance issues when "
"working with larger files."
msgstr ""
"이 과정은 파일의 모든 내용을 메모리에 `String`으로 생성하는 것보다 효율적입니"
"다. 특히 대용량 파일을 다룰 때 메모리에 모두 올리는 방식은 성능 문제를 일으"
"킬 수 있습니다."

#: src/std_misc/process.md:3
msgid ""
"The `process::Output` struct represents the output of a finished child "
"process, and the `process::Command` struct is a process builder."
msgstr ""
"`process::Output` 구조체는 종료된 자식 프로세스의 출력을 나타내며, "
"`process::Command` 구조체는 프로세스 빌더입니다."

#: src/std_misc/process.md:10
msgid "\"rustc\""
msgstr "\"rustc\""

#: src/std_misc/process.md:11
msgid "\"--version\""
msgstr "\"--version\""

#: src/std_misc/process.md:13
msgid "\"failed to execute process: {}\""
msgstr "\"프로세스 실행 실패: {}\""

#: src/std_misc/process.md:19
msgid "\"rustc succeeded and stdout was:\\n{}\""
msgstr "\"rustc가 성공했으며 표준 출력은 다음과 같습니다:\\n{}\""

#: src/std_misc/process.md:23
msgid "\"rustc failed and stderr was:\\n{}\""
msgstr "\"rustc가 실패했으며 표준 에러는 다음과 같습니다:\\n{}\""

#: src/std_misc/process.md:28
msgid ""
"(You are encouraged to try the previous example with an incorrect flag "
"passed to `rustc`)"
msgstr ""
"(이전 예제에서 `rustc`에 잘못된 플래그를 전달하여 시도해 보시길 권장합니다.)"

#: src/std_misc/process/pipe.md:3
msgid ""
"The `std::process::Child` struct represents a child process, and exposes the "
"`stdin`, `stdout` and `stderr` handles for interaction with the underlying "
"process via pipes."
msgstr ""
"`std::process::Child` 구조체는 자식 프로세스를 나타내며, 파이프를 통해 기저 "
"프로세스와 상호작용하기 위한 `stdin`, `stdout`, `stderr` 핸들을 노출합니다."

#: src/std_misc/process/pipe.md:11
msgid "\"the quick brown fox jumps over the lazy dog\\n\""
msgstr "\"the quick brown fox jumps over the lazy dog\\n\""

#: src/std_misc/process/pipe.md:15
msgid "// Spawn the `wc` command\n"
msgstr "// `wc` 명령어를 실행(spawn)합니다\n"

#: src/std_misc/process/pipe.md:16 src/std_misc/fs.md:12 src/std_misc/fs.md:73
#: src/std_misc/ffi.md:11
msgid "\"windows\""
msgstr "\"windows\""

#: src/std_misc/process/pipe.md:17
msgid "\"powershell\""
msgstr "\"powershell\""

#: src/std_misc/process/pipe.md:18
msgid "\"-Command\""
msgstr "\"-Command\""

#: src/std_misc/process/pipe.md:18
msgid "\"$input | Measure-Object -Line -Word -Character\""
msgstr "\"$input | Measure-Object -Line -Word -Character\""

#: src/std_misc/process/pipe.md:21
msgid "\"wc\""
msgstr "\"wc\""

#: src/std_misc/process/pipe.md:27
msgid "\"couldn't spawn wc: {}\""
msgstr "\"wc를 실행할 수 없습니다: {}\""

#: src/std_misc/process/pipe.md:31
msgid ""
"// Write a string to the `stdin` of `wc`.\n"
"    //\n"
"    // `stdin` has type `Option<ChildStdin>`, but since we know this "
"instance\n"
"    // must have one, we can directly `unwrap` it.\n"
msgstr ""
"// `wc`의 표준 입력(stdin)에 문자열을 씁니다.\n"
"//\n"
"// `stdin`은 `Option<ChildStdin>` 타입이지만, 이 인스턴스에는 반드시\n"
"// 존재한다는 것을 알고 있으므로 직접 `unwrap`할 수 있습니다.\n"

#: src/std_misc/process/pipe.md:36
msgid "\"couldn't write to wc stdin: {}\""
msgstr "\"wc의 표준 입력에 쓸 수 없습니다: {}\""

#: src/std_misc/process/pipe.md:37
msgid "\"sent pangram to wc\""
msgstr "\"wc에 팬그램을 보냈습니다\""

#: src/std_misc/process/pipe.md:40
msgid ""
"// Because `stdin` does not live after the above calls, it is `drop`ed,\n"
"    // and the pipe is closed.\n"
"    //\n"
"    // This is very important, otherwise `wc` wouldn't start processing the\n"
"    // input we just sent.\n"
msgstr ""
"// 위의 호출 이후에는 `stdin`이 더 이상 살아있지 않으므로 `drop`되고,\n"
"// 파이프가 닫힙니다.\n"
"//\n"
"// 이는 매우 중요합니다. 그렇지 않으면 `wc`가 우리가 보낸 입력을\n"
"// 처리하기 시작하지 않을 것이기 때문입니다.\n"

#: src/std_misc/process/pipe.md:46
msgid ""
"// The `stdout` field also has type `Option<ChildStdout>` so must be "
"unwrapped.\n"
msgstr ""
"// `stdout` 필드도 `Option<ChildStdout>` 타입이므로 `unwrap`해야 합니다.\n"

#: src/std_misc/process/pipe.md:49
msgid "\"couldn't read wc stdout: {}\""
msgstr "\"wc의 표준 출력을 읽을 수 없습니다: {}\""

#: src/std_misc/process/pipe.md:50
msgid "\"wc responded with:\\n{}\""
msgstr "\"wc의 응답:\\n{}\""

#: src/std_misc/process/wait.md:3
msgid ""
"If you'd like to wait for a `process::Child` to finish, you must call "
"`Child::wait`, which will return a `process::ExitStatus`."
msgstr ""
"`process::Child`가 종료될 때까지 기다리려면 `Child::wait`를 호출해야 하며, 이"
"는 `process::ExitStatus`를 반환합니다."

#: src/std_misc/process/wait.md:10
msgid "\"sleep\""
msgstr "\"sleep\""

#: src/std_misc/process/wait.md:13
msgid "\"reached end of main\""
msgstr "\"메인의 끝에 도달함\""

#: src/std_misc/process/wait.md:18
msgid ""
"# `wait` keeps running for 5 seconds until the `sleep 5` command finishes\n"
msgstr "# `wait`는 `sleep 5` 명령어가 끝날 때까지 5초 동안 계속 실행됩니다\n"

#: src/std_misc/fs.md:3
msgid ""
"The `std::fs` module contains several functions that deal with the "
"filesystem."
msgstr "`std::fs` 모듈은 파일 시스템을 다루는 여러 함수들을 포함하고 있습니다."

#: src/std_misc/fs.md:10 src/std_misc/fs.md:68 src/std_misc/ffi.md:20
msgid "\"unix\""
msgstr "\"unix\""

#: src/std_misc/fs.md:15
msgid "// A simple implementation of `% cat path`\n"
msgstr "// `% cat path`를 간단히 구현한 것\n"

#: src/std_misc/fs.md:25
msgid "// A simple implementation of `% echo s > path`\n"
msgstr "// `% echo s > path`를 간단히 구현한 것\n"

#: src/std_misc/fs.md:32
msgid "// A simple implementation of `% touch path` (ignores existing files)\n"
msgstr "// `% touch path`를 간단히 구현한 것 (기존 파일은 무시함)\n"

#: src/std_misc/fs.md:42
msgid "\"`mkdir a`\""
msgstr "\"`mkdir a`\""

#: src/std_misc/fs.md:43
msgid "// Create a directory, returns `io::Result<()>`\n"
msgstr "// 디렉터리를 생성합니다. `io::Result<()>`를 반환합니다\n"

#: src/std_misc/fs.md:45 src/std_misc/fs.md:52 src/std_misc/fs.md:58
#: src/std_misc/fs.md:63 src/std_misc/fs.md:70 src/std_misc/fs.md:75
#: src/std_misc/fs.md:81 src/std_misc/fs.md:88 src/std_misc/fs.md:97
#: src/std_misc/fs.md:103
msgid "\"! {:?}\""
msgstr "\"! {:?}\""

#: src/std_misc/fs.md:49
msgid "\"`echo hello > a/b.txt`\""
msgstr "\"`echo hello > a/b.txt`\""

#: src/std_misc/fs.md:50
msgid ""
"// The previous match can be simplified using the `unwrap_or_else` method\n"
msgstr ""
"// 이전의 `match`는 `unwrap_or_else` 메서드를 사용하여 단순화될 수 있습니다\n"

#: src/std_misc/fs.md:51
msgid "\"a/b.txt\""
msgstr "\"a/b.txt\""

#: src/std_misc/fs.md:55
msgid "\"`mkdir -p a/c/d`\""
msgstr "\"`mkdir -p a/c/d`\""

#: src/std_misc/fs.md:56
msgid "// Recursively create a directory, returns `io::Result<()>`\n"
msgstr "// 디렉터리를 재귀적으로 생성합니다. `io::Result<()>`를 반환합니다\n"

#: src/std_misc/fs.md:57 src/std_misc/fs.md:102
msgid "\"a/c/d\""
msgstr "\"a/c/d\""

#: src/std_misc/fs.md:61
msgid "\"`touch a/c/e.txt`\""
msgstr "\"`touch a/c/e.txt`\""

#: src/std_misc/fs.md:62 src/std_misc/fs.md:96
msgid "\"a/c/e.txt\""
msgstr "\"a/c/e.txt\""

#: src/std_misc/fs.md:66
msgid "\"`ln -s ../b.txt a/c/b.txt`\""
msgstr "\"`ln -s ../b.txt a/c/b.txt`\""

#: src/std_misc/fs.md:67
msgid "// Create a symbolic link, returns `io::Result<()>`\n"
msgstr "// 심볼릭 링크를 생성합니다. `io::Result<()>`를 반환합니다\n"

#: src/std_misc/fs.md:69 src/std_misc/fs.md:74
msgid "\"../b.txt\""
msgstr "\"../b.txt\""

#: src/std_misc/fs.md:69 src/std_misc/fs.md:74 src/std_misc/fs.md:80
msgid "\"a/c/b.txt\""
msgstr "\"a/c/b.txt\""

#: src/std_misc/fs.md:79
msgid "\"`cat a/c/b.txt`\""
msgstr "\"`cat a/c/b.txt`\""

#: src/std_misc/fs.md:85
msgid "\"`ls a`\""
msgstr "\"`ls a`\""

#: src/std_misc/fs.md:86
msgid "// Read the contents of a directory, returns `io::Result<Vec<Path>>`\n"
msgstr "// 디렉터리의 내용을 읽습니다. `io::Result<Vec<Path>>`를 반환합니다\n"

#: src/std_misc/fs.md:94
msgid "\"`rm a/c/e.txt`\""
msgstr "\"`rm a/c/e.txt`\""

#: src/std_misc/fs.md:95
msgid "// Remove a file, returns `io::Result<()>`\n"
msgstr "// 파일을 제거합니다. `io::Result<()>`를 반환합니다\n"

#: src/std_misc/fs.md:100
msgid "\"`rmdir a/c/d`\""
msgstr "\"`rmdir a/c/d`\""

#: src/std_misc/fs.md:101
msgid "// Remove an empty directory, returns `io::Result<()>`\n"
msgstr "// 빈 디렉터리를 제거합니다. `io::Result<()>`를 반환합니다\n"

#: src/std_misc/fs.md:110
msgid ""
"```shell\n"
"$ rustc fs.rs && ./fs\n"
"`mkdir a`\n"
"`echo hello > a/b.txt`\n"
"`mkdir -p a/c/d`\n"
"`touch a/c/e.txt`\n"
"`ln -s ../b.txt a/c/b.txt`\n"
"`cat a/c/b.txt`\n"
"> hello\n"
"`ls a`\n"
"> \"a/b.txt\"\n"
"> \"a/c\"\n"
"`rm a/c/e.txt`\n"
"`rmdir a/c/d`\n"
"```"
msgstr ""
"```shell\n"
"$ rustc fs.rs && ./fs\n"
"`mkdir a`\n"
"`echo hello > a/b.txt`\n"
"`mkdir -p a/c/d`\n"
"`touch a/c/e.txt`\n"
"`ln -s ../b.txt a/c/b.txt`\n"
"`cat a/c/b.txt`\n"
"> hello\n"
"`ls a`\n"
"> \"a/b.txt\"\n"
"> \"a/c\"\n"
"`rm a/c/e.txt`\n"
"`rmdir a/c/d`\n"
"```"

#: src/std_misc/fs.md:126
msgid "And the final state of the `a` directory is:"
msgstr "`a` 디렉터리의 최종 상태는 다음과 같습니다:"

#: src/std_misc/fs.md:138
msgid "An alternative way to define the function `cat` is with `?` notation:"
msgstr "`cat` 함수를 정의하는 또 다른 방법은 `?` 표기법을 사용하는 것입니다:"

#: src/std_misc/fs.md:151
msgid "[`cfg!`](../attribute/cfg.md)"
msgstr "[`cfg!`](../attribute/cfg.md)"

#: src/std_misc/arg.md:3
msgid "Standard Library"
msgstr "표준 라이브러리"

#: src/std_misc/arg.md:5
msgid ""
"The command line arguments can be accessed using `std::env::args`, which "
"returns an iterator that yields a `String` for each argument:"
msgstr ""
"커맨드 라인 인자들은 `std::env::args`를 통해 접근할 수 있으며, 이는 각 인자"
"에 대해 `String`을 내놓는 이터레이터를 반환합니다:"

#: src/std_misc/arg.md:14
msgid "// The first argument is the path that was used to call the program.\n"
msgstr "// 첫 번째 인자는 프로그램을 호출하는 데 사용된 경로입니다.\n"

#: src/std_misc/arg.md:15
msgid "\"My path is {}.\""
msgstr "\"제 경로는 {}입니다.\""

#: src/std_misc/arg.md:17
msgid ""
"// The rest of the arguments are the passed command line parameters.\n"
"    // Call the program like this:\n"
"    //   $ ./args arg1 arg2\n"
msgstr ""
"// 나머지 인자들은 전달된 커맨드 라인 파라미터들입니다.\n"
"// 프로그램을 다음과 같이 호출해 보세요:\n"
"//   $ ./args arg1 arg2\n"

#: src/std_misc/arg.md:20
msgid "\"I got {:?} arguments: {:?}.\""
msgstr "\"{}개의 인자를 받았습니다: {:?}.\""

#: src/std_misc/arg.md:24
msgid ""
"```shell\n"
"$ ./args 1 2 3\n"
"My path is ./args.\n"
"I got 3 arguments: [\"1\", \"2\", \"3\"].\n"
"```"
msgstr ""
"```shell\n"
"$ ./args 1 2 3\n"
"제 경로는 ./args입니다.\n"
"3개의 인자를 받았습니다: [\"1\", \"2\", \"3\"].\n"
"```"

#: src/std_misc/arg.md:32
msgid ""
"Alternatively, there are numerous crates that can provide extra "
"functionality when creating command-line applications. One of the more "
"popular command line argument crates being [`clap`](https://rust-"
"cli.github.io/book/tutorial/cli-args.html#parsing-cli-arguments-with-clap)."
msgstr ""
"또는 커맨드 라인 애플리케이션을 만들 때 추가 기능을 제공하는 수많은 크레이트"
"들이 있습니다. 가장 인기 있는 커맨드 라인 인자 크레이트 중 하나는 [`clap`]"
"(https://rust-cli.github.io/book/tutorial/cli-args.html#parsing-cli-"
"arguments-with-clap)입니다."

#: src/std_misc/arg/matching.md:3
msgid "Matching can be used to parse simple arguments:"
msgstr "`match`를 사용하여 간단한 인자들을 파싱할 수 있습니다:"

#: src/std_misc/arg/matching.md:17
msgid ""
"\"usage:\n"
"match_args <string>\n"
"    Check whether given string is the answer.\n"
"match_args {{increase|decrease}} <integer>\n"
"    Increase or decrease given integer by one.\""
msgstr ""
"\"사용법:\n"
"match_args <string>\n"
"    주어진 문자열이 정답인지 확인합니다.\n"
"match_args {{increase|decrease}} <integer>\n"
"    주어진 정수를 1만큼 증가시키거나 감소시킵니다.\""

#: src/std_misc/arg/matching.md:28
msgid "// no arguments passed\n"
msgstr "// 전달된 인자가 없음\n"

#: src/std_misc/arg/matching.md:30
msgid "\"My name is 'match_args'. Try passing some arguments!\""
msgstr "\"제 이름은 'match_args'입니다. 인자를 전달해 보세요!\""

#: src/std_misc/arg/matching.md:32
msgid "// one argument passed\n"
msgstr "// 한 개의 인자가 전달됨\n"

#: src/std_misc/arg/matching.md:35
msgid "\"This is the answer!\""
msgstr "\"정답입니다!\""

#: src/std_misc/arg/matching.md:36
msgid "\"This is not the answer.\""
msgstr "\"정답이 아닙니다.\""

#: src/std_misc/arg/matching.md:39
msgid "// one command and one argument passed\n"
msgstr "// 하나의 명령어와 하나의 인자가 전달됨\n"

#: src/std_misc/arg/matching.md:43
msgid "// parse the number\n"
msgstr "// 숫자를 파싱합니다\n"

#: src/std_misc/arg/matching.md:49
msgid "\"error: second argument not an integer\""
msgstr "\"에러: 두 번째 인자가 정수가 아닙니다\""

#: src/std_misc/arg/matching.md:54
msgid "// parse the command\n"
msgstr "// 명령어를 파싱합니다\n"

#: src/std_misc/arg/matching.md:56
msgid "\"increase\""
msgstr "\"increase\""

#: src/std_misc/arg/matching.md:57
msgid "\"decrease\""
msgstr "\"decrease\""

#: src/std_misc/arg/matching.md:59
msgid "\"error: invalid command\""
msgstr "\"에러: 유효하지 않은 명령어\""

#: src/std_misc/arg/matching.md:64
msgid "// all the other cases\n"
msgstr "// 그 외의 모든 경우\n"

#: src/std_misc/arg/matching.md:66
msgid "// show a help message\n"
msgstr "// 도움말 메시지를 표시함\n"

#: src/std_misc/arg/matching.md:73
msgid ""
"If you named your program `match_args.rs` and compile it like this `rustc "
"match_args.rs`, you can execute it as follows:"
msgstr ""
"프로그램 이름을 `match_args.rs`라고 짓고 `rustc match_args.rs`와 같이 컴파일"
"했다면, 다음과 같이 실행할 수 있습니다:"

#: src/std_misc/ffi.md:3
msgid ""
"Rust provides a Foreign Function Interface (FFI) to C libraries. Foreign "
"functions must be declared inside an `extern` block annotated with a "
"`#[link]` attribute containing the name of the foreign library."
msgstr ""
"Rust는 C 라이브러리에 대한 외부 함수 인터페이스(Foreign Function Interface, "
"FFI)를 제공합니다. 외부 함수는 외부 라이브러리의 이름이 포함된 `#[link]` 속성"
"이 달린 `extern` 블록 내에 선언되어야 합니다."

#: src/std_misc/ffi.md:9
msgid "// this extern block links to the libm library\n"
msgstr "// 이 extern 블록은 libm 라이브러리에 링크됩니다\n"

#: src/std_misc/ffi.md:12
msgid "\"msvcrt\""
msgstr "\"msvcrt\""

#: src/std_misc/ffi.md:14 src/std_misc/ffi.md:23
msgid ""
"// this is a foreign function\n"
"    // that computes the square root of a single precision complex number\n"
msgstr ""
"// 이는 단정도 복소수의 제곱근을 계산하는\n"
"// 외부 함수입니다\n"

#: src/std_misc/ffi.md:21
msgid "\"m\""
msgstr "\"m\""

#: src/std_misc/ffi.md:29
msgid ""
"// Since calling foreign functions is considered unsafe,\n"
"// it's common to write safe wrappers around them.\n"
msgstr ""
"// 외부 함수를 호출하는 것은 안전하지 않은(unsafe) 것으로 간주되므로,\n"
"// 이를 감싸는 안전한 래퍼(wrapper)를 작성하는 것이 일반적입니다.\n"

#: src/std_misc/ffi.md:37
msgid "// z = -1 + 0i\n"
msgstr "// z = -1 + 0i\n"

#: src/std_misc/ffi.md:40
msgid "// calling a foreign function is an unsafe operation\n"
msgstr "// 외부 함수를 호출하는 것은 안전하지 않은(unsafe) 작업입니다\n"

#: src/std_misc/ffi.md:43
msgid "\"the square root of {:?} is {:?}\""
msgstr "\"{:?}의 제곱근은 {:?}입니다\""

#: src/std_misc/ffi.md:45
msgid "// calling safe API wrapped around unsafe operation\n"
msgstr "// unsafe 연산을 감싼 안전한 API 호출\n"

#: src/std_misc/ffi.md:46
msgid "\"cos({:?}) = {:?}\""
msgstr "\"cos({:?}) = {:?}\""

#: src/std_misc/ffi.md:48
msgid "// Minimal implementation of single precision complex numbers\n"
msgstr "// 단정밀도 복소수의 최소 구현\n"

#: src/std_misc/ffi.md:60
msgid "\"{}-{}i\""
msgstr "\"{}-{}i\""

#: src/std_misc/ffi.md:62
msgid "\"{}+{}i\""
msgstr "\"{}+{}i\""

#: src/testing.md:3
msgid ""
"Rust is a programming language that cares a lot about correctness and it "
"includes support for writing software tests within the language itself."
msgstr ""
"Rust는 올바름(correctness)을 매우 중요하게 생각하는 프로그래밍 언어이며, 언"
"어 자체에서 소프트웨어 테스트 작성을 지원합니다."

#: src/testing.md:6
msgid "Testing comes in three styles:"
msgstr "테스트는 세 가지 스타일로 제공됩니다:"

#: src/testing.md:8
msgid "[Unit](testing/unit_testing.md) testing."
msgstr "[유닛(Unit)](testing/unit_testing.md) 테스트."

#: src/testing.md:9
msgid "[Doc](testing/doc_testing.md) testing."
msgstr "[문서(Doc)](testing/doc_testing.md) 테스트."

#: src/testing.md:10
msgid "[Integration](testing/integration_testing.md) testing."
msgstr "[통합(Integration)](testing/integration_testing.md) 테스트."

#: src/testing.md:12
msgid "Also Rust has support for specifying additional dependencies for tests:"
msgstr "또한 Rust는 테스트를 위한 추가 의존성 지정을 지원합니다:"

#: src/testing.md:14
msgid "[Dev-dependencies](testing/dev_dependencies.md)"
msgstr "[개발 의존성(Dev-dependencies)](testing/dev_dependencies.md)"

#: src/testing.md:18
msgid ""
"[The Book](https://doc.rust-lang.org/book/ch11-00-testing.html) chapter on "
"testing"
msgstr ""
"테스트에 관한 [The Book](https://doc.rust-lang.org/book/ch11-00-"
"testing.html) 장"

#: src/testing.md:19
msgid ""
"[API Guidelines](https://rust-lang-nursery.github.io/api-guidelines/"
"documentation.html) on doc-testing"
msgstr ""
"문서 테스트(doc-testing)에 관한 [API 가이드라인](https://rust-lang-"
"nursery.github.io/api-guidelines/documentation.html)"

#: src/testing/unit_testing.md:3
msgid ""
"Tests are Rust functions that verify that the non-test code is functioning "
"in the expected manner. The bodies of test functions typically perform some "
"setup, run the code we want to test, then assert whether the results are "
"what we expect."
msgstr ""
"테스트는 테스트 대상 코드가 예상대로 작동하는지 확인하는 Rust 함수입니다. 테"
"스트 함수의 본문은 일반적으로 설정을 수행하고, 테스트하려는 코드를 실행한 다"
"음, 결과가 예상과 일치하는지 단언(assert)합니다."

#: src/testing/unit_testing.md:8
msgid ""
"Most unit tests go into a `tests` [mod](../mod.md) with the `#[cfg(test)]` "
"[attribute](../attribute.md). Test functions are marked with the `#[test]` "
"attribute."
msgstr ""
"대부분의 유닛 테스트는 `#[cfg(test)]` [속성](../attribute.md)이 있는 `tests` "
"[모듈](../mod.md)에 들어갑니다. 테스트 함수는 `#[test]` 속성으로 표시됩니다."

#: src/testing/unit_testing.md:11
msgid ""
"Tests fail when something in the test function [panics](../std/panic.md). "
"There are some helper [macros](../macros.md):"
msgstr ""
"테스트 함수 내에서 [패닉](../std/panic.md)이 발생하면 테스트가 실패합니다. 다"
"음과 같은 몇 가지 도우미 [매크로](../macros.md)가 있습니다:"

#: src/testing/unit_testing.md:14
msgid "`assert!(expression)` - panics if expression evaluates to `false`."
msgstr ""
"`assert!(expression)` - 표현식의 평가 결과가 `false`이면 패닉을 발생시킵니다."

#: src/testing/unit_testing.md:15
msgid ""
"`assert_eq!(left, right)` and `assert_ne!(left, right)` - testing left and "
"right expressions for equality and inequality respectively."
msgstr ""
"`assert_eq!(left, right)` 및 `assert_ne!(left, right)` - 왼쪽과 오른쪽 표현식"
"이 각각 같은지 또는 다른지를 테스트합니다."

#: src/testing/unit_testing.md:22
msgid ""
"// This is a really bad adding function, its purpose is to fail in this\n"
"// example.\n"
msgstr ""
"// 이것은 정말 형편없는 더하기 함수입니다. 이 예제에서 실패하도록 만드는 것"
"이 목적입니다.\n"

#: src/testing/unit_testing.md:32
msgid ""
"// Note this useful idiom: importing names from outer (for mod tests) "
"scope.\n"
msgstr ""
"// 이 유용한 관용구를 기억하세요: 외부 스코프(mod tests의 경우)에서 이름들을 "
"가져옵니다.\n"

#: src/testing/unit_testing.md:42
msgid ""
"// This assert would fire and test will fail.\n"
"        // Please note, that private functions can be tested too!\n"
msgstr ""
"// 이 단언(assert)은 실행될 것이고 테스트는 실패할 것입니다.\n"
"        // 참고로, 프라이빗 함수도 테스트할 수 있습니다!\n"

#: src/testing/unit_testing.md:49
msgid "Tests can be run with `cargo test`."
msgstr "테스트는 `cargo test`로 실행할 수 있습니다."

#: src/testing/unit_testing.md:73
msgid "Tests and `?`"
msgstr "테스트와 `?`"

#: src/testing/unit_testing.md:75
msgid ""
"None of the previous unit test examples had a return type. But in Rust 2018, "
"your unit tests can return `Result<()>`, which lets you use `?` in them! "
"This can make them much more concise."
msgstr ""
"이전의 유닛 테스트 예제들에는 반환 타입이 없었습니다. 하지만 Rust 2018에서는 "
"유닛 테스트가 `Result<()>`를 반환할 수 있어, 테스트 내에서 `?`를 사용할 수 있"
"습니다! 이를 통해 테스트를 훨씬 더 간결하게 만들 수 있습니다."

#: src/testing/unit_testing.md:84
msgid "\"negative floats don't have square roots\""
msgstr "\"음수 부동 소수점은 제곱근을 가질 수 없습니다\""

#: src/testing/unit_testing.md:101
msgid ""
"See [\"The Edition Guide\"](https://doc.rust-lang.org/edition-guide/"
"rust-2018/error-handling-and-panics/question-mark-in-main-and-tests.html) "
"for more details."
msgstr ""
"더 자세한 내용은 [\"The Edition Guide\"](https://doc.rust-lang.org/edition-"
"guide/rust-2018/error-handling-and-panics/question-mark-in-main-and-"
"tests.html)를 참조하세요."

#: src/testing/unit_testing.md:103
msgid "Testing panics"
msgstr "패닉 테스트"

#: src/testing/unit_testing.md:105
msgid ""
"To check functions that should panic under certain circumstances, use "
"attribute `#[should_panic]`. This attribute accepts optional parameter "
"`expected = ` with the text of the panic message. If your function can panic "
"in multiple ways, it helps make sure your test is testing the correct panic."
msgstr ""
"특정 상황에서 패닉이 발생해야 하는 함수를 확인하려면 `#[should_panic]` 속성"
"을 사용합니다. 이 속성은 선택적 파라미터 `expected = `를 받으며, 패닉 메시지"
"의 텍스트를 확인합니다. 만약 여러분의 함수가 여러 방식으로 패닉을 일으킬 수 "
"있다면, 이 파라미터는 예상한 패닉이 발생했는지 확인하는 데 도움이 됩니다."

#: src/testing/unit_testing.md:110
msgid ""
"**Note**: Rust also allows a shorthand form `#[should_panic = \"message\"]`, "
"which works exactly like `#[should_panic(expected = \"message\")]`. Both are "
"valid; the latter is more commonly used and is considered more explicit."
msgstr ""
"**참고**: Rust는 `#[should_panic = \"message\"]`와 같은 단축 형태도 허용하"
"며, 이는 `#[should_panic(expected = \"message\")]`와 정확히 똑같이 작동합니"
"다. 둘 다 유효하지만, 후자가 더 일반적으로 사용되며 더 명시적인 것으로 간주됩"
"니다."

#: src/testing/unit_testing.md:117 src/testing/doc_testing.md:46
msgid "\"Divide-by-zero error\""
msgstr "\"0으로 나누기 에러\""

#: src/testing/unit_testing.md:119 src/testing/unit_testing.md:140
#: src/testing/unit_testing.md:146
msgid "\"Divide result is zero\""
msgstr "\"나눗셈 결과가 0입니다\""

#: src/testing/unit_testing.md:146
msgid "// This also works\n"
msgstr "// 이 방식도 작동합니다\n"

#: src/testing/unit_testing.md:153
msgid "Running these tests gives us:"
msgstr "이 테스트들을 실행하면 다음과 같은 결과를 얻습니다:"

#: src/testing/unit_testing.md:173
msgid "Running specific tests"
msgstr "특정 테스트 실행하기"

#: src/testing/unit_testing.md:175
msgid ""
"To run specific tests one may specify the test name to `cargo test` command."
msgstr ""
"특정 테스트를 실행하려면 `cargo test` 명령에 테스트 이름을 지정하면 됩니다."

#: src/testing/unit_testing.md:191
msgid ""
"To run multiple tests one may specify part of a test name that matches all "
"the tests that should be run."
msgstr ""
"여러 테스트를 실행하려면 실행하려는 모든 테스트와 매칭되는 테스트 이름의 일부"
"분을 지정하면 됩니다."

#: src/testing/unit_testing.md:210
msgid "Ignoring tests"
msgstr "테스트 무시하기"

#: src/testing/unit_testing.md:212
msgid ""
"Tests can be marked with the `#[ignore]` attribute to exclude some tests. Or "
"to run them with command `cargo test -- --ignored`"
msgstr ""
"일부 테스트를 제외하기 위해 `#[ignore]` 속성을 표시할 수 있습니다. 또는 "
"`cargo test -- --ignored` 명령으로 무시된 테스트들만 실행할 수도 있습니다."

#: src/testing/doc_testing.md:3
msgid ""
"The primary way of documenting a Rust project is through annotating the "
"source code. Documentation comments are written in [CommonMark Markdown "
"specification](https://commonmark.org/) and support code blocks in them. "
"Rust takes care about correctness, so these code blocks are compiled and "
"used as documentation tests."
msgstr ""
"Rust 프로젝트를 문서화하는 기본 방법은 소스 코드에 주석을 다는 것입니다. 문서"
"화 주석은 [CommonMark Markdown 명세](https://commonmark.org/)로 작성되며 코"
"드 블록을 지원합니다. Rust는 올바름(correctness)을 중요하게 생각하므로, 이러"
"한 코드 블록들은 컴파일되어 문서 테스트(documentation tests)로 사용됩니다."

#: src/testing/doc_testing.md:10
msgid ""
"/// First line is a short summary describing function.\n"
"///\n"
"/// The next lines present detailed documentation. Code blocks start with\n"
"/// triple backquotes and have implicit `fn main()` inside\n"
"/// and `extern crate <cratename>`. Assume we're testing a `playground` "
"library\n"
"/// crate or using the Playground's Test action:\n"
"///\n"
"/// ```\n"
"/// let result = playground::add(2, 3);\n"
"/// assert_eq!(result, 5);\n"
"/// ```\n"
msgstr ""
"/// 첫 번째 줄은 함수를 설명하는 짧은 요약입니다.\n"
"///\n"
"/// 다음 줄들은 상세한 문서화를 보여줍니다. 코드 블록은 백틱 세 개로 시작하"
"며,\n"
"/// 내부적으로 암시적인 `fn main()`과 `extern crate <cratename>`을 가집니"
"다.\n"
"/// `playground` 라이브러리 크레이트를 테스트하거나 플레이그라운드의\n"
"/// Test 액션을 사용하는 예시라고 가정해 봅시다:\n"
"///\n"
"/// ```\n"
"/// let result = playground::add(2, 3);\n"
"/// assert_eq!(result, 5);\n"
"/// ```\n"

#: src/testing/doc_testing.md:24
msgid ""
"/// Usually doc comments may include sections \"Examples\", \"Panics\" and "
"\"Failures\".\n"
"///\n"
"/// The next function divides two numbers.\n"
"///\n"
"/// # Examples\n"
"///\n"
"/// ```\n"
"/// let result = playground::div(10, 2);\n"
"/// assert_eq!(result, 5);\n"
"/// ```\n"
"///\n"
"/// # Panics\n"
"///\n"
"/// The function panics if the second argument is zero.\n"
"///\n"
"/// ```rust,should_panic\n"
"/// // panics on division by zero\n"
"/// playground::div(10, 0);\n"
"/// ```\n"
msgstr ""
"/// 일반적으로 문서 주석에는 \"Examples\", \"Panics\", \"Failures\" 섹션이 포"
"함될 수 있습니다.\n"
"///\n"
"/// 다음 함수는 두 수를 나눕니다.\n"
"///\n"
"/// # Examples\n"
"///\n"
"/// ```\n"
"/// let result = playground::div(10, 2);\n"
"/// assert_eq!(result, 5);\n"
"/// ```\n"
"///\n"
"/// # Panics\n"
"///\n"
"/// 두 번째 인자가 0이면 함수가 패닉을 발생시킵니다.\n"
"///\n"
"/// ```rust,should_panic\n"
"/// // 0으로 나누기 시 패닉 발생\n"
"/// playground::div(10, 0);\n"
"/// ```\n"

#: src/testing/doc_testing.md:53
msgid ""
"Code blocks in documentation are automatically tested when running the "
"regular `cargo test` command:"
msgstr ""
"문서 내의 코드 블록은 일반적인 `cargo test` 명령을 실행할 때 자동으로 테스트"
"됩니다:"

#: src/testing/doc_testing.md:72
msgid "Motivation behind documentation tests"
msgstr "문서 테스트의 의도"

#: src/testing/doc_testing.md:74
msgid ""
"The main purpose of documentation tests is to serve as examples that "
"exercise the functionality, which is one of the most important [guidelines]"
"(https://rust-lang-nursery.github.io/api-guidelines/"
"documentation.html#examples-use--not-try-not-unwrap-c-question-mark). It "
"allows using examples from docs as complete code snippets. But using `?` "
"makes compilation fail since `main` returns `unit`. The ability to hide some "
"source lines from documentation comes to the rescue: one may write `fn "
"try_main() -> Result<(), ErrorType>`, hide it and `unwrap` it in hidden "
"`main`. Sounds complicated? Here's an example:"
msgstr ""
"문서 테스트의 주된 목적은 기능을 실행해보는 예시로서의 역할을 하는 것이며, 이"
"는 가장 중요한 [가이드라인](https://rust-lang-nursery.github.io/api-"
"guidelines/documentation.html#examples-use--not-try-not-unwrap-c-question-"
"mark) 중 하나입니다. 이를 통해 문서의 예시를 완전한 코드 스니펫으로 사용할 "
"수 있습니다. 하지만 `main`이 유닛 타입(`unit`)을 반환하기 때문에 `?`를 사용하"
"면 컴파일에 실패합니다. 이때 문서에서 일부 소스 라인을 숨길 수 있는 기능이 도"
"움이 됩니다. `fn try_main() -> Result<(), ErrorType>`을 작성하고, 이를 숨긴 "
"뒤 숨겨진 `main`에서 `unwrap` 할 수 있습니다. 복잡하게 들리나요? 여기 예시가 "
"있습니다:"

#: src/testing/doc_testing.md:83
msgid ""
"/// Using hidden `try_main` in doc tests.\n"
"///\n"
"/// ```\n"
"/// # // hidden lines start with `#` symbol, but they're still compilable!\n"
"/// # fn try_main() -> Result<(), String> { // line that wraps the body "
"shown in doc\n"
"/// let res = playground::try_div(10, 2)?;\n"
"/// # Ok(()) // returning from try_main\n"
"/// # }\n"
"/// # fn main() { // starting main that'll unwrap()\n"
"/// #    try_main().unwrap(); // calling try_main and unwrapping\n"
"/// #                         // so that test will panic in case of error\n"
"/// # }\n"
"/// ```\n"
msgstr ""
"/// 문서 테스트에서 숨겨진 `try_main` 사용하기.\n"
"///\n"
"/// ```\n"
"/// # // `#` 기호로 시작하는 줄은 숨겨지지만, 여전히 컴파일 가능합니다!\n"
"/// # fn try_main() -> Result<(), String> { // 문서에 보여지는 본문을 감싸는 "
"줄\n"
"/// let res = playground::try_div(10, 2)?;\n"
"/// # Ok(()) // try_main에서 반환\n"
"/// # }\n"
"/// # fn main() { // unwrap()을 호출할 main 시작\n"
"/// #    try_main().unwrap(); // try_main을 호출하고 unwrap하여\n"
"/// #                         // 에러 발생 시 테스트가 패닉을 일으키도록 함\n"
"/// # }\n"
"/// ```\n"

#: src/testing/doc_testing.md:98
msgid "\"Divide-by-zero\""
msgstr "\"0으로 나누기\""

#: src/testing/doc_testing.md:107
msgid ""
"[RFC505](https://github.com/rust-lang/rfcs/blob/master/text/0505-api-comment-"
"conventions.md) on documentation style"
msgstr ""
"문서 스타일에 관한 [RFC505](https://github.com/rust-lang/rfcs/blob/master/"
"text/0505-api-comment-conventions.md)"

#: src/testing/doc_testing.md:108
msgid ""
"[API Guidelines](https://rust-lang-nursery.github.io/api-guidelines/"
"documentation.html) on documentation guidelines"
msgstr ""
"문서 가이드라인에 관한 [API 가이드라인](https://rust-lang-nursery.github.io/"
"api-guidelines/documentation.html)"

#: src/testing/integration_testing.md:3
msgid ""
"[Unit tests](unit_testing.md) are testing one module in isolation at a time: "
"they're small and can test private code. Integration tests are external to "
"your crate and use only its public interface in the same way any other code "
"would. Their purpose is to test that many parts of your library work "
"correctly together."
msgstr ""
"[유닛 테스트](unit_testing.md)는 한 번에 하나의 모듈을 격리하여 테스트합니"
"다. 유닛 테스트는 크기가 작고 프라이빗 코드도 테스트할 수 있습니다. 통합 테스"
"트는 크레이트 외부에 존재하며, 다른 코드와 마찬가지로 공개(public) 인터페이스"
"만 사용합니다. 통합 테스트의 목적은 라이브러리의 여러 부분이 함께 올바르게 작"
"동하는지 테스트하는 것입니다."

#: src/testing/integration_testing.md:8
msgid "Cargo looks for integration tests in `tests` directory next to `src`."
msgstr "Cargo는 `src` 옆의 `tests` 디렉터리에서 통합 테스트를 찾습니다."

#: src/testing/integration_testing.md:10 src/testing/dev_dependencies.md:17
msgid "File `src/lib.rs`:"
msgstr "`src/lib.rs` 파일:"

#: src/testing/integration_testing.md:13
msgid "// Define this in a crate called `adder`.\n"
msgstr "// `adder`라는 이름의 크레이트에 이를 정의합니다.\n"

#: src/testing/integration_testing.md:19
msgid "File with test: `tests/integration_test.rs`:"
msgstr "테스트 파일: `tests/integration_test.rs`:"

#: src/testing/integration_testing.md:28
msgid "Running tests with `cargo test` command:"
msgstr "`cargo test` 명령으로 테스트 실행하기:"

#: src/testing/integration_testing.md:50
msgid ""
"Each Rust source file in the `tests` directory is compiled as a separate "
"crate. In order to share some code between integration tests we can make a "
"module with public functions, importing and using it within tests."
msgstr ""
"통합 테스트 간에 일부 코드를 공유하기 위해 공개 함수가 있는 모듈을 만들고, 이"
"를 테스트 내에서 가져와 사용할 수 있습니다."

#: src/testing/integration_testing.md:54
msgid "File `tests/common/mod.rs`:"
msgstr "`tests/common/mod.rs` 파일:"

#: src/testing/integration_testing.md:58
msgid ""
"// some setup code, like creating required files/directories, starting\n"
"    // servers, etc.\n"
msgstr "// 필요한 파일/디렉터리 생성, 서버 시작 등과 같은 일부 설정 코드\n"

#: src/testing/integration_testing.md:63
msgid "File with test: `tests/integration_test.rs`"
msgstr "테스트 파일: `tests/integration_test.rs`"

#: src/testing/integration_testing.md:66
msgid "// importing common module.\n"
msgstr "// common 모듈 가져오기.\n"

#: src/testing/integration_testing.md:71
msgid "// using common code.\n"
msgstr "// 공통 코드 사용하기.\n"

#: src/testing/integration_testing.md:77
msgid ""
"Creating the module as `tests/common.rs` also works, but is not recommended "
"because the test runner will treat the file as a test crate and try to run "
"tests inside it."
msgstr ""
"`tests/common.rs`로 모듈을 만드는 것도 가능하지만, 테스트 러너가 이 파일을 테"
"스트 크레이트로 취급하여 내부의 테스트를 실행하려 하므로 권장되지 않습니다."

#: src/testing/dev_dependencies.md:1
msgid "Development dependencies"
msgstr "개발 의존성"

#: src/testing/dev_dependencies.md:3
msgid ""
"Sometimes there is a need to have dependencies for tests (or examples, or "
"benchmarks) only. Such dependencies are added to `Cargo.toml` in the `[dev-"
"dependencies]` section. These dependencies are not propagated to other "
"packages which depend on this package."
msgstr ""
"가끔 테스트(또는 예제, 벤치마크)만을 위한 의존성이 필요할 때가 있습니다. 이러"
"한 의존성은 `Cargo.toml`의 `[dev-dependencies]` 섹션에 추가됩니다. 이 의존성"
"들은 이 패키지에 의존하는 다른 패키지들로는 전파되지 않습니다."

#: src/testing/dev_dependencies.md:8
msgid ""
"One such example is [`pretty_assertions`](https://docs.rs/pretty_assertions/"
"1.0.0/pretty_assertions/index.html), which extends standard `assert_eq!` and "
"`assert_ne!` macros, to provide colorful diff. File `Cargo.toml`:"
msgstr ""
"그러한 예 중 하나로 표준 `assert_eq!` 및 `assert_ne!` 매크로를 확장하여 색상"
"화된 diff를 제공하는 [`pretty_assertions`](https://docs.rs/pretty_assertions/"
"1.0.0/pretty_assertions/index.html)가 있습니다. `Cargo.toml` 파일:"

#: src/testing/dev_dependencies.md:11
msgid ""
"```toml\n"
"# standard crate data is left out\n"
"[dev-dependencies]\n"
"pretty_assertions = \"1\"\n"
"```"
msgstr ""
"```toml\n"
"# 표준 크레이트 데이터는 생략되었습니다\n"
"[dev-dependencies]\n"
"pretty_assertions = \"1\"\n"
"```"

#: src/testing/dev_dependencies.md:27
msgid "// crate for test-only use. Cannot be used in non-test code.\n"
msgstr ""
"// 테스트 전용으로만 사용되는 크레이트입니다. 테스트가 아닌 코드에서는 사용"
"할 수 없습니다.\n"

#: src/testing/dev_dependencies.md:38
msgid ""
"[Cargo](http://doc.crates.io/specifying-dependencies.html) docs on "
"specifying dependencies."
msgstr ""
"의존성 지정에 관한 [Cargo](http://doc.crates.io/specifying-"
"dependencies.html) 문서."

#: src/unsafe.md:3
msgid ""
"As an introduction to this section, to borrow from [the official docs]"
"(https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html), \"one should try "
"to minimize the amount of unsafe code in a code base.\" With that in mind, "
"let's get started! Unsafe annotations in Rust are used to bypass protections "
"put in place by the compiler; specifically, there are four primary things "
"that unsafe is used for:"
msgstr ""
"이 섹션을 시작하며 [공식 문서](https://doc.rust-lang.org/book/ch19-01-unsafe-"
"rust.html)의 말을 빌리자면, \"코드베이스에서 unsafe 코드의 양을 최소화하도록 "
"노력해야 합니다.\" 이 점을 염두에 두고 시작해 봅시다! Rust에서 Unsafe 어노테"
"이션은 컴파일러가 제공하는 보호 기능을 우회하는 데 사용됩니다. 구체적으로, "
"unsafe는 다음과 같은 네 가지 주요 작업에 사용됩니다:"

#: src/unsafe.md:9
msgid "dereferencing raw pointers"
msgstr "raw 포인터 역참조하기"

#: src/unsafe.md:10
msgid ""
"calling functions or methods which are `unsafe` (including calling a "
"function over FFI, see [a previous chapter](std_misc/ffi.md) of the book)"
msgstr ""
"`unsafe` 함수나 메서드 호출하기 (FFI를 통한 함수 호출 포함, 이 책의 [이전 장]"
"(std_misc/ffi.md) 참조)"

#: src/unsafe.md:12
msgid "accessing or modifying static mutable variables"
msgstr "정적 가변(static mutable) 변수에 접근하거나 수정하기"

#: src/unsafe.md:13
msgid "implementing unsafe traits"
msgstr "unsafe 트레이트 구현하기"

#: src/unsafe.md:15
msgid "Raw Pointers"
msgstr "Raw 포인터"

#: src/unsafe.md:17
msgid ""
"Raw pointers `*` and references `&T` function similarly, but references are "
"always safe because they are guaranteed to point to valid data due to the "
"borrow checker. Dereferencing a raw pointer can only be done through an "
"unsafe block."
msgstr ""
"Raw 포인터 `*`와 참조 `&T`는 비슷하게 작동하지만, 참조는 빌림 검사기(borrow "
"checker) 덕분에 항상 유효한 데이터를 가리킨다는 것이 보장되므로 항상 안전합니"
"다. Raw 포인터의 역참조는 unsafe 블록을 통해서만 수행될 수 있습니다."

#: src/unsafe.md:32
msgid "Calling Unsafe Functions"
msgstr "Unsafe 함수 호출하기"

#: src/unsafe.md:34
msgid ""
"Some functions can be declared as `unsafe`, meaning it is the programmer's "
"responsibility to ensure correctness instead of the compiler's. One example "
"of this is [`std::slice::from_raw_parts`](https://doc.rust-lang.org/std/"
"slice/fn.from_raw_parts.html) which will create a slice given a pointer to "
"the first element and a length."
msgstr ""
"일부 함수는 `unsafe`로 선언될 수 있는데, 이는 컴파일러 대신 프로그래머가 올바"
"름을 보장해야 할 책임이 있음을 의미합니다. 그 예로 첫 번째 요소에 대한 포인터"
"와 길이를 받아 슬라이스를 생성하는 [`std::slice::from_raw_parts`](https://"
"doc.rust-lang.org/std/slice/fn.from_raw_parts.html)가 있습니다."

#: src/unsafe.md:56
msgid ""
"For `slice::from_raw_parts`, one of the assumptions which _must_ be upheld "
"is that the pointer passed in points to valid memory and that the memory "
"pointed to is of the correct type. If these invariants aren't upheld then "
"the program's behaviour is undefined and there is no knowing what will "
"happen."
msgstr ""
"`slice::from_raw_parts`의 경우, 반드시 지켜져야 하는 가정 중 하나는 전달된 포"
"인터가 유효한 메모리를 가리키고 가리키는 메모리가 올바른 타입이어야 한다는 것"
"입니다. 이러한 불변성(invariant)이 지켜지지 않으면 프로그램의 동작은 정의되"
"지 않으며 어떤 일이 일어날지 알 수 없습니다."

#: src/unsafe/asm.md:3
msgid ""
"Rust provides support for inline assembly via the `asm!` macro. It can be "
"used to embed handwritten assembly in the assembly output generated by the "
"compiler. Generally this should not be necessary, but might be where the "
"required performance or timing cannot be otherwise achieved. Accessing low "
"level hardware primitives, e.g. in kernel code, may also demand this "
"functionality."
msgstr ""
"Rust는 `asm!` 매크로를 통해 인라인 어셈블리를 지원합니다. 이를 통해 컴파일러"
"가 생성하는 어셈블리 출력에 수기로 작성한 어셈블리를 삽입할 수 있습니다. 일반"
"적으로 이는 필요하지 않지만, 다른 방법으로는 필요한 성능이나 타이밍을 달성할 "
"수 없는 경우에 유용할 수 있습니다. 커널 코드와 같은 저수준 하드웨어 프리미티"
"브에 접근하는 경우에도 이 기능이 필요할 수 있습니다."

#: src/unsafe/asm.md:8
msgid ""
"**Note**: the examples here are given in x86/x86-64 assembly, but other "
"architectures are also supported."
msgstr ""
"**참고**: 여기의 예제들은 x86/x86-64 어셈블리로 제공되지만, 다른 아키텍처도 "
"지원됩니다."

#: src/unsafe/asm.md:10
msgid "Inline assembly is currently supported on the following architectures:"
msgstr "인라인 어셈블리는 현재 다음 아키텍처에서 지원됩니다:"

#: src/unsafe/asm.md:12
msgid "x86 and x86-64"
msgstr "x86 및 x86-64"

#: src/unsafe/asm.md:13
msgid "ARM"
msgstr "ARM"

#: src/unsafe/asm.md:14
msgid "AArch64"
msgstr "AArch64"

#: src/unsafe/asm.md:15
msgid "RISC-V"
msgstr "RISC-V"

#: src/unsafe/asm.md:17
msgid "Basic usage"
msgstr "기본 사용법"

#: src/unsafe/asm.md:19
msgid "Let us start with the simplest possible example:"
msgstr "가장 간단한 예제부터 시작해 봅시다:"

#: src/unsafe/asm.md:22 src/unsafe/asm.md:42 src/unsafe/asm.md:69
#: src/unsafe/asm.md:107 src/unsafe/asm.md:124 src/unsafe/asm.md:149
#: src/unsafe/asm.md:183 src/unsafe/asm.md:204 src/unsafe/asm.md:221
#: src/unsafe/asm.md:260 src/unsafe/asm.md:296 src/unsafe/asm.md:312
#: src/unsafe/asm.md:338 src/unsafe/asm.md:376 src/unsafe/asm.md:403
#: src/unsafe/asm.md:427 src/unsafe/asm.md:465
msgid "\"x86_64\""
msgstr "\"x86_64\""

#: src/unsafe/asm.md:26
msgid "\"nop\""
msgstr "\"nop\""

#: src/unsafe/asm.md:31
msgid ""
"This will insert a NOP (no operation) instruction into the assembly "
"generated by the compiler. Note that all `asm!` invocations have to be "
"inside an `unsafe` block, as they could insert arbitrary instructions and "
"break various invariants. The instructions to be inserted are listed in the "
"first argument of the `asm!` macro as a string literal."
msgstr ""
"이 코드는 컴파일러가 생성한 어셈블리에 NOP (no operation) 명령어를 삽입합니"
"다. `asm!` 호출은 임의의 명령어를 삽입하여 다양한 불변성을 깰 수 있으므로 모"
"두 `unsafe` 블록 안에 있어야 한다는 점에 유의하세요. 삽입할 명령어는 `asm!` "
"매크로의 첫 번째 인자에 문자열 리터럴로 나열됩니다."

#: src/unsafe/asm.md:36
msgid "Inputs and outputs"
msgstr "입력과 출력"

#: src/unsafe/asm.md:38
msgid ""
"Now inserting an instruction that does nothing is rather boring. Let us do "
"something that actually acts on data:"
msgstr ""
"아무것도 하지 않는 명령어를 넣는 것은 꽤 지루합니다. 실제로 데이터에 작용하"
"는 무언가를 해봅시다:"

#: src/unsafe/asm.md:47
msgid "\"mov {}, 5\""
msgstr "\"mov {}, 5\""

#: src/unsafe/asm.md:53
msgid ""
"This will write the value `5` into the `u64` variable `x`. You can see that "
"the string literal we use to specify instructions is actually a template "
"string. It is governed by the same rules as Rust [format strings](https://"
"doc.rust-lang.org/std/fmt/#syntax). The arguments that are inserted into the "
"template however look a bit different than you may be familiar with. First "
"we need to specify if the variable is an input or an output of the inline "
"assembly. In this case it is an output. We declared this by writing `out`. "
"We also need to specify in what kind of register the assembly expects the "
"variable. In this case we put it in an arbitrary general purpose register by "
"specifying `reg`. The compiler will choose an appropriate register to insert "
"into the template and will read the variable from there after the inline "
"assembly finishes executing."
msgstr ""
"이 코드는 값 `5`를 `u64` 변수 `x`에 씁니다. 명령어를 지정하는 데 사용하는 문"
"자열 리터럴이 실제로는 템플릿 문자열이라는 것을 알 수 있습니다. 이는 Rust [형"
"식 문자열](https://doc.rust-lang.org/std/fmt/#syntax)과 동일한 규칙의 적용을 "
"받습니다. 하지만 템플릿에 삽입되는 인자들은 여러분에게 익숙한 것과는 조금 달"
"라 보일 수 있습니다. 먼저 변수가 인라인 어셈블리의 입력인지 출력인지를 지정해"
"야 합니다. 이 경우에는 출력입니다. 우리는 `out`을 작성하여 이를 선언했습니"
"다. 또한 어셈블리가 변수를 어떤 종류의 레지스터에 두기를 기대하는지도 지정해"
"야 합니다. 이 경우에는 `reg`를 지정하여 임의의 범용 레지스터에 넣었습니다. 컴"
"파일러는 템플릿에 삽입할 적절한 레지스터를 선택하고, 인라인 어셈블리 실행이 "
"끝난 후 해당 레지스터에서 변수를 읽어올 것입니다."

#: src/unsafe/asm.md:66
msgid "Let us see another example that also uses an input:"
msgstr "입력을 사용하는 또 다른 예제를 살펴봅시다:"

#: src/unsafe/asm.md:76
msgid "\"mov {0}, {1}\""
msgstr "\"mov {0}, {1}\""

#: src/unsafe/asm.md:77 src/unsafe/asm.md:112 src/unsafe/asm.md:130
msgid "\"add {0}, 5\""
msgstr "\"add {0}, 5\""

#: src/unsafe/asm.md:86
msgid ""
"This will add `5` to the input in variable `i` and write the result to "
"variable `o`. The particular way this assembly does this is first copying "
"the value from `i` to the output, and then adding `5` to it."
msgstr ""
"이 코드는 변수 `i`의 입력에 `5`를 더하고 그 결과를 변수 `o`에 씁니다. 이 어셈"
"블리가 이를 수행하는 구체적인 방식은 먼저 `i`의 값을 출력으로 복사한 다음, 거"
"기에 `5`를 더하는 것입니다."

#: src/unsafe/asm.md:90
msgid "The example shows a few things:"
msgstr "이 예제는 몇 가지를 보여줍니다:"

#: src/unsafe/asm.md:92
msgid ""
"First, we can see that `asm!` allows multiple template string arguments; "
"each one is treated as a separate line of assembly code, as if they were all "
"joined together with newlines between them. This makes it easy to format "
"assembly code."
msgstr ""
"첫째, `asm!`이 여러 템플릿 문자열 인자를 허용한다는 것을 알 수 있습니다. 각각"
"은 별도의 어셈블리 코드 줄로 처리되며, 마치 줄바꿈으로 모두 연결된 것처럼 작"
"동합니다. 이를 통해 어셈블리 코드를 쉽게 포맷팅할 수 있습니다."

#: src/unsafe/asm.md:97
msgid ""
"Second, we can see that inputs are declared by writing `in` instead of `out`."
msgstr ""
"둘째, `out` 대신 `in`을 작성하여 입력을 선언한다는 것을 알 수 있습니다."

#: src/unsafe/asm.md:99
msgid ""
"Third, we can see that we can specify an argument number, or name as in any "
"format string. For inline assembly templates this is particularly useful as "
"arguments are often used more than once. For more complex inline assembly "
"using this facility is generally recommended, as it improves readability, "
"and allows reordering instructions without changing the argument order."
msgstr ""
"셋째, 다른 형식 문자열에서처럼 인자 번호나 이름을 지정할 수 있음을 알 수 있습"
"니다. 인라인 어셈블리 템플릿에서는 인자가 한 번 이상 사용되는 경우가 많기 때"
"문에 이 기능이 특히 유용합니다. 복잡한 인라인 어셈블리의 경우 이 기능을 사용"
"하는 것이 일반적으로 권장되는데, 가독성을 높이고 인자 순서를 변경하지 않고도 "
"명령어를 재배치할 수 있게 해주기 때문입니다."

#: src/unsafe/asm.md:104
msgid "We can further refine the above example to avoid the `mov` instruction:"
msgstr "위의 예제를 더 개선하여 `mov` 명령어를 피할 수 있습니다:"

#: src/unsafe/asm.md:118
msgid ""
"We can see that `inout` is used to specify an argument that is both input "
"and output. This is different from specifying an input and output separately "
"in that it is guaranteed to assign both to the same register."
msgstr ""
"`inout`이 입력과 출력 모두로 사용되는 인자를 지정하는 데 사용됨을 알 수 있습"
"니다. 이는 입력과 출력을 따로 지정하는 것과 다른데, `inout`은 두 경우 모두 동"
"일한 레지스터에 할당됨을 보장하기 때문입니다."

#: src/unsafe/asm.md:121
msgid ""
"It is also possible to specify different variables for the input and output "
"parts of an `inout` operand:"
msgstr ""
"`inout` 피연산자의 입력과 출력 부분에 대해 서로 다른 변수를 지정하는 것도 가"
"능합니다:"

#: src/unsafe/asm.md:136
msgid "Late output operands"
msgstr "늦은(Late) 출력 피연산자"

#: src/unsafe/asm.md:85
msgid ""
"The Rust compiler is conservative with its allocation of operands. It is "
"assumed that an `out` can be written at any time, and can therefore share "
"its location with any other argument. However, to guarantee that the "
"compiler will not use the same register for another argument because it is "
"still required, use `&mut` operands:"
msgstr ""
"Rust 컴파일러는 피연산자 할당에 보수적입니다. `out`은 언제든지 쓰일 수 있다"
"고 가정되며, 따라서 다른 인자와 위치를 공유할 수 있습니다. 하지만 컴파일러"
"가 여전히 필요하다는 이유로 다른 인자에 같은 레지스터를 사용하지 않도록 보장"
"하려면 `&mut` 피연산자를 사용하세요:"

#: src/unsafe/asm.md:146
msgid ""
"Here is an example where `inlateout` _cannot_ be used in `release` mode or "
"other optimized cases:"
msgstr ""
"`release` 모드나 기타 최적화된 경우에 `inlateout`을 사용할 수 _없는_ 예시는 "
"다음과 같습니다:"

#: src/unsafe/asm.md:157 src/unsafe/asm.md:189 src/unsafe/asm.md:472
msgid "\"add {0}, {1}\""
msgstr "\"add {0}, {1}\""

#: src/unsafe/asm.md:158
msgid "\"add {0}, {2}\""
msgstr "\"add {0}, {2}\""

#: src/unsafe/asm.md:168
msgid ""
"In unoptimized cases (e.g. `Debug` mode), replacing `inout(reg) a` with "
"`inlateout(reg) a` in the above example can continue to give the expected "
"result. However, with `release` mode or other optimized cases, using "
"`inlateout(reg) a` can instead lead to the final value `a = 16`, causing the "
"assertion to fail."
msgstr ""
"최적화되지 않은 경우(예: `Debug` 모드), 위 예제에서 `inout(reg) a`를 "
"`inlateout(reg) a`로 대체해도 계속해서 예상된 결과를 얻을 수 있습니다. 그러"
"나 `release` 모드나 기타 최적화된 경우에는 `inlateout(reg) a`를 사용하면 최"
"종 값이 `a = 16`이 되어 단언(assertion)이 실패할 수 있습니다."

#: src/unsafe/asm.md:173
msgid ""
"This is because in optimized cases, the compiler is free to allocate the "
"same register for inputs `b` and `c` since it knows that they have the same "
"value. Furthermore, when `inlateout` is used, `a` and `c` could be allocated "
"to the same register, in which case the first `add` instruction would "
"overwrite the initial load from variable `c`. This is in contrast to how "
"using `inout(reg) a` ensures a separate register is allocated for `a`."
msgstr ""
"이는 최적화된 경우 컴파일러가 입력 `b`와 `c`에 대해 동일한 값을 가지고 있음"
"을 알고 있으므로 동일한 레지스터를 할당할 수 있기 때문입니다. 또한 "
"`inlateout`이 사용될 때 `a`와 `c`가 동일한 레지스터에 할당될 수 있는데, 이 경"
"우 첫 번째 `add` 명령어가 변수 `c`로부터의 초기 로드 값을 덮어쓰게 됩니다. 이"
"는 `inout(reg) a`를 사용하여 `a`에 대해 별도의 레지스터가 할당되도록 보장하"
"는 것과 대조적입니다."

#: src/unsafe/asm.md:179
msgid ""
"However, the following example can use `inlateout` since the output is only "
"modified after all input registers have been read:"
msgstr ""
"하지만 다음 예제에서는 모든 입력 레지스터를 읽은 후에만 출력이 수정되므로 "
"`inlateout`을 사용할 수 있습니다:"

#: src/unsafe/asm.md:195
msgid ""
"As you can see, this assembly fragment will still work correctly if `a` and "
"`b` are assigned to the same register."
msgstr ""
"보시다시피, `a`와 `b`가 동일한 레지스터에 할당되더라도 이 어셈블리 조각은 여"
"전히 올바르게 작동할 것입니다."

#: src/unsafe/asm.md:197
msgid "Explicit register operands"
msgstr "명시적 레지스터 피연산자"

#: src/unsafe/asm.md:199
msgid ""
"Some instructions require that the operands be in a specific register. "
"Therefore, Rust inline assembly provides some more specific constraint "
"specifiers. While `reg` is generally available on any architecture, explicit "
"registers are highly architecture specific. E.g. for x86 the general purpose "
"registers `eax`, `ebx`, `ecx`, `edx`, `ebp`, `esi`, and `edi` among others "
"can be addressed by their name."
msgstr ""
"일부 명령어는 피연산자가 특정 레지스터에 있어야 함을 요구합니다. 따라서 Rust "
"인라인 어셈블리는 몇 가지 더 구체적인 제약 지정자를 제공합니다. `reg`는 일반"
"적으로 모든 아키텍처에서 사용할 수 있지만, 명시적 레지스터는 아키텍처에 따라 "
"매우 다릅니다. 예를 들어 x86의 경우 `eax`, `ebx`, `ecx`, `edx`, `ebp`, "
"`esi`, `edi` 등의 범용 레지스터를 이름으로 지정할 수 있습니다."

#: src/unsafe/asm.md:209
msgid "\"out 0x64, eax\""
msgstr "\"out 0x64, eax\""

#: src/unsafe/asm.md:209 src/unsafe/asm.md:285
msgid "\"eax\""
msgstr "\"eax\""

#: src/unsafe/asm.md:214
msgid ""
"In this example we call the `out` instruction to output the content of the "
"`cmd` variable to port `0x64`. Since the `out` instruction only accepts "
"`eax` (and its sub registers) as operand we had to use the `eax` constraint "
"specifier."
msgstr ""
"이 예제에서는 `out` 명령어를 호출하여 `cmd` 변수의 내용을 포트 `0x64`로 출력"
"합니다. `out` 명령어는 `eax` (및 그 하위 레지스터)만을 피연산자로 받아들이므"
"로 `eax` 제약 지정자를 사용해야 했습니다."

#: src/unsafe/asm.md:216
msgid ""
"**Note**: unlike other operand types, explicit register operands cannot be "
"used in the template string: you can't use `{}` and should write the "
"register name directly instead. Also, they must appear at the end of the "
"operand list after all other operand types."
msgstr ""
"**참고**: 다른 피연산자 타입과 달리 명시적 레지스터 피연산자는 템플릿 문자열"
"에서 사용할 수 없습니다. `{}`를 사용할 수 없으며 대신 레지스터 이름을 직접 작"
"성해야 합니다. 또한 다른 모든 피연산자 타입 뒤에 피연산자 목록의 마지막에 나"
"타나야 합니다."

#: src/unsafe/asm.md:218
msgid "Consider this example which uses the x86 `mul` instruction:"
msgstr "x86 `mul` 명령어를 사용하는 이 예제를 살펴보세요:"

#: src/unsafe/asm.md:230
msgid ""
"// The x86 mul instruction takes rax as an implicit input and writes\n"
"            // the 128-bit result of the multiplication to rax:rdx.\n"
"            \"mul {}\""
msgstr ""
"// x86 mul 명령어는 rax를 암시적 입력으로 받고\n"
"            // 128비트 곱셈 결과를 rax:rdx에 씁니다.\n"
"            \"mul {}\""

#: src/unsafe/asm.md:234 src/unsafe/asm.md:356
msgid "\"rax\""
msgstr "\"rax\""

#: src/unsafe/asm.md:235
msgid "\"rdx\""
msgstr "\"rdx\""

#: src/unsafe/asm.md:244
msgid ""
"This uses the `mul` instruction to multiply two 64-bit inputs with a 128-bit "
"result. The only explicit operand is a register, that we fill from the "
"variable `a`. The second operand is implicit, and must be the `rax` "
"register, which we fill from the variable `b`. The lower 64 bits of the "
"result are stored in `rax` from which we fill the variable `lo`. The higher "
"64 bits are stored in `rdx` from which we fill the variable `hi`."
msgstr ""
"이 코드는 `mul` 명령어를 사용하여 두 개의 64비트 입력을 곱해 128비트 결과를 "
"얻습니다. 유일한 명시적 피연산자는 레지스터이며, 변수 `a`로 채웁니다. 두 번"
"째 피연산자는 암시적이며 `rax` 레지스터여야 하는데, 이는 변수 `b`로 채웁니"
"다. 결과의 하위 64비트는 `rax`에 저장되어 변수 `lo`를 채우고, 상위 64비트는 "
"`rdx`에 저장되어 변수 `hi`를 채웁니다."

#: src/unsafe/asm.md:250
msgid "Clobbered registers"
msgstr "클로버(Clobbered) 레지스터"

#: src/unsafe/asm.md:252
msgid ""
"In many cases inline assembly will modify state that is not needed as an "
"output. Usually this is either because we have to use a scratch register in "
"the assembly or because instructions modify state that we don't need to "
"further examine. This state is generally referred to as being \"clobbered\". "
"We need to tell the compiler about this since it may need to save and "
"restore this state around the inline assembly block."
msgstr ""
"많은 경우 인라인 어셈블리는 출력으로 필요하지 않은 상태를 수정합니다. 보통 어"
"셈블리 내에서 스크래치 레지스터를 사용해야 하거나, 명령어가 더 이상 검사할 필"
"요가 없는 상태를 수정하기 때문입니다. 이러한 상태를 일반적으로 \"클로버"
"(clobbered)\" 되었다고 합니다. 컴파일러가 인라인 어셈블리 블록 전후로 이러한 "
"상태를 저장하고 복원해야 할 수도 있으므로 이를 컴파일러에 알려야 합니다."

#: src/unsafe/asm.md:262
msgid "// three entries of four bytes each\n"
msgstr "// 각각 4바이트인 3개의 엔트리\n"

#: src/unsafe/asm.md:264
msgid ""
"// String is stored as ascii in ebx, edx, ecx in order\n"
"    // Because ebx is reserved, the asm needs to preserve the value of it.\n"
"    // So we push and pop it around the main asm.\n"
"    // 64 bit mode on 64 bit processors does not allow pushing/popping of\n"
"    // 32 bit registers (like ebx), so we have to use the extended rbx "
"register instead.\n"
msgstr ""
"// 문자열은 ebx, edx, ecx 순서대로 ASCII로 저장됩니다.\n"
"    // ebx는 예약되어 있으므로, 어셈블리는 이 값을 보존해야 합니다.\n"
"    // 따라서 메인 어셈블리 전후로 push와 pop을 수행합니다.\n"
"    // 64비트 프로세서의 64비트 모드에서는 32비트 레지스터(ebx와 같은)를\n"
"    // push/pop 하는 것을 허용하지 않으므로, 대신 확장된 rbx 레지스터를 사용"
"해야 합니다.\n"

#: src/unsafe/asm.md:272
msgid "\"push rbx\""
msgstr "\"push rbx\""

#: src/unsafe/asm.md:273
msgid "\"cpuid\""
msgstr "\"cpuid\""

#: src/unsafe/asm.md:274
msgid "\"mov [rdi], ebx\""
msgstr "\"mov [rdi], ebx\""

#: src/unsafe/asm.md:275
msgid "\"mov [rdi + 4], edx\""
msgstr "\"mov [rdi + 4], edx\""

#: src/unsafe/asm.md:276
msgid "\"mov [rdi + 8], ecx\""
msgstr "\"mov [rdi + 8], ecx\""

#: src/unsafe/asm.md:277
msgid "\"pop rbx\""
msgstr "\"pop rbx\""

#: src/unsafe/asm.md:278
msgid ""
"// We use a pointer to an array for storing the values to simplify\n"
"            // the Rust code at the cost of a couple more asm instructions\n"
"            // This is more explicit with how the asm works however, as "
"opposed\n"
"            // to explicit register outputs such as `out(\"ecx\") val`\n"
"            // The *pointer itself* is only an input even though it's "
"written behind\n"
msgstr ""
"// 몇 가지 어셈블리 명령어를 더 사용하는 대신 Rust 코드를 단순화하기 위해\n"
"            // 값을 저장하는 데 배열 포인터를 사용합니다.\n"
"            // 하지만 이는 `out(\"ecx\") val`과 같은 명시적 레지스터 출력과"
"는 반대로\n"
"            // 어셈블리가 어떻게 작동하는지 더 명시적으로 보여줍니다.\n"
"            // *포인터 자체*는 비록 그 뒤에 값이 쓰여지더라도 입력일 뿐입니"
"다.\n"

#: src/unsafe/asm.md:283 src/unsafe/asm.md:354
msgid "\"rdi\""
msgstr "\"rdi\""

#: src/unsafe/asm.md:284
msgid "// select cpuid 0, also specify eax as clobbered\n"
msgstr "// cpuid 0을 선택하고, eax를 클로버된 것으로 지정합니다.\n"

#: src/unsafe/asm.md:286
msgid "// cpuid clobbers these registers too\n"
msgstr "// cpuid는 이 레지스터들도 클로버합니다.\n"

#: src/unsafe/asm.md:287
msgid "\"ecx\""
msgstr "\"ecx\""

#: src/unsafe/asm.md:288
msgid "\"edx\""
msgstr "\"edx\""

#: src/unsafe/asm.md:293
msgid "\"CPU Manufacturer ID: {}\""
msgstr "\"CPU 제조사 ID: {}\""

#: src/unsafe/asm.md:300
msgid ""
"In the example above we use the `cpuid` instruction to read the CPU "
"manufacturer ID. This instruction writes to `eax` with the maximum supported "
"`cpuid` argument and `ebx`, `edx`, and `ecx` with the CPU manufacturer ID as "
"ASCII bytes in that order."
msgstr ""
"위의 예제에서는 `cpuid` 명령어를 사용하여 CPU 제조사 ID를 읽습니다. 이 명령어"
"는 `eax`에 지원되는 최대 `cpuid` 인자를 쓰고, `ebx`, `edx`, `ecx` 순서대로 "
"CPU 제조사 ID를 ASCII 바이트로 씁니다."

#: src/unsafe/asm.md:303
msgid ""
"Even though `eax` is never read we still need to tell the compiler that the "
"register has been modified so that the compiler can save any values that "
"were in these registers before the asm. This is done by declaring it as an "
"output but with `_` instead of a variable name, which indicates that the "
"output value is to be discarded."
msgstr ""
"`eax`는 결코 읽히지 않지만, 컴파일러가 어셈블리 이전의 레지스터 값을 저장할 "
"수 있도록 레지스터가 수정되었음을 알려야 합니다. 이는 출력으로 선언하되 변수 "
"이름 대신 `_`를 사용하여 수행하며, 이는 출력 값을 버림을 나타냅니다."

#: src/unsafe/asm.md:305
msgid ""
"This code also works around the limitation that `ebx` is a reserved register "
"by LLVM. That means that LLVM assumes that it has full control over the "
"register and it must be restored to its original state before exiting the "
"asm block, so it cannot be used as an input or output **except** if the "
"compiler uses it to fulfill a general register class (e.g. `in(reg)`). This "
"makes `reg` operands dangerous when using reserved registers as we could "
"unknowingly corrupt our input or output because they share the same register."
msgstr ""
"이 코드는 `ebx`가 LLVM에 의해 예약된 레지스터라는 제한 사항도 해결합니다. 이"
"는 LLVM이 해당 레지스터를 완전히 제어한다고 가정하며 어셈블리 블록을 종료하"
"기 전에 원래 상태로 복원해야 함을 의미합니다. 따라서 컴파일러가 일반 레지스"
"터 클래스(예: `in(reg)`)를 충족하기 위해 사용하는 경우를 **제외**하고는 입력"
"이나 출력으로 사용할 수 없습니다. 이로 인해 예약된 레지스터를 사용할 때 "
"`reg` 피연산자는 위험할 수 있는데, 동일한 레지스터를 공유하여 자신도 모르게 "
"입력이나 출력을 손상시킬 수 있기 때문입니다."

#: src/unsafe/asm.md:307
msgid ""
"To work around this we use `rdi` to store the pointer to the output array, "
"save `ebx` via `push`, read from `ebx` inside the asm block into the array "
"and then restore `ebx` to its original state via `pop`. The `push` and `pop` "
"use the full 64-bit `rbx` version of the register to ensure that the entire "
"register is saved. On 32 bit targets the code would instead use `ebx` in the "
"`push`/`pop`."
msgstr ""
"이를 해결하기 위해 `rdi`를 사용하여 출력 배열에 대한 포인터를 저장하고, "
"`push`를 통해 `ebx`를 저장한 후, 어셈블리 블록 내에서 `ebx`로부터 배열로 읽"
"어 들인 다음, `pop`을 통해 `ebx`를 원래 상태로 복원합니다. 전체 레지스터가 저"
"장되도록 `push`와 `pop`은 레지스터의 64비트 버전인 `rbx`를 사용합니다. 32비"
"트 타겟의 경우 코드에서 대신 `ebx`를 `push`/`pop`에 사용할 것입니다."

#: src/unsafe/asm.md:309
msgid ""
"This can also be used with a general register class to obtain a scratch "
"register for use inside the asm code:"
msgstr ""
"이는 어셈블리 코드 내부에서 사용할 스크래치 레지스터를 얻기 위해 일반 레지스"
"터 클래스와 함께 사용될 수도 있습니다."

#: src/unsafe/asm.md:314
msgid "// Multiply x by 6 using shifts and adds\n"
msgstr "// 시프트와 더하기를 사용하여 x에 6을 곱함\n"

#: src/unsafe/asm.md:319
msgid "\"mov {tmp}, {x}\""
msgstr "\"mov {tmp}, {x}\""

#: src/unsafe/asm.md:320
msgid "\"shl {tmp}, 1\""
msgstr "\"shl {tmp}, 1\""

#: src/unsafe/asm.md:321
msgid "\"shl {x}, 2\""
msgstr "\"shl {x}, 2\""

#: src/unsafe/asm.md:322
msgid "\"add {x}, {tmp}\""
msgstr "\"add {x}, {tmp}\""

#: src/unsafe/asm.md:331
msgid "Symbol operands and ABI clobbers"
msgstr "심볼 피연산자와 ABI 클로버"

#: src/unsafe/asm.md:333
msgid ""
"By default, `asm!` assumes that any register not specified as an output will "
"have its contents preserved by the assembly code. The [`clobber_abi`]"
"(https://doc.rust-lang.org/stable/reference/inline-assembly.html#abi-"
"clobbers) argument to `asm!` tells the compiler to automatically insert the "
"necessary clobber operands according to the given calling convention ABI: "
"any register which is not fully preserved in that ABI will be treated as "
"clobbered.  Multiple `clobber_abi` arguments may be provided and all "
"clobbers from all specified ABIs will be inserted."
msgstr ""
"기본적으로 `asm!`은 출력으로 지정되지 않은 모든 레지스터의 내용이 어셈블리 코"
"드에 의해 보존된다고 가정합니다. `asm!`의 [`clobber_abi`](https://doc.rust-"
"lang.org/stable/reference/inline-assembly.html#abi-clobbers) 인자는 컴파일러"
"가 주어진 호출 규약 ABI에 따라 필요한 클로버 피연산자를 자동으로 삽입하도록 "
"지시합니다. 해당 ABI에서 완전히 보존되지 않는 모든 레지스터는 클로버된 것으"
"로 취급됩니다. 여러 `clobber_abi` 인자를 제공할 수 있으며, 지정된 모든 ABI의 "
"모든 클로버가 삽입됩니다."

#: src/unsafe/asm.md:341 src/unsafe/asm.md:359
msgid "\"C\""
msgstr "\"C\""

#: src/unsafe/asm.md:342
msgid "\"arg = {}\""
msgstr "\"인자 = {}\""

#: src/unsafe/asm.md:350
msgid "\"call {}\""
msgstr "\"call {}\""

#: src/unsafe/asm.md:351
msgid "// Function pointer to call\n"
msgstr "// 호출할 함수 포인터\n"

#: src/unsafe/asm.md:353
msgid "// 1st argument in rdi\n"
msgstr "// 첫 번째 인자는 rdi에\n"

#: src/unsafe/asm.md:355
msgid "// Return value in rax\n"
msgstr "// 반환 값은 rax에\n"

#: src/unsafe/asm.md:357
msgid ""
"// Mark all registers which are not preserved by the \"C\" calling\n"
"            // convention as clobbered.\n"
msgstr ""
"// \"C\" 호출 규약에 의해 보존되지 않는 모든 레지스터를 클로버된 것으로 표시"
"합니다.\n"

#: src/unsafe/asm.md:367
msgid "Register template modifiers"
msgstr "레지스터 템플릿 수정자"

#: src/unsafe/asm.md:369
msgid ""
"In some cases, fine control is needed over the way a register name is "
"formatted when inserted into the template string. This is needed when an "
"architecture's assembly language has several names for the same register, "
"each typically being a \"view\" over a subset of the register (e.g. the low "
"32 bits of a 64-bit register)."
msgstr ""
"어떤 경우에는 템플릿 문자열에 삽입될 때 레지스터 이름이 포맷팅되는 방식에 대"
"해 세밀한 제어가 필요합니다. 이는 아키텍처의 어셈블리 언어에 동일한 레지스터"
"에 대한 여러 이름이 있을 때 필요하며, 각 이름은 일반적으로 레지스터 일부에 대"
"한 \"뷰(view)\"입니다(예: 64비트 레지스터의 하위 32비트)."

#: src/unsafe/asm.md:371
msgid ""
"By default the compiler will always choose the name that refers to the full "
"register size (e.g. `rax` on x86-64, `eax` on x86, etc)."
msgstr ""
"기본적으로 컴파일러는 항상 전체 레지스터 크기를 참조하는 이름을 선택합니다"
"(예: x86-64의 `rax`, x86의 `eax` 등)."

#: src/unsafe/asm.md:373
msgid ""
"This default can be overridden by using modifiers on the template string "
"operands, just like you would with format strings:"
msgstr ""
"이 기본값은 형식 문자열에서처럼 템플릿 문자열 피연산자에 수정자를 사용하여 재"
"정의할 수 있습니다."

#: src/unsafe/asm.md:382
msgid "\"mov {0:h}, {0:l}\""
msgstr "\"mov {0:h}, {0:l}\""

#: src/unsafe/asm.md:389
msgid ""
"In this example, we use the `reg_abcd` register class to restrict the "
"register allocator to the 4 legacy x86 registers (`ax`, `bx`, `cx`, `dx`) of "
"which the first two bytes can be addressed independently."
msgstr ""
"이 예제에서는 `reg_abcd` 레지스터 클래스를 사용하여 레지스터 할당자를 처음 "
"두 바이트를 독립적으로 주소 지정할 수 있는 4개의 레거시 x86 레지스터(`ax`, "
"`bx`, `cx`, `dx`)로 제한합니다."

#: src/unsafe/asm.md:391
msgid ""
"Let us assume that the register allocator has chosen to allocate `x` in the "
"`ax` register. The `h` modifier will emit the register name for the high "
"byte of that register and the `l` modifier will emit the register name for "
"the low byte. The asm code will therefore be expanded as `mov ah, al` which "
"copies the low byte of the value into the high byte."
msgstr ""
"레지스터 할당자가 `x`를 `ax` 레지스터에 할당하기로 선택했다고 가정해 봅시다. "
"`h` 수정자는 해당 레지스터의 상위 바이트에 대한 레지스터 이름을 출력하고, "
"`l` 수정자는 하위 바이트에 대한 레지스터 이름을 출력합니다. 따라서 어셈블리 "
"코드는 `mov ah, al`로 확장되어 값의 하위 바이트를 상위 바이트로 복사합니다."

#: src/unsafe/asm.md:394
msgid ""
"If you use a smaller data type (e.g. `u16`) with an operand and forget to "
"use template modifiers, the compiler will emit a warning and suggest the "
"correct modifier to use."
msgstr ""
"피연산자와 함께 더 작은 데이터 타입(예: `u16`)을 사용하면서 템플릿 수정자를 "
"사용하는 것을 잊은 경우, 컴파일러는 경고를 내보내고 사용할 올바른 수정자를 제"
"안합니다."

#: src/unsafe/asm.md:396
msgid "Memory address operands"
msgstr "메모리 주소 피연산자"

#: src/unsafe/asm.md:398
msgid ""
"Sometimes assembly instructions require operands passed via memory addresses/"
"memory locations. You have to manually use the memory address syntax "
"specified by the target architecture. For example, on x86/x86_64 using Intel "
"assembly syntax, you should wrap inputs/outputs in `[]` to indicate they are "
"memory operands:"
msgstr ""
"때로는 어셈블리 명령어가 메모리 주소/메모리 위치를 통해 전달되는 피연산자를 "
"요구합니다. 타겟 아키텍처에 지정된 메모리 주소 구문을 수동으로 사용해야 합니"
"다. 예를 들어, Intel 어셈블리 구문을 사용하는 x86/x86_64에서는 입력/출력을 "
"`[]`로 감싸서 메모리 피연산자임을 나타내야 합니다."

#: src/unsafe/asm.md:408
msgid "\"fldcw [{}]\""
msgstr "\"fldcw [{}]\""

#: src/unsafe/asm.md:414
msgid "Labels"
msgstr "레이블"

#: src/unsafe/asm.md:416
msgid ""
"Any reuse of a named label, local or otherwise, can result in an assembler "
"or linker error or may cause other strange behavior. Reuse of a named label "
"can happen in a variety of ways including:"
msgstr ""
"이름이 지정된 레이블(로컬이든 아니든)을 재사용하면 어셈블러나 링커 오류가 발"
"생하거나 기타 이상한 동작이 발생할 수 있습니다. 이름이 지정된 레이블의 재사용"
"은 다음과 같은 다양한 방식으로 발생할 수 있습니다."

#: src/unsafe/asm.md:418
msgid ""
"explicitly: using a label more than once in one `asm!` block, or multiple "
"times across blocks."
msgstr ""
"명시적으로: 하나의 `asm!` 블록에서 레이블을 두 번 이상 사용하거나, 블록 간에 "
"여러 번 사용하는 경우."

#: src/unsafe/asm.md:419
msgid ""
"implicitly via inlining: the compiler is allowed to instantiate multiple "
"copies of an `asm!` block, for example when the function containing it is "
"inlined in multiple places."
msgstr ""
"인라이닝을 통한 암시적 방식: 컴파일러는 `asm!` 블록의 여러 복사본을 인스턴스"
"화할 수 있습니다. 예를 들어 해당 블록을 포함하는 함수가 여러 위치에서 인라이"
"닝되는 경우가 이에 해당합니다."

#: src/unsafe/asm.md:420
msgid ""
"implicitly via LTO: LTO can cause code from _other crates_ to be placed in "
"the same codegen unit, and so could bring in arbitrary labels."
msgstr ""
"LTO를 통한 암시적 방식: LTO는 _다른 크레이트_의 코드를 동일한 코드 생성 단위"
"에 배치할 수 있으며, 이로 인해 임의의 레이블이 유입될 수 있습니다."

#: src/unsafe/asm.md:422
msgid ""
"As a consequence, you should only use GNU assembler **numeric** [local "
"labels](https://sourceware.org/binutils/docs/as/Symbol-Names.html#Local-"
"Labels) inside inline assembly code. Defining symbols in assembly code may "
"lead to assembler and/or linker errors due to duplicate symbol definitions."
msgstr ""
"결과적으로, 인라인 어셈블리 코드 내부에서는 GNU 어셈블러 **숫자** [로컬 레이"
"블](https://sourceware.org/binutils/docs/as/Symbol-Names.html#Local-Labels)"
"만 사용해야 합니다. 어셈블리 코드에서 심볼을 정의하면 심볼 중복 정의로 인해 "
"어셈블러 및/또는 링커 오류가 발생할 수 있습니다."

#: src/unsafe/asm.md:424
msgid ""
"Moreover, on x86 when using the default Intel syntax, due to [an LLVM bug]"
"(https://bugs.llvm.org/show_bug.cgi?id=36144), you shouldn't use labels "
"exclusively made of `0` and `1` digits, e.g. `0`, `11` or `101010`, as they "
"may end up being interpreted as binary values. Using `options(att_syntax)` "
"will avoid any ambiguity, but that affects the syntax of the _entire_ `asm!` "
"block. (See [Options](#options), below, for more on `options`.)"
msgstr ""
"또한 x86에서 기본 Intel 구문을 사용할 때, [LLVM 버그](https://bugs.llvm.org/"
"show_bug.cgi?id=36144)로 인해 `0`, `11` 또는 `101010`과 같이 `0`과 `1` 숫자로"
"만 구성된 레이블은 사용하지 말아야 합니다. 이는 바이너리 값으로 해석될 수 있"
"기 때문입니다. `options(att_syntax)`를 사용하면 모호함을 피할 수 있지만, 이"
"는 `asm!` 블록 _전체_의 구문에 영향을 미칩니다. (`options`에 대한 자세한 내용"
"은 아래의 [옵션](#options) 섹션을 참조하세요.)"

#: src/unsafe/asm.md:433
msgid "\"mov {0}, 10\""
msgstr "\"mov {0}, 10\""

#: src/unsafe/asm.md:434 src/unsafe/asm.md:439
msgid "\"2:\""
msgstr "\"2:\""

#: src/unsafe/asm.md:435
msgid "\"sub {0}, 1\""
msgstr "\"sub {0}, 1\""

#: src/unsafe/asm.md:436
msgid "\"cmp {0}, 3\""
msgstr "\"cmp {0}, 3\""

#: src/unsafe/asm.md:437
msgid "\"jle 2f\""
msgstr "\"jle 2f\""

#: src/unsafe/asm.md:438
msgid "\"jmp 2b\""
msgstr "\"jmp 2b\""

#: src/unsafe/asm.md:440
msgid "\"add {0}, 2\""
msgstr "\"add {0}, 2\""

#: src/unsafe/asm.md:448
msgid ""
"This will decrement the `{0}` register value from 10 to 3, then add 2 and "
"store it in `a`."
msgstr ""
"이 코드는 `{0}` 레지스터 값을 10에서 3으로 감소시킨 다음, 2를 더하고 그 결과"
"를 `a`에 저장합니다."

#: src/unsafe/asm.md:450
msgid "This example shows a few things:"
msgstr "이 예제는 몇 가지를 보여줍니다:"

#: src/unsafe/asm.md:452
msgid ""
"First, that the same number can be used as a label multiple times in the "
"same inline block."
msgstr ""
"첫째, 동일한 숫자를 하나의 인라인 블록 내에서 레이블로 여러 번 사용할 수 있습"
"니다."

#: src/unsafe/asm.md:453
msgid ""
"Second, that when a numeric label is used as a reference (as an instruction "
"operand, for example), the suffixes “b” (“backward”) or ”f” (“forward”) "
"should be added to the numeric label. It will then refer to the nearest "
"label defined by this number in this direction."
msgstr ""
"둘째, 숫자 레이블이 참조(예: 명령어 피연산자)로 사용될 때는 숫자 레이블에 접"
"미사 “b” (“backward”, 뒤로) 또는 ”f” (“forward”, 앞으로)를 추가해야 합니다. "
"그러면 해당 방향에서 이 숫자로 정의된 가장 가까운 레이블을 참조하게 됩니다."

#: src/unsafe/asm.md:458
msgid "Options"
msgstr "옵션"

#: src/unsafe/asm.md:460
msgid ""
"By default, an inline assembly block is treated the same way as an external "
"FFI function call with a custom calling convention: it may read/write "
"memory, have observable side effects, etc. However, in many cases it is "
"desirable to give the compiler more information about what the assembly code "
"is actually doing so that it can optimize better."
msgstr ""
"기본적으로 인라인 어셈블리 블록은 커스텀 호출 규약을 사용하는 외부 FFI 함수 "
"호출과 동일하게 취급됩니다. 즉, 메모리를 읽거나 쓰고, 관찰 가능한 부수 효과"
"가 있을 수 있다고 가정합니다. 하지만 많은 경우 컴파일러가 더 나은 최적화를 수"
"행할 수 있도록 어셈블리 코드가 실제로 무엇을 하는지에 대한 더 많은 정보를 제"
"공하는 것이 바람직합니다."

#: src/unsafe/asm.md:462
msgid "Let's take our previous example of an `add` instruction:"
msgstr "이전의 `add` 명령어 예제를 다시 살펴봅시다:"

#: src/unsafe/asm.md:481
msgid ""
"Options can be provided as an optional final argument to the `asm!` macro. "
"We specified three options here:"
msgstr ""
"옵션은 `asm!` 매크로의 선택적인 마지막 인자로 제공될 수 있습니다. 여기서는 "
"세 가지 옵션을 지정했습니다:"

#: src/unsafe/asm.md:483
msgid ""
"`pure` means that the asm code has no observable side effects and that its "
"output depends only on its inputs. This allows the compiler optimizer to "
"call the inline asm fewer times or even eliminate it entirely."
msgstr ""
"`pure`는 어셈블리 코드가 관찰 가능한 부수 효과가 없으며 출력이 입력에만 의존"
"함을 의미합니다. 이를 통해 컴파일러 최적화 프로그램은 인라인 어셈블리를 더 적"
"게 호출하거나 아예 제거할 수 있습니다."

#: src/unsafe/asm.md:484
msgid ""
"`nomem` means that the asm code does not read or write to memory. By default "
"the compiler will assume that inline assembly can read or write any memory "
"address that is accessible to it (e.g. through a pointer passed as an "
"operand, or a global)."
msgstr ""
"`nomem`은 어셈블리 코드가 메모리를 읽거나 쓰지 않음을 의미합니다. 기본적으로 "
"컴파일러는 인라인 어셈블리가 접근 가능한 모든 메모리 주소(예: 피연산자로 전달"
"된 포인터나 전역 변수를 통해)를 읽거나 쓸 수 있다고 가정합니다."

#: src/unsafe/asm.md:485
msgid ""
"`nostack` means that the asm code does not push any data onto the stack. "
"This allows the compiler to use optimizations such as the stack red zone on "
"x86-64 to avoid stack pointer adjustments."
msgstr ""
"`nostack`은 어셈블리 코드가 스택에 어떤 데이터도 푸시하지 않음을 의미합니다. "
"이를 통해 컴파일러는 x86-64의 스택 레드 존(stack red zone)과 같은 최적화를 사"
"용하여 스택 포인터 조정을 피할 수 있습니다."

#: src/unsafe/asm.md:487
msgid ""
"These allow the compiler to better optimize code using `asm!`, for example "
"by eliminating pure `asm!` blocks whose outputs are not needed."
msgstr ""
"이러한 옵션들은 컴파일러가 `asm!`을 사용하는 코드를 더 잘 최적화할 수 있게 해"
"줍니다. 예를 들어 출력이 필요하지 않은 순수(pure) `asm!` 블록을 제거할 수 있"
"습니다."

#: src/unsafe/asm.md:489
msgid ""
"See the [reference](https://doc.rust-lang.org/stable/reference/inline-"
"assembly.html) for the full list of available options and their effects."
msgstr ""
"사용 가능한 전체 옵션 목록과 그 효과에 대해서는 [레퍼런스](https://doc.rust-"
"lang.org/stable/reference/inline-assembly.html)를 참조하세요."

#: src/compatibility.md:3
msgid ""
"The Rust language is evolving rapidly, and because of this certain "
"compatibility issues can arise, despite efforts to ensure forwards-"
"compatibility wherever possible."
msgstr ""
"Rust 언어는 빠르게 진화하고 있으며, 이로 인해 가능한 한 전방 호환성을 보장하"
"려는 노력에도 불구하고 특정 호환성 문제가 발생할 수 있습니다."

#: src/compatibility.md:7
msgid "[Raw identifiers](compatibility/raw_identifiers.md)"
msgstr "[Raw 식별자](compatibility/raw_identifiers.md)"

#: src/compatibility/raw_identifiers.md:3
msgid ""
"Rust, like many programming languages, has the concept of \"keywords\". "
"These identifiers mean something to the language, and so you cannot use them "
"in places like variable names, function names, and other places. Raw "
"identifiers let you use keywords where they would not normally be allowed. "
"This is particularly useful when Rust introduces new keywords, and a library "
"using an older edition of Rust has a variable or function with the same name "
"as a keyword introduced in a newer edition."
msgstr ""
"Rust는 많은 프로그래밍 언어와 마찬가지로 \"키워드\"라는 개념이 있습니다. 이러"
"한 식별자들은 언어에 의미가 있으므로 변수 이름, 함수 이름 등에서 사용할 수 없"
"습니다. Raw 식별자를 사용하면 일반적으로 허용되지 않는 위치에서 키워드를 사용"
"할 수 있습니다. 이는 특히 Rust가 새로운 키워드를 도입하고, 이전 에디션의 Rust"
"를 사용하는 라이브러리에 최신 에디션에서 도입된 키워드와 동일한 이름의 변수"
"나 함수가 있을 때 유용합니다."

#: src/compatibility/raw_identifiers.md:11
msgid ""
"For example, consider a crate `foo` compiled with the 2015 edition of Rust "
"that exports a function named `try`. This keyword is reserved for a new "
"feature in the 2018 edition, so without raw identifiers, we would have no "
"way to name the function."
msgstr ""
"예를 들어, 2015 에디션 Rust로 컴파일된 `foo` 크레이트가 `try`라는 이름의 함수"
"를 내보낸다고 가정해 봅시다. 이 키워드는 2018 에디션의 새로운 기능을 위해 예"
"약되어 있으므로, Raw 식별자가 없다면 함수 이름을 지을 방법이 없을 것입니다."

#: src/compatibility/raw_identifiers.md:24
msgid "You'll get this error:"
msgstr "다음과 같은 오류가 발생합니다:"

#: src/compatibility/raw_identifiers.md:34
msgid "You can write this with a raw identifier:"
msgstr "Raw 식별자를 사용하여 다음과 같이 작성할 수 있습니다:"

#: src/meta.md:3
msgid ""
"Some topics aren't exactly relevant to how you program runs but provide you "
"tooling or infrastructure support which just makes things better for "
"everyone. These topics include:"
msgstr ""
"일부 주제는 프로그램의 실행 방식과 직접적인 관련은 없지만, 모든 사람에게 도움"
"이 되는 도구 또는 인프라 지원을 제공합니다. 이러한 주제는 다음과 같습니다."

#: src/meta.md:7
msgid ""
"[Documentation](meta/doc.md): Generate library documentation for users via "
"the included `rustdoc`."
msgstr ""
"[문서화](meta/doc.md): 포함된 `rustdoc`을 통해 사용자를 위한 라이브러리 문서"
"를 생성합니다."

#: src/meta.md:9
msgid ""
"[Playground](meta/playground.md): Integrate the Rust Playground in your "
"documentation."
msgstr ""
"[플레이그라운드](meta/playground.md): 문서에 Rust 플레이그라운드를 통합합니"
"다."

#: src/meta/doc.md:3
msgid ""
"Use `cargo doc` to build documentation in `target/doc`, `cargo doc --open` "
"will automatically open it in your web browser."
msgstr ""
"`target/doc`에 문서를 빌드하려면 `cargo doc`을 사용하세요. `cargo doc --open`"
"은 웹 브라우저에서 문서를 자동으로 엽니다."

#: src/meta/doc.md:6
msgid ""
"Use `cargo test` to run all tests (including documentation tests), and "
"`cargo test --doc` to only run documentation tests."
msgstr ""
"모든 테스트(문서 테스트 포함)를 실행하려면 `cargo test`를, 문서 테스트만 실행"
"하려면 `cargo test --doc`을 사용하세요."

#: src/meta/doc.md:9
msgid ""
"These commands will appropriately invoke `rustdoc` (and `rustc`) as required."
msgstr ""
"이러한 명령어들은 필요에 따라 `rustdoc`(및 `rustc`)을 적절히 호출합니다."

#: src/meta/doc.md:11
msgid "Doc comments"
msgstr "문서 주석"

#: src/meta/doc.md:13
msgid ""
"Doc comments are very useful for big projects that require documentation. "
"When running `rustdoc`, these are the comments that get compiled into "
"documentation. They are denoted by a `///`, and support [Markdown](https://"
"en.wikipedia.org/wiki/Markdown)."
msgstr ""
"문서 주석은 문서화가 필요한 큰 프로젝트에 매우 유용합니다. `rustdoc`을 실행"
"할 때, 이 주석들이 문서로 컴파일됩니다. 이들은 `///`로 표시되며 [Markdown]"
"(https://en.wikipedia.org/wiki/Markdown)을 지원합니다."

#: src/meta/doc.md:18
msgid "\"doc\""
msgstr "\"doc\""

#: src/meta/doc.md:19
msgid "/// A human being is represented here\n"
msgstr "/// 여기에 사람(human being)이 표현됩니다.\n"

#: src/meta/doc.md:22
msgid "/// A person must have a name, no matter how much Juliet may hate it\n"
msgstr "/// 줄리엣이 아무리 싫어하더라도 사람은 이름을 가져야 합니다.\n"

#: src/meta/doc.md:27
msgid ""
"/// Creates a person with the given name.\n"
"    ///\n"
"    /// # Examples\n"
"    ///\n"
"    /// ```\n"
"    /// // You can have rust code between fences inside the comments\n"
"    /// // If you pass --test to `rustdoc`, it will even test it for you!\n"
"    /// use doc::Person;\n"
"    /// let person = Person::new(\"name\");\n"
"    /// ```\n"
msgstr ""
"/// 주어진 이름으로 사람을 생성합니다.\n"
"    ///\n"
"    /// # Examples\n"
"    ///\n"
"    /// ```\n"
"    /// // 주석 내부의 울타리(fence) 사이에 Rust 코드를 넣을 수 있습니다.\n"
"    /// // `rustdoc`에 --test를 전달하면, 코드 테스트까지 해줍니다!\n"
"    /// use doc::Person;\n"
"    /// let person = Person::new(\"name\");\n"
"    /// ```\n"

#: src/meta/doc.md:43
msgid ""
"/// Gives a friendly hello!\n"
"    ///\n"
"    /// Says \"Hello, [name](Person::name)\" to the `Person` it is called "
"on.\n"
msgstr ""
"/// 친절하게 인사합니다!\n"
"    ///\n"
"    /// 호출된 `Person`의 이름을 사용하여 \"안녕, [name](Person::name)\"이라"
"고 말합니다.\n"

#: src/meta/doc.md:47
msgid "\"Hello, {}!\""
msgstr "\"안녕, {}!\""

#: src/meta/doc.md:52
msgid "\"John\""
msgstr "\"존\""

#: src/meta/doc.md:58
msgid ""
"To run the tests, first build the code as a library, then tell `rustdoc` "
"where to find the library so it can link it into each doctest program:"
msgstr ""
"테스트를 실행하려면 먼저 코드를 라이브러리로 빌드한 다음, `rustdoc`이 각 문"
"서 테스트 프로그램에 링크할 수 있도록 라이브러리 위치를 알려주어야 합니다."

#: src/meta/doc.md:61
msgid ""
"```shell\n"
"$ rustc doc.rs --crate-type lib\n"
"$ rustdoc --test --extern doc=\"libdoc.rlib\" doc.rs\n"
"```"
msgstr ""
"```shell\n"
"$ rustc doc.rs --crate-type lib\n"
"$ rustdoc --test --extern doc=\"libdoc.rlib\" doc.rs\n"
"```"

#: src/meta/doc.md:66
msgid "Doc attributes"
msgstr "문서 속성"

#: src/meta/doc.md:68
msgid ""
"Below are a few examples of the most common `#[doc]` attributes used with "
"`rustdoc`."
msgstr ""
"다음은 `rustdoc`과 함께 사용되는 가장 일반적인 `#[doc]` 속성의 몇 가지 예입니"
"다."

#: src/meta/doc.md:71
msgid "`inline`"
msgstr "`inline`"

#: src/meta/doc.md:73
msgid "Used to inline docs, instead of linking out to separate page."
msgstr ""
"별도의 페이지로 링크하는 대신 문서를 인라인으로 표시하는 데 사용됩니다."

#: src/meta/doc.md:78
msgid "/// bar docs\n"
msgstr "/// bar 문서\n"

#: src/meta/doc.md:81
msgid "/// the docs for Bar\n"
msgstr "/// Bar에 대한 문서\n"

#: src/meta/doc.md:86
msgid "`no_inline`"
msgstr "`no_inline`"

#: src/meta/doc.md:88
msgid "Used to prevent linking out to separate page or anywhere."
msgstr "별도의 페이지나 다른 곳으로 링크되는 것을 방지하는 데 사용됩니다."

#: src/meta/doc.md:91
msgid "// Example from libcore/prelude\n"
msgstr "// libcore/prelude에서 가져온 예시\n"

#: src/meta/doc.md:96
msgid "`hidden`"
msgstr "`hidden`"

#: src/meta/doc.md:98
msgid "Using this tells `rustdoc` not to include this in documentation:"
msgstr "이를 사용하면 `rustdoc`이 해당 항목을 문서에 포함하지 않도록 합니다."

#: src/meta/doc.md:101
msgid "// Example from the futures-rs library\n"
msgstr "// futures-rs 라이브러리에서 가져온 예시\n"

#: src/meta/doc.md:106
msgid ""
"For documentation, `rustdoc` is widely used by the community. It's what is "
"used to generate the [std library docs](https://doc.rust-lang.org/std/)."
msgstr ""
"문서화를 위해 커뮤니티에서는 `rustdoc`이 널리 사용됩니다. [표준 라이브러리 문"
"서](https://doc.rust-lang.org/std/)를 생성하는 데 사용되는 도구이기도 합니다."

#: src/meta/doc.md:111
msgid ""
"[The Rust Book: Making Useful Documentation Comments](https://doc.rust-"
"lang.org/book/ch14-02-publishing-to-crates-io.html#making-useful-"
"documentation-comments)"
msgstr ""
"[The Rust Book: 유용한 문서 주석 만들기](https://doc.rust-lang.org/book/"
"ch14-02-publishing-to-crates-io.html#making-useful-documentation-comments)"

#: src/meta/doc.md:112
msgid "[The rustdoc Book](https://doc.rust-lang.org/rustdoc/index.html)"
msgstr "[rustdoc 책](https://doc.rust-lang.org/rustdoc/index.html)"

#: src/meta/doc.md:113
msgid ""
"[The Reference: Doc comments](https://doc.rust-lang.org/stable/reference/"
"comments.html#doc-comments)"
msgstr ""
"[The Reference: 문서 주석](https://doc.rust-lang.org/stable/reference/"
"comments.html#doc-comments)"

#: src/meta/doc.md:114
msgid ""
"[RFC 1574: API Documentation Conventions](https://rust-lang.github.io/rfcs/"
"1574-more-api-documentation-conventions.html#appendix-a-full-conventions-"
"text)"
msgstr ""
"[RFC 1574: API 문서 관례](https://rust-lang.github.io/rfcs/1574-more-api-"
"documentation-conventions.html#appendix-a-full-conventions-text)"

#: src/meta/doc.md:115
msgid ""
"[RFC 1946: Relative links to other items from doc comments (intra-rustdoc "
"links)](https://rust-lang.github.io/rfcs/1946-intra-rustdoc-links.html)"
msgstr ""
"[RFC 1946: 문서 주석에서 다른 아이템으로의 상대 링크 (intra-rustdoc links)]"
"(https://rust-lang.github.io/rfcs/1946-intra-rustdoc-links.html)"

#: src/meta/doc.md:116
msgid ""
"[Is there any documentation style guide for comments? (reddit)](https://"
"www.reddit.com/r/rust/comments/ahb50s/"
"is_there_any_documentation_style_guide_for/)"
msgstr ""
"[주석에 대한 문서화 스타일 가이드가 있나요? (reddit)](https://www.reddit.com/"
"r/rust/comments/ahb50s/is_there_any_documentation_style_guide_for/)"

#: src/meta/playground.md:3
msgid ""
"The [Rust Playground](https://play.rust-lang.org/) is a way to experiment "
"with Rust code through a web interface."
msgstr ""
"[Rust 플레이그라운드](https://play.rust-lang.org/)는 웹 인터페이스를 통해 "
"Rust 코드를 실험해 볼 수 있는 방법입니다."

#: src/meta/playground.md:6
msgid "Using it with `mdbook`"
msgstr "`mdbook`에서 사용하기"

#: src/meta/playground.md:8
msgid ""
"In [`mdbook`](https://github.com/rust-lang/mdBook), you can make code "
"examples playable and editable."
msgstr ""
"[`mdbook`](https://github.com/rust-lang/mdBook)에서는 코드 예제를 실행 가능하"
"고 수정 가능하게 만들 수 있습니다."

#: src/meta/playground.md:16
msgid ""
"This allows the reader to both run your code sample, but also modify and "
"tweak it. The key here is the adding of the word `editable` to your "
"codefence block separated by a comma."
msgstr ""
"이를 통해 독자는 코드 샘플을 실행할 뿐만 아니라 수정하고 조정해 볼 수도 있습"
"니다. 여기서 핵심은 코드 펜스(codefence) 블록에 콤마로 구분하여 `editable`이"
"라는 단어를 추가하는 것입니다."

#: src/meta/playground.md:26
msgid ""
"Additionally, you can add `ignore` if you want `mdbook` to skip your code "
"when it builds and tests."
msgstr "빌드 및 테스트 시에."

#: src/meta/playground.md:35
msgid "Using it with docs"
msgstr "문서에서 사용하기"

#: src/meta/playground.md:37
msgid ""
"You may have noticed in some of the [official Rust docs](https://doc.rust-"
"lang.org/core/) a button that says \"Run\", which opens the code sample up "
"in a new tab in Rust Playground. This feature is enabled if you use the "
"`#[doc]` attribute called [`html_playground_url`](https://doc.rust-lang.org/"
"rustdoc/write-documentation/the-doc-attribute.html#html_playground_url)."
msgstr ""
"[공식 Rust 문서](https://doc.rust-lang.org/core/) 중 일부에서 \"Run\"이라고 "
"적힌 버튼을 본 적이 있을 것입니다. 이 버튼을 누르면 Rust 플레이그라운드의 새 "
"탭에서 코드 샘플이 열립니다. 이 기능은 [`html_playground_url`](https://"
"doc.rust-lang.org/rustdoc/write-documentation/the-doc-"
"attribute.html#html_playground_url)이라는 `#[doc]` 속성을 사용하면 활성화됩니"
"다."

#: src/meta/playground.md:42
msgid ""
"````text\n"
"#![doc(html_playground_url = \"https://play.rust-lang.org/\")]\n"
"//! ```\n"
"//! println!(\"Hello World\");\n"
"//! ```\n"
"````"
msgstr ""
"````text\n"
"#![doc(html_playground_url = \"https://play.rust-lang.org/\")]\n"
"//! ```\n"
"//! println!(\"Hello World\");\n"
"//! ```\n"
"````"

#: src/meta/playground.md:51
msgid "[The Rust Playground](https://play.rust-lang.org/)"
msgstr "[Rust 플레이그라운드](https://play.rust-lang.org/)"

#: src/meta/playground.md:52
msgid ""
"[The Rust Playground On Github](https://github.com/integer32llc/rust-"
"playground/)"
msgstr ""
"[GitHub의 Rust 플레이그라운드](https://github.com/integer32llc/rust-"
"playground/)"

#: src/meta/playground.md:53
msgid ""
"[The rustdoc Book](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html)"
msgstr ""
"[rustdoc 책](https://doc.rust-lang.org/rustdoc/what-is-rustdoc.html)"

#~ msgid ""
#~ "While the former enables conditional compilation, the latter "
#~ "conditionally evaluates to `true` or `false` literals, allowing for "
#~ "checks at run-time. Both utilize identical argument syntax."
#~ msgstr ""
#~ "전자는 조건부 컴파일을 가능하게 하는 반면, 후자는 조건부로 `true` 또는 "
#~ "`false` 리터럴로 평가되어 런타임에 검사를 가능하게 합니다. 둘 다 동일한 인"
#~ "자 문법을 사용합니다."

#~ msgid "// Compile-time Error! Type mismatch so these cannot be compared:\n"
#~ msgstr "// 컴파일 타임 에러! 타입 불일치로 인해 비교할 수 없습니다:\n"

#~ msgid ""
#~ "// This function takes ownership of the heap allocated memory from `b`\n"
#~ "    //destroy_box(b);\n"
#~ msgstr "// 이 함수는 `b`로부터 힙 할당 메모리의 소유권을 가져갑니다\n"
