msgid "" msgstr "" "Project-Id-Version: Comprehensive Rust 🦀\n" "POT-Creation-Date: \n" "PO-Revision-Date: 2023-01-18 16:02+0100\n" "Last-Translator: Martin Geisler \n" "Language-Team: \n" "Language: da\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "Plural-Forms: nplurals=2; plural=(n != 1);\n" #: src/SUMMARY.md:3 msgid "Welcome to Comprehensive Rust 🦀" msgstr "Velkommen til Comprehensive Rust 🦀" #: src/SUMMARY.md:4 msgid "Running the Course" msgstr "" #: src/SUMMARY.md:5 msgid "Course Structure" msgstr "Kursets struktur" #: src/SUMMARY.md:6 msgid "Keyboard Shortcuts" msgstr "Genvejstaster" #: src/SUMMARY.md:7 msgid "Using Cargo" msgstr "Brug af Cargo" #: src/SUMMARY.md:8 msgid "Rust Ecosystem" msgstr "Rust's økosystem" #: src/SUMMARY.md:9 msgid "Code Samples" msgstr "" #: src/SUMMARY.md:10 msgid "Running Cargo Locally" msgstr "" #: src/SUMMARY.md:13 msgid "Day 1: Morning" msgstr "Dag 1: Formiddag" #: src/SUMMARY.md:17 src/SUMMARY.md:73 src/SUMMARY.md:126 src/SUMMARY.md:176 msgid "Welcome" msgstr "Velkommen" #: src/SUMMARY.md:18 msgid "What is Rust?" msgstr "Hvad er Rust?" #: src/SUMMARY.md:19 msgid "Hello World!" msgstr "Hej verden!" #: src/SUMMARY.md:20 msgid "Small Example" msgstr "Et little eksempel" #: src/SUMMARY.md:21 msgid "Why Rust?" msgstr "Hvorfor bruge Rust?" #: src/SUMMARY.md:22 msgid "Compile Time Guarantees" msgstr "" #: src/SUMMARY.md:23 msgid "Runtime Guarantees" msgstr "" #: src/SUMMARY.md:24 msgid "Modern Features" msgstr "Moderne features" #: src/SUMMARY.md:25 msgid "Basic Syntax" msgstr "Basal syntaks" #: src/SUMMARY.md:26 msgid "Scalar Types" msgstr "Skalartyper" #: src/SUMMARY.md:27 msgid "Compound Types" msgstr "Sammensatte typer" #: src/SUMMARY.md:28 msgid "References" msgstr "Referencer" #: src/SUMMARY.md:29 msgid "Dangling References" msgstr "" #: src/SUMMARY.md:30 msgid "Slices" msgstr "" #: src/SUMMARY.md:31 msgid "String vs str" msgstr "String og str" #: src/SUMMARY.md:32 msgid "Functions" msgstr "Funktioner" #: src/SUMMARY.md:33 src/SUMMARY.md:80 msgid "Methods" msgstr "Metoder" #: src/SUMMARY.md:34 msgid "Overloading" msgstr "" #: src/SUMMARY.md:35 src/SUMMARY.md:64 src/SUMMARY.md:88 src/SUMMARY.md:117 #: src/SUMMARY.md:144 src/SUMMARY.md:168 src/SUMMARY.md:191 src/SUMMARY.md:218 msgid "Exercises" msgstr "Øvelser" #: src/SUMMARY.md:36 msgid "Implicit Conversions" msgstr "Implicitte konverteringer" #: src/SUMMARY.md:37 msgid "Arrays and for Loops" msgstr "Arrays of for-løkker" #: src/SUMMARY.md:39 msgid "Day 1: Afternoon" msgstr "Dag 1: Eftermiddag" #: src/SUMMARY.md:41 msgid "Variables" msgstr "Variabler" #: src/SUMMARY.md:42 msgid "Type Inference" msgstr "" #: src/SUMMARY.md:43 msgid "static & const" msgstr "static & const" #: src/SUMMARY.md:44 msgid "Scopes and Shadowing" msgstr "" #: src/SUMMARY.md:45 msgid "Memory Management" msgstr "Håndtering af hukommelse" #: src/SUMMARY.md:46 msgid "Stack vs Heap" msgstr "Stak og heap" #: src/SUMMARY.md:47 msgid "Stack Memory" msgstr "Stakhukommelse" #: src/SUMMARY.md:48 msgid "Manual Memory Management" msgstr "Manuel hukommelseshåndtering" #: src/SUMMARY.md:49 msgid "Scope-Based Memory Management" msgstr "" #: src/SUMMARY.md:50 msgid "Garbage Collection" msgstr "" #: src/SUMMARY.md:51 msgid "Rust Memory Management" msgstr "Hukommelseshåndtering i Rust" #: src/SUMMARY.md:52 msgid "Comparison" msgstr "Sammenligning" #: src/SUMMARY.md:53 msgid "Ownership" msgstr "Ejerskab" #: src/SUMMARY.md:54 msgid "Move Semantics" msgstr "" #: src/SUMMARY.md:55 msgid "Moved Strings in Rust" msgstr "" #: src/SUMMARY.md:56 msgid "Double Frees in Modern C++" msgstr "" #: src/SUMMARY.md:57 msgid "Moves in Function Calls" msgstr "" #: src/SUMMARY.md:58 msgid "Copying and Cloning" msgstr "" #: src/SUMMARY.md:59 msgid "Borrowing" msgstr "" #: src/SUMMARY.md:60 msgid "Shared and Unique Borrows" msgstr "" #: src/SUMMARY.md:61 msgid "Lifetimes" msgstr "" #: src/SUMMARY.md:62 msgid "Lifetimes in Function Calls" msgstr "" #: src/SUMMARY.md:63 msgid "Lifetimes in Data Structures" msgstr "" #: src/SUMMARY.md:65 msgid "Designing a Library" msgstr "" #: src/SUMMARY.md:66 msgid "Iterators and Ownership" msgstr "" #: src/SUMMARY.md:69 msgid "Day 2: Morning" msgstr "" #: src/SUMMARY.md:74 msgid "Structs" msgstr "" #: src/SUMMARY.md:75 msgid "Tuple Structs" msgstr "" #: src/SUMMARY.md:76 msgid "Field Shorthand Syntax" msgstr "" #: src/SUMMARY.md:77 msgid "Enums" msgstr "" #: src/SUMMARY.md:78 msgid "Variant Payloads" msgstr "" #: src/SUMMARY.md:79 msgid "Enum Sizes" msgstr "" #: src/SUMMARY.md:81 msgid "Method Receiver" msgstr "" #: src/SUMMARY.md:82 src/SUMMARY.md:186 msgid "Example" msgstr "" #: src/SUMMARY.md:83 msgid "Pattern Matching" msgstr "" #: src/SUMMARY.md:84 msgid "Destructuring Enums" msgstr "" #: src/SUMMARY.md:85 msgid "Destructuring Structs" msgstr "" #: src/SUMMARY.md:86 msgid "Destructuring Arrays" msgstr "" #: src/SUMMARY.md:87 msgid "Match Guards" msgstr "" #: src/SUMMARY.md:89 msgid "Health Statistics" msgstr "" #: src/SUMMARY.md:90 msgid "Points and Polygons" msgstr "" #: src/SUMMARY.md:92 msgid "Day 2: Afternoon" msgstr "" #: src/SUMMARY.md:94 msgid "Control Flow" msgstr "" #: src/SUMMARY.md:95 msgid "Blocks" msgstr "" #: src/SUMMARY.md:96 msgid "if expressions" msgstr "" #: src/SUMMARY.md:97 msgid "if let expressions" msgstr "" #: src/SUMMARY.md:98 msgid "while expressions" msgstr "" #: src/SUMMARY.md:99 msgid "while let expressions" msgstr "" #: src/SUMMARY.md:100 msgid "for expressions" msgstr "" #: src/SUMMARY.md:101 msgid "loop expressions" msgstr "" #: src/SUMMARY.md:102 msgid "match expressions" msgstr "" #: src/SUMMARY.md:103 msgid "break & continue" msgstr "" #: src/SUMMARY.md:104 msgid "Standard Library" msgstr "" #: src/SUMMARY.md:105 msgid "String" msgstr "" #: src/SUMMARY.md:106 msgid "Option and Result" msgstr "" #: src/SUMMARY.md:107 msgid "Vec" msgstr "" #: src/SUMMARY.md:108 msgid "HashMap" msgstr "" #: src/SUMMARY.md:109 msgid "Box" msgstr "" #: src/SUMMARY.md:110 msgid "Recursive Data Types" msgstr "" #: src/SUMMARY.md:111 msgid "Niche Optimization" msgstr "" #: src/SUMMARY.md:112 msgid "Rc" msgstr "" #: src/SUMMARY.md:113 msgid "Modules" msgstr "" #: src/SUMMARY.md:114 msgid "Visibility" msgstr "" #: src/SUMMARY.md:115 msgid "Paths" msgstr "" #: src/SUMMARY.md:116 msgid "Filesystem Hierarchy" msgstr "" #: src/SUMMARY.md:118 msgid "Luhn Algorithm" msgstr "" #: src/SUMMARY.md:119 msgid "Strings and Iterators" msgstr "" #: src/SUMMARY.md:122 msgid "Day 3: Morning" msgstr "" #: src/SUMMARY.md:127 msgid "Traits" msgstr "" #: src/SUMMARY.md:128 msgid "Deriving Traits" msgstr "" #: src/SUMMARY.md:129 msgid "Default Methods" msgstr "" #: src/SUMMARY.md:130 msgid "Important Traits" msgstr "" #: src/SUMMARY.md:131 msgid "Iterator" msgstr "" #: src/SUMMARY.md:132 msgid "FromIterator" msgstr "" #: src/SUMMARY.md:133 msgid "Read and Write" msgstr "" #: src/SUMMARY.md:134 msgid "Add, Mul, ..." msgstr "" #: src/SUMMARY.md:135 msgid "Drop" msgstr "" #: src/SUMMARY.md:136 msgid "Generics" msgstr "" #: src/SUMMARY.md:137 msgid "Generic Data Types" msgstr "" #: src/SUMMARY.md:138 msgid "Generic Methods" msgstr "" #: src/SUMMARY.md:139 msgid "Trait Bounds" msgstr "" #: src/SUMMARY.md:140 msgid "impl Trait" msgstr "" #: src/SUMMARY.md:141 msgid "Closures" msgstr "" #: src/SUMMARY.md:142 msgid "Monomorphization" msgstr "" #: src/SUMMARY.md:143 msgid "Trait Objects" msgstr "" #: src/SUMMARY.md:145 msgid "A Simple GUI Library" msgstr "" #: src/SUMMARY.md:147 msgid "Day 3: Afternoon" msgstr "" #: src/SUMMARY.md:149 msgid "Error Handling" msgstr "" #: src/SUMMARY.md:150 msgid "Panics" msgstr "" #: src/SUMMARY.md:151 msgid "Catching Stack Unwinding" msgstr "" #: src/SUMMARY.md:152 msgid "Structured Error Handling" msgstr "" #: src/SUMMARY.md:153 msgid "Propagating Errors with ?" msgstr "" #: src/SUMMARY.md:154 msgid "Converting Error Types" msgstr "" #: src/SUMMARY.md:155 msgid "Deriving Error Enums" msgstr "" #: src/SUMMARY.md:156 msgid "Adding Context to Errors" msgstr "" #: src/SUMMARY.md:157 msgid "Testing" msgstr "" #: src/SUMMARY.md:158 msgid "Unit Tests" msgstr "" #: src/SUMMARY.md:159 msgid "Test Modules" msgstr "" #: src/SUMMARY.md:160 msgid "Documentation Tests" msgstr "" #: src/SUMMARY.md:161 msgid "Integration Tests" msgstr "" #: src/SUMMARY.md:162 msgid "Unsafe Rust" msgstr "" #: src/SUMMARY.md:163 msgid "Dereferencing Raw Pointers" msgstr "" #: src/SUMMARY.md:164 msgid "Mutable Static Variables" msgstr "" #: src/SUMMARY.md:165 msgid "Calling Unsafe Functions" msgstr "" #: src/SUMMARY.md:166 msgid "Extern Functions" msgstr "" #: src/SUMMARY.md:167 msgid "Unions" msgstr "" #: src/SUMMARY.md:169 msgid "Safe FFI Wrapper" msgstr "" #: src/SUMMARY.md:172 msgid "Day 4: Morning" msgstr "" #: src/SUMMARY.md:177 msgid "Concurrency" msgstr "" #: src/SUMMARY.md:178 msgid "Threads" msgstr "" #: src/SUMMARY.md:179 msgid "Scoped Threads" msgstr "" #: src/SUMMARY.md:180 msgid "Channels" msgstr "" #: src/SUMMARY.md:181 msgid "Unbounded Channels" msgstr "" #: src/SUMMARY.md:182 msgid "Bounded Channels" msgstr "" #: src/SUMMARY.md:183 msgid "Shared State" msgstr "" #: src/SUMMARY.md:184 msgid "Arc" msgstr "" #: src/SUMMARY.md:185 msgid "Mutex" msgstr "" #: src/SUMMARY.md:187 msgid "Send and Sync" msgstr "" #: src/SUMMARY.md:187 msgid "Send" msgstr "" #: src/SUMMARY.md:187 msgid "Sync" msgstr "" #: src/SUMMARY.md:190 msgid "Examples" msgstr "" #: src/SUMMARY.md:192 msgid "Dining Philosophers" msgstr "" #: src/SUMMARY.md:193 msgid "Multi-threaded Link Checker" msgstr "" #: src/SUMMARY.md:195 msgid "Day 4: Afternoon" msgstr "" #: src/SUMMARY.md:199 msgid "Android" msgstr "" #: src/SUMMARY.md:200 msgid "Setup" msgstr "" #: src/SUMMARY.md:201 msgid "Build Rules" msgstr "" #: src/SUMMARY.md:202 msgid "Binary" msgstr "" #: src/SUMMARY.md:203 msgid "Library" msgstr "" #: src/SUMMARY.md:204 msgid "AIDL" msgstr "" #: src/SUMMARY.md:205 msgid "Interface" msgstr "" #: src/SUMMARY.md:206 msgid "Implementation" msgstr "" #: src/SUMMARY.md:207 msgid "Server" msgstr "" #: src/SUMMARY.md:208 msgid "Deploy" msgstr "" #: src/SUMMARY.md:209 msgid "Client" msgstr "" #: src/SUMMARY.md:210 msgid "Changing API" msgstr "" #: src/SUMMARY.md:211 msgid "Logging" msgstr "" #: src/SUMMARY.md:212 msgid "Interoperability" msgstr "" #: src/SUMMARY.md:213 msgid "With C" msgstr "" #: src/SUMMARY.md:214 msgid "Calling C with Bindgen" msgstr "" #: src/SUMMARY.md:215 msgid "Calling Rust from C" msgstr "" #: src/SUMMARY.md:216 msgid "With C++" msgstr "" #: src/SUMMARY.md:217 msgid "With Java" msgstr "" #: src/SUMMARY.md:220 msgid "Final Words" msgstr "" #: src/SUMMARY.md:222 msgid "Thanks!" msgstr "" #: src/SUMMARY.md:223 msgid "Other Resources" msgstr "" #: src/SUMMARY.md:224 msgid "Credits" msgstr "" #: src/SUMMARY.md:228 msgid "Solutions" msgstr "" #: src/SUMMARY.md:233 msgid "Day 1 Morning" msgstr "" #: src/SUMMARY.md:234 msgid "Day 1 Afternoon" msgstr "" #: src/SUMMARY.md:235 msgid "Day 2 Morning" msgstr "" #: src/SUMMARY.md:236 msgid "Day 2 Afternoon" msgstr "" #: src/SUMMARY.md:237 msgid "Day 3 Morning" msgstr "" #: src/SUMMARY.md:238 msgid "Day 3 Afternoon" msgstr "" #: src/SUMMARY.md:239 msgid "Day 4 Morning" msgstr "" #: src/welcome.md:1 msgid "# Welcome to Comprehensive Rust 🦀" msgstr "# Velkommen til Comprehensive Rust 🦀" #: src/welcome.md:3 msgid "" "This is a four day Rust course developed by the Android team. The course " "covers\n" "the full spectrum of Rust, from basic syntax to advanced topics like " "generics\n" "and error handling. It also includes Android-specific content on the last " "day." msgstr "" "Dette er et fire dages Rust-kursus udviklet af Android-teamet. Kurset\n" "dækker hele spektret af Rust, fra grundlæggende syntaks til avancerede\n" "emner som generiske og fejlhåndtering. Det inkluderer også\n" "Android-specifikt indhold på den sidste dag." #: src/welcome.md:7 msgid "" "The goal of the course is to teach you Rust. We assume you don't know " "anything\n" "about Rust and hope to:" msgstr "" "Målet med kurset er at lære dig Rust. Vi antager, at du ikke ved noget\n" "om Rust og håber at:" #: src/welcome.md:10 msgid "" "* Give you a comprehensive understanding of the Rust syntax and language.\n" "* Enable you to modify existing programs and write new programs in Rust.\n" "* Show you common Rust idioms." msgstr "" "* Giver dig en omfattende forståelse af Rust-syntaksen og sproget.\n" "* Gøre det muligt for dig at ændre eksisterende programmer og skrive\n" " nye programmer i Rust.\n" "* Vis dig almindelige Rust idiomer." #: src/welcome.md:14 msgid "On Day 4, we will cover Android-specific things such as:" msgstr "På dag 4 vil vi dække Android-specifikke ting såsom:" #: src/welcome.md:16 msgid "" "* Building Android components in Rust.\n" "* AIDL servers and clients.\n" "* Interoperability with C, C++, and Java." msgstr "" "* Bygning af Android-komponenter i Rust\n" "* AIDL servere og klienter.\n" "* Interoperabilitet med C, C++ og Java." #: src/welcome.md:20 msgid "" "It is important to note that this course does not cover Android " "**application** \n" "development in Rust, and that the Android-specific parts are specifically " "about\n" "writing code for Android itself, the operating system. " msgstr "" "Det er vigtigt at bemærke, at dette kursus ikke dækker\n" "Android-applikationsudvikling i Rust, og at de Android-specifikke dele\n" "specifikt handler om at skrive kode til selve Android styresystemet." #: src/welcome.md:24 msgid "## Non-Goals" msgstr "## Ting som ikke dækkes" #: src/welcome.md:26 msgid "" "Rust is a large language and we won't be able to cover all of it in a few " "days.\n" "Some non-goals of this course are:" msgstr "" "Rust er et stort sprog og vi vil ikke være i stand til at dække det\n" "hele på et par dage. Nogle af ting som vi ikke dækker er:" #: src/welcome.md:29 msgid "" "* Learn how to use async Rust --- we'll only mention async Rust when\n" " covering traditional concurrency primitives. Please see [Asynchronous\n" " Programming in Rust](https://rust-lang.github.io/async-book/) instead for\n" " details on this topic.\n" "* Learn how to develop macros, please see [Chapter 19.5 in the Rust\n" " Book](https://doc.rust-lang.org/book/ch19-06-macros.html) and [Rust by\n" " Example](https://doc.rust-lang.org/rust-by-example/macros.html) instead." msgstr "" #: src/welcome.md:37 msgid "## Assumptions" msgstr "" #: src/welcome.md:39 msgid "" "The course assumes that you already know how to program. Rust is a " "statically\n" "typed language and we will sometimes make comparisons with C and C++ to " "better\n" "explain or contrast the Rust approach." msgstr "" #: src/welcome.md:43 msgid "" "If you know how to program in a dynamically typed language such as Python " "or\n" "JavaScript, then you will be able to follow along just fine too." msgstr "" #: src/welcome.md:46 src/cargo/rust-ecosystem.md:19 #: src/cargo/code-samples.md:22 src/cargo/running-locally.md:68 #: src/welcome-day-1.md:14 src/welcome-day-1/what-is-rust.md:19 #: src/hello-world.md:20 src/hello-world/small-example.md:21 src/why-rust.md:9 #: src/why-rust/compile-time.md:14 src/why-rust/runtime.md:8 #: src/why-rust/modern.md:17 src/basic-syntax/slices.md:18 #: src/basic-syntax/string-slices.md:22 src/exercises/day-1/morning.md:9 #: src/basic-syntax/variables.md:15 src/basic-syntax/type-inference.md:24 #: src/basic-syntax/static-and-const.md:46 #: src/basic-syntax/scopes-shadowing.md:23 src/memory-management/stack.md:26 #: src/memory-management/rust.md:12 src/ownership/move-semantics.md:20 #: src/ownership/moves-function-calls.md:18 src/ownership/copy-clone.md:33 #: src/ownership/borrowing.md:25 src/ownership/shared-unique-borrows.md:23 #: src/ownership/lifetimes-function-calls.md:27 #: src/ownership/lifetimes-data-structures.md:23 #: src/exercises/day-1/afternoon.md:9 src/enums/variant-payloads.md:33 #: src/enums/sizes.md:31 src/exercises/day-2/morning.md:9 #: src/control-flow/if-let-expressions.md:19 src/std/string.md:28 #: src/std/option-result.md:16 src/std/box.md:32 src/std/rc.md:26 #: src/exercises/day-2/afternoon.md:5 src/traits/iterator.md:30 #: src/traits/from-iterator.md:12 src/generics/impl-trait.md:22 #: src/generics/closures.md:23 src/exercises/day-3/morning.md:5 #: src/error-handling/try-operator.md:48 #: src/error-handling/converting-error-types.md:53 #: src/exercises/day-3/afternoon.md:5 src/concurrency/threads.md:28 #: src/exercises/day-4/morning.md:10 src/exercises/day-4/afternoon.md:10 msgid "
" msgstr "" #: src/welcome.md:48 msgid "" "This is an example of a _speaker note_. We will use these to add additional\n" "information to the slides. This could be key points which the instructor " "should\n" "cover as well as answers to typical questions which come up in class." msgstr "" #: src/welcome.md:52 src/cargo/rust-ecosystem.md:67 #: src/cargo/code-samples.md:35 src/cargo/running-locally.md:74 #: src/welcome-day-1.md:42 src/welcome-day-1/what-is-rust.md:27 #: src/hello-world.md:36 src/hello-world/small-example.md:44 src/why-rust.md:24 #: src/why-rust/compile-time.md:33 src/why-rust/runtime.md:22 #: src/why-rust/modern.md:51 src/basic-syntax/compound-types.md:50 #: src/basic-syntax/slices.md:30 src/exercises/day-1/morning.md:28 #: src/basic-syntax/variables.md:20 src/basic-syntax/type-inference.md:44 #: src/basic-syntax/static-and-const.md:52 #: src/basic-syntax/scopes-shadowing.md:37 src/memory-management/stack.md:32 #: src/memory-management/rust.md:18 src/ownership/move-semantics.md:26 #: src/ownership/moves-function-calls.md:25 src/ownership/copy-clone.md:48 #: src/ownership/borrowing.md:51 src/ownership/shared-unique-borrows.md:29 #: src/ownership/lifetimes-function-calls.md:54 #: src/ownership/lifetimes-data-structures.md:30 #: src/exercises/day-1/afternoon.md:15 src/enums/variant-payloads.md:39 #: src/enums/sizes.md:37 src/exercises/day-2/morning.md:15 #: src/control-flow/if-let-expressions.md:25 src/std/string.md:34 #: src/std/option-result.md:25 src/std/box.md:37 src/std/rc.md:32 #: src/exercises/day-2/afternoon.md:11 src/traits/iterator.md:35 #: src/traits/from-iterator.md:23 src/generics/impl-trait.md:31 #: src/generics/closures.md:38 src/exercises/day-3/morning.md:11 #: src/error-handling/try-operator.md:55 #: src/error-handling/converting-error-types.md:60 #: src/exercises/day-3/afternoon.md:11 src/concurrency/threads.md:45 #: src/exercises/day-4/morning.md:16 src/exercises/day-4/afternoon.md:15 msgid "
" msgstr "" #: src/running-the-course.md:1 msgid "# Running the Course" msgstr "" #: src/running-the-course.md:3 src/running-the-course/course-structure.md:3 msgid "> This page is for the course instructor." msgstr "" #: src/running-the-course.md:5 msgid "" "Here is a bit of background information about how we've been running the " "course\n" "internally at Google." msgstr "" #: src/running-the-course.md:8 msgid "To run the course, you need to:" msgstr "" #: src/running-the-course.md:10 msgid "" "1. Make yourself familiar with the course material. We've included speaker " "notes\n" " on some of the pages to help highlight the key points (please help us by\n" " contributing more speaker notes!). You should make sure to open the " "speaker\n" " notes in a popup (click the link with a little arrow next to \"Speaker\n" " Notes\"). This way you have a clean screen to present to the class." msgstr "" #: src/running-the-course.md:16 msgid "" "2. Decide on the dates. Since the course is large, we recommend that you\n" " schedule the four days over two weeks. Course participants have said " "that\n" " they find it helpful to have a gap in the course since it helps them " "process\n" " all the information we give them." msgstr "" #: src/running-the-course.md:21 msgid "" "3. Find a room large enough for your in-person participants. We recommend a\n" " class size of 15-20 people. That's small enough that people are " "comfortable\n" " asking questions --- it's also small enough that one instructor will " "have\n" " time to answer the questions." msgstr "" #: src/running-the-course.md:26 msgid "" "4. On the day of your course, show up to the room a little early to set " "things\n" " up. We recommend presenting directly using `mdbook serve` running on " "your\n" " laptop. This ensures optimal performance with no lag as you change " "pages.\n" " Using your laptop will also allow you to fix typos as you or the course\n" " participants spot them." msgstr "" #: src/running-the-course.md:32 msgid "" "5. Let people solve the exercises by themselves or in small groups. Make " "sure to\n" " ask people if they're stuck or if there is anything you can help with. " "When\n" " you see that several people have the same problem, call it out to the " "class\n" " and offer a solution, e.g., by showing people where to find the relvant\n" " information in the standard library." msgstr "" #: src/running-the-course.md:38 msgid "" "6. If you don't skip the Android specific parts on Day 4, you will need an " "[AOSP\n" " checkout][1]. Make a checkout of the [course repository][2] on the same\n" " machine and move the `src/android/` directory into the root of your AOSP\n" " checkout. This will ensure that the Android build system sees the\n" " `Android.bp` files in `src/android/`." msgstr "" #: src/running-the-course.md:44 msgid "" " Ensure that `adb sync` works with your emulator or real device and pre-" "build\n" " all Android examples using `src/android/build_all.sh`. Read the script to " "see\n" " the commands it runs and make sure they work when you run them by hand." msgstr "" #: src/running-the-course.md:48 msgid "" "That is all, good luck running the course! We hope it will be as much fun " "for\n" "you as it has been for us!" msgstr "" #: src/running-the-course.md:51 msgid "" "Please [provide feedback][3] afterwards so that we can keep improving the\n" "course. We would love to hear what worked well for you and what can be made\n" "better. Your students are also very welcome to [send us feedback][4]!" msgstr "" #: src/running-the-course.md:55 msgid "" "[1]: https://source.android.com/docs/setup/download/downloading\n" "[2]: https://github.com/google/comprehensive-rust\n" "[3]: https://github.com/google/comprehensive-rust/discussions/86\n" "[4]: https://github.com/google/comprehensive-rust/discussions/100" msgstr "" #: src/running-the-course/course-structure.md:1 msgid "# Course Structure" msgstr "" #: src/running-the-course/course-structure.md:5 msgid "The course is fast paced and covers a lot of ground:" msgstr "" #: src/running-the-course/course-structure.md:7 msgid "" "* Day 1: Basic Rust, ownership and the borrow checker.\n" "* Day 2: Compound data types, pattern matching, the standard library.\n" "* Day 3: Traits and generics, error handling, testing, unsafe Rust.\n" "* Day 4: Concurrency in Rust and interoperability with other languages" msgstr "" #: src/running-the-course/course-structure.md:12 msgid "" "> **Exercise for Day 4:** Do you interface with some C/C++ code in your " "project\n" "> which we could attempt to move to Rust? The fewer dependencies the " "better.\n" "> Parsing code would be ideal." msgstr "" #: src/running-the-course/course-structure.md:16 msgid "## Format" msgstr "" #: src/running-the-course/course-structure.md:18 msgid "" "The course is meant to be very interactive and we recommend letting the\n" "questions drive the exploration of Rust!" msgstr "" #: src/running-the-course/keyboard-shortcuts.md:1 msgid "# Keyboard Shortcuts" msgstr "" #: src/running-the-course/keyboard-shortcuts.md:3 msgid "There are several useful keyboard shortcuts in mdBook:" msgstr "" #: src/running-the-course/keyboard-shortcuts.md:5 msgid "" "* Arrow-Left: Navigate to the previous page.\n" "* Arrow-Right: Navigate to the next page.\n" "* Ctrl + Enter: Execute the code sample that has focus.\n" "* s: Activate the search bar." msgstr "" #: src/cargo.md:1 msgid "# Using Cargo" msgstr "" #: src/cargo.md:3 msgid "" "When you start reading about Rust, you will soon meet [Cargo](https://doc." "rust-lang.org/cargo/), the standard tool\n" "used in the Rust ecosystem to build and run Rust applications. Here we want " "to\n" "give a brief overview of what Cargo is and how it fits into the wider " "ecosystem\n" "and how it fits into this training." msgstr "" #: src/cargo.md:8 msgid "## Installation" msgstr "" #: src/cargo.md:10 msgid "### Rustup (Recommended)" msgstr "" #: src/cargo.md:12 msgid "" "You can follow the instructions to install cargo and rust compiler, among " "other standard ecosystem tools with the [rustup][3] tool, which is " "maintained by the Rust Foundation." msgstr "" #: src/cargo.md:14 msgid "" "Along with cargo and rustc, Rustup will install itself as a command line " "utility that you can use to install/switch toolchains, setup cross " "compilation, etc." msgstr "" #: src/cargo.md:16 msgid "### Package Managers" msgstr "" #: src/cargo.md:18 msgid "#### Debian" msgstr "" #: src/cargo.md:20 msgid "On Debian/Ubuntu, you can install Cargo and the Rust source with" msgstr "" #: src/cargo.md:22 msgid "" "```shell\n" "$ sudo apt install cargo rust-src\n" "```" msgstr "" #: src/cargo.md:26 msgid "" "This will allow [rust-analyzer][1] to jump to the definitions. We suggest " "using\n" "[VS Code][2] to edit the code (but any LSP compatible editor works)." msgstr "" #: src/cargo.md:29 msgid "" "Some folks also like to use the [Jetbrains][4] family of IDEs, which do " "their own analysis but have their own tradeoffs. If you prefer them, you can " "install the [Rust Plugin][5]. Please take note that as of January 2023 " "debugging only works on the CLion version of the Jetbrains IDEA suite." msgstr "" #: src/cargo.md:31 msgid "" "[1]: https://rust-analyzer.github.io/\n" "[2]: https://code.visualstudio.com/\n" "[3]: https://rustup.rs/\n" "[4]: https://www.jetbrains.com/clion/\n" "[5]: https://www.jetbrains.com/rust/" msgstr "" #: src/cargo/rust-ecosystem.md:1 msgid "# The Rust Ecosystem" msgstr "" #: src/cargo/rust-ecosystem.md:3 msgid "" "The Rust ecosystem consists of a number of tools, of which the main ones are:" msgstr "" #: src/cargo/rust-ecosystem.md:5 msgid "" "* `rustc`: the Rust compiler which turns `.rs` files into binaries and " "other\n" " intermediate formats[^rustc]." msgstr "" #: src/cargo/rust-ecosystem.md:8 msgid "" "* `cargo`: the Rust dependency manager and build tool. Cargo knows how to\n" " download dependencies hosted on and it will pass them " "to\n" " `rustc` when building your project. Cargo also comes with a built-in test\n" " runner which is used to execute unit tests[^cargo]." msgstr "" #: src/cargo/rust-ecosystem.md:13 msgid "" "* `rustup`: the Rust toolchain installer and updater. This tool is used to\n" " install and update `rustc` and `cargo` when new versions of Rust is " "released.\n" " In addition, `rustup` can also download documentation for the standard\n" " library. You can have multiple versions of Rust installed at once and " "`rustup`\n" " will let you switch between them as needed." msgstr "" #: src/cargo/rust-ecosystem.md:21 src/hello-world.md:25 #: src/hello-world/small-example.md:27 src/why-rust/runtime.md:10 #: src/why-rust/modern.md:19 src/error-handling/try-operator.md:50 #: src/error-handling/converting-error-types.md:55 #: src/concurrency/threads.md:30 msgid "Key points:" msgstr "" #: src/cargo/rust-ecosystem.md:23 msgid "" "* Rust has a rapid release schedule with a new release coming out\n" " every six weeks. New releases maintain backwards compatibility with\n" " old releases --- plus they enable new functionality." msgstr "" #: src/cargo/rust-ecosystem.md:27 msgid "" "* There are three release channels: \"stable\", \"beta\", and \"nightly\"." msgstr "" #: src/cargo/rust-ecosystem.md:29 msgid "" "* New features are being tested on \"nightly\", \"beta\" is what becomes\n" " \"stable\" every six weeks." msgstr "" #: src/cargo/rust-ecosystem.md:32 msgid "" "* Rust also has [editions]: the current edition is Rust 2021. Previous\n" " editions were Rust 2015 and Rust 2018." msgstr "" #: src/cargo/rust-ecosystem.md:35 msgid "" " * The editions are allowed to make backwards incompatible changes to\n" " the language." msgstr "" #: src/cargo/rust-ecosystem.md:38 msgid "" " * To prevent breaking code, editions are opt-in: you select the\n" " edition for your crate via the `Cargo.toml` file." msgstr "" #: src/cargo/rust-ecosystem.md:41 msgid "" " * To avoid splitting the ecosystem, Rust compilers can mix code\n" " written for different editions." msgstr "" #: src/cargo/rust-ecosystem.md:44 msgid "" " * Mention that it is quite rare to ever use the compiler directly not " "through `cargo` (most users never do)." msgstr "" #: src/cargo/rust-ecosystem.md:46 msgid "" " * It might be worth alluding that Cargo itself is an extremely powerful " "and comprehensive tool. It is capable of many advanced features including " "but not limited to: \n" " * Project/package structure\n" " * [workspaces]\n" " * Dev Dependencies and Runtime Dependency management/caching\n" " * [build scripting]\n" " * [global installation]\n" " * It is also extensible with sub command plugins as well (such as " "[cargo clippy]).\n" " * Read more from the [official Cargo Book]" msgstr "" #: src/cargo/rust-ecosystem.md:55 msgid "[editions]: https://doc.rust-lang.org/edition-guide/" msgstr "" #: src/cargo/rust-ecosystem.md:57 msgid "[workspaces]: https://doc.rust-lang.org/cargo/reference/workspaces.html" msgstr "" #: src/cargo/rust-ecosystem.md:59 msgid "" "[build scripting]: https://doc.rust-lang.org/cargo/reference/build-scripts." "html" msgstr "" #: src/cargo/rust-ecosystem.md:61 msgid "" "[global installation]: https://doc.rust-lang.org/cargo/commands/cargo-" "install.html" msgstr "" #: src/cargo/rust-ecosystem.md:63 msgid "[cargo clippy]: https://github.com/rust-lang/rust-clippy" msgstr "" #: src/cargo/rust-ecosystem.md:65 msgid "[official Cargo Book]: https://doc.rust-lang.org/cargo/" msgstr "" #: src/cargo/code-samples.md:1 msgid "# Code Samples in This Training" msgstr "" #: src/cargo/code-samples.md:3 msgid "" "For this training, we will mostly explore the Rust language through " "examples\n" "which can be executed through your browser. This makes the setup much easier " "and\n" "ensures a consistent experience for everyone." msgstr "" #: src/cargo/code-samples.md:7 msgid "" "Installing Cargo is still encouraged: it will make it easier for you to do " "the\n" "exercises. On the last day, we will do a larger exercise which shows you how " "to\n" "work with dependencies and for that you need Cargo." msgstr "" #: src/cargo/code-samples.md:11 msgid "The code blocks in this course are fully interactive:" msgstr "" #: src/cargo/code-samples.md:13 msgid "" "```rust,editable\n" "fn main() {\n" " println!(\"Edit me!\");\n" "}\n" "```" msgstr "" #: src/cargo/code-samples.md:19 msgid "" "You can use Ctrl + Enter to execute the code when focus is in " "the\n" "text box." msgstr "" #: src/cargo/code-samples.md:24 msgid "" "Most code samples are editable like shown above. A few code samples\n" "are not editable for various reasons:" msgstr "" #: src/cargo/code-samples.md:27 msgid "" "* The embedded playgrounds cannot execute unit tests. Copy-paste the\n" " code and open it in the real Playground to demonstrate unit tests." msgstr "" #: src/cargo/code-samples.md:30 msgid "" "* The embedded playgrounds lose their state the moment you navigate\n" " away from the page! This is the reason that the students should\n" " solve the exercises using a local Rust installation or via the\n" " Playground." msgstr "" #: src/cargo/running-locally.md:1 msgid "# Running Code Locally with Cargo" msgstr "" #: src/cargo/running-locally.md:3 msgid "" "If you want to experiment with the code on your own system, then you will " "need\n" "to first install Rust. Do this by following the [instructions in the Rust\n" "Book][1]. This should give you a working `rustc` and `cargo`. At the time " "of\n" "writing, the latest stable Rust release has these version numbers:" msgstr "" #: src/cargo/running-locally.md:8 msgid "" "```shell\n" "% rustc --version\n" "rustc 1.61.0 (fe5b13d68 2022-05-18)\n" "% cargo --version\n" "cargo 1.61.0 (a028ae4 2022-04-29)\n" "```" msgstr "" #: src/cargo/running-locally.md:15 msgid "" "With this is in place, then follow these steps to build a Rust binary from " "one\n" "of the examples in this training:" msgstr "" #: src/cargo/running-locally.md:18 msgid "" "1. Click the \"Copy to clipboard\" button on the example you want to copy." msgstr "" #: src/cargo/running-locally.md:20 msgid "" "2. Use `cargo new exercise` to create a new `exercise/` directory for your " "code:" msgstr "" #: src/cargo/running-locally.md:22 msgid "" " ```shell\n" " $ cargo new exercise\n" " Created binary (application) `exercise` package\n" " ```" msgstr "" #: src/cargo/running-locally.md:27 msgid "" "3. Navigate into `exercise/` and use `cargo run` to build and run your " "binary:" msgstr "" #: src/cargo/running-locally.md:29 msgid "" " ```shell\n" " $ cd exercise\n" " $ cargo run\n" " Compiling exercise v0.1.0 (/home/mgeisler/tmp/exercise)\n" " Finished dev [unoptimized + debuginfo] target(s) in 0.75s\n" " Running `target/debug/exercise`\n" " Hello, world!\n" " ```" msgstr "" #: src/cargo/running-locally.md:38 msgid "" "4. Replace the boiler-plate code in `src/main.rs` with your own code. For\n" " example, using the example on the previous page, make `src/main.rs` look " "like" msgstr "" #: src/cargo/running-locally.md:41 msgid "" " ```rust\n" " fn main() {\n" " println!(\"Edit me!\");\n" " }\n" " ```" msgstr "" #: src/cargo/running-locally.md:47 msgid "5. Use `cargo run` to build and run your updated binary:" msgstr "" #: src/cargo/running-locally.md:49 msgid "" " ```shell\n" " $ cargo run\n" " Compiling exercise v0.1.0 (/home/mgeisler/tmp/exercise)\n" " Finished dev [unoptimized + debuginfo] target(s) in 0.24s\n" " Running `target/debug/exercise`\n" " Edit me!\n" " ```" msgstr "" #: src/cargo/running-locally.md:57 msgid "" "6. Use `cargo check` to quickly check your project for errors, use `cargo " "build`\n" " to compile it without running it. You will find the output in `target/" "debug/`\n" " for a normal debug build. Use `cargo build --release` to produce an " "optimized\n" " release build in `target/release/`." msgstr "" #: src/cargo/running-locally.md:62 msgid "" "7. You can add dependencies for your project by editing `Cargo.toml`. When " "you\n" " run `cargo` commands, it will automatically download and compile missing\n" " dependencies for you." msgstr "" #: src/cargo/running-locally.md:66 msgid "[1]: https://doc.rust-lang.org/book/ch01-01-installation.html" msgstr "" #: src/cargo/running-locally.md:70 msgid "" "Try to encourage the class participants to install Cargo and use a\n" "local editor. It will make their life easier since they will have a\n" "normal development environment." msgstr "" #: src/welcome-day-1.md:1 msgid "# Welcome to Day 1" msgstr "" #: src/welcome-day-1.md:3 msgid "" "This is the first day of Comprehensive Rust. We will cover a lot of ground\n" "today:" msgstr "" #: src/welcome-day-1.md:6 msgid "" "* Basic Rust syntax: variables, scalar and compound types, enums, structs,\n" " references, functions, and methods." msgstr "" #: src/welcome-day-1.md:9 msgid "" "* Memory management: stack vs heap, manual memory management, scope-based " "memory\n" " management, and garbage collection." msgstr "" #: src/welcome-day-1.md:12 msgid "" "* Ownership: move semantics, copying and cloning, borrowing, and lifetimes." msgstr "" #: src/welcome-day-1.md:16 msgid "Please remind the students that:" msgstr "" #: src/welcome-day-1.md:18 msgid "" "* They should ask questions when they get them, don't save them to the end.\n" "* The class is meant to be interactive and discussions are very much " "encouraged!\n" " * As an instructor, you should try to keep the discussions relevant, i." "e.,\n" " keep the related to how Rust does things vs some other language. It can " "be\n" " hard to find the right balance, but err on the side of allowing " "discussions\n" " since they engage people much more than one-way communication.\n" "* The questions will likely mean that we about things ahead of the slides.\n" " * This is perfectly okay! Repetition is an important part of leaning. " "Remember\n" " that the slides are just a support and you are free to skip them as you\n" " like." msgstr "" #: src/welcome-day-1.md:29 msgid "" "The idea for the first day is to show _just enough_ of Rust to be able to " "speak\n" "about the famous borrow checker. The way Rust handles memory is a major " "feature\n" "and we should show students this right away." msgstr "" #: src/welcome-day-1.md:33 msgid "" "If you're teaching this in a classroom, this is a good place to go over the\n" "schedule. We suggest splitting the day into two parts (following the slides):" msgstr "" #: src/welcome-day-1.md:36 msgid "" "* Morning: 9:00 to 12:00,\n" "* Afternoon: 13:00 to 16:00." msgstr "" #: src/welcome-day-1.md:39 msgid "" "You can of course adjust this as necessary. Please make sure to include " "breaks,\n" "we recommend a break every hour!" msgstr "" #: src/welcome-day-1/what-is-rust.md:1 msgid "# What is Rust?" msgstr "" #: src/welcome-day-1/what-is-rust.md:3 msgid "Rust is a new programming language which had its 1.0 release in 2015:" msgstr "" #: src/welcome-day-1/what-is-rust.md:5 msgid "" "* Rust is a statically compiled language in a similar role as C++\n" " * `rustc` uses LLVM as its backend.\n" "* Rust supports many [platforms and\n" " architectures](https://doc.rust-lang.org/nightly/rustc/platform-support." "html):\n" " * x86, ARM, WebAssembly, ...\n" " * Linux, Mac, Windows, ...\n" "* Rust is used for a wide range of devices:\n" " * firmware and boot loaders,\n" " * smart displays,\n" " * mobile phones,\n" " * desktops,\n" " * servers." msgstr "" #: src/welcome-day-1/what-is-rust.md:21 msgid "Rust fits in the same area as C++:" msgstr "" #: src/welcome-day-1/what-is-rust.md:23 msgid "" "* High flexibility.\n" "* High level of control.\n" "* Can be scaled down to very constrained devices like mobile phones." msgstr "" #: src/hello-world.md:1 msgid "# Hello World!" msgstr "" #: src/hello-world.md:3 msgid "" "Let us jump into the simplest possible Rust program, a classic Hello World\n" "program:" msgstr "" #: src/hello-world.md:6 msgid "" "```rust\n" "fn main() {\n" " println!(\"Hello 🌍!\");\n" "}\n" "```" msgstr "" #: src/hello-world.md:12 msgid "What you see:" msgstr "" #: src/hello-world.md:14 msgid "" "* Functions are introduced with `fn`.\n" "* Blocks are delimited by curly braces like in C and C++.\n" "* The `main` function is the entry point of the program.\n" "* Rust has hygienic macros, `println!` is an example of this.\n" "* Rust strings are UTF-8 encoded and can contain any Unicode character." msgstr "" #: src/hello-world.md:22 msgid "" "This slide tries to make the students comfortable with Rust code. They will " "see\n" "a ton of it over the next four days so we start small with something " "familiar." msgstr "" #: src/hello-world.md:27 msgid "" "* Rust is very much like other languages in the C/C++/Java tradition. It is\n" " imperative (not functional) and it doesn't try to reinvent things unless\n" " absolutely necessary." msgstr "" #: src/hello-world.md:31 msgid "* Rust is modern with full support for things like Unicode." msgstr "" #: src/hello-world.md:33 msgid "" "* Rust uses macros for situations where you want to have a variable number " "of\n" " arguments (no function [overloading](basic-syntax/functions-interlude.md))." msgstr "" #: src/hello-world/small-example.md:1 msgid "# Small Example" msgstr "" #: src/hello-world/small-example.md:3 msgid "Here is a small example program in Rust:" msgstr "" #: src/hello-world/small-example.md:5 msgid "" "```rust,editable\n" "fn main() { // Program entry point\n" " let mut x: i32 = 6; // Mutable variable binding\n" " print!(\"{x}\"); // Macro for printing, like printf\n" " while x != 1 { // No parenthesis around expression\n" " if x % 2 == 0 { // Math like in other languages\n" " x = x / 2;\n" " } else {\n" " x = 3 * x + 1;\n" " }\n" " print!(\" -> {x}\");\n" " }\n" " println!();\n" "}\n" "```" msgstr "" #: src/hello-world/small-example.md:23 msgid "" "The code implements the Collatz conjecture: it is believed that the loop " "will\n" "always end, but this is not yet proved. Edit the code and play with " "different\n" "inputs." msgstr "" #: src/hello-world/small-example.md:29 msgid "" "* Explain that all variables are statically typed. Try removing `i32` to " "trigger\n" " type inference. Try with `i8` instead and trigger a runtime integer " "overflow." msgstr "" #: src/hello-world/small-example.md:32 msgid "* Change `let mut x` to `let x`, discuss the compiler error." msgstr "" #: src/hello-world/small-example.md:34 msgid "" "* Show how `print!` gives a compilation error if the arguments don't match " "the\n" " format string." msgstr "" #: src/hello-world/small-example.md:37 msgid "" "* Show how you need to use `{}` as a placeholder if you want to print an\n" " expression which is more complex than just a single variable." msgstr "" #: src/hello-world/small-example.md:40 msgid "" "* Show the students the standard library, show them how to search for `std::" "fmt`\n" " which has the rules of the formatting mini-language. It's important that " "the\n" " students become familiar with searching in the standard library." msgstr "" #: src/why-rust.md:1 msgid "# Why Rust?" msgstr "" #: src/why-rust.md:3 msgid "Some unique selling points of Rust:" msgstr "" #: src/why-rust.md:5 msgid "" "* Compile time memory safety.\n" "* Lack of undefined runtime behavior.\n" "* Modern language features." msgstr "" #: src/why-rust.md:11 msgid "" "Make sure to ask the class which languages they have experience with. " "Depending\n" "on the answer you can highlight different features of Rust:" msgstr "" #: src/why-rust.md:14 msgid "" "* Experience with C or C++: Rust eliminates a whole class of _runtime " "errors_\n" " via the borrow checker. You get performance like in C and C++, but you " "don't\n" " have the memory unsafety issues. In addition, you get a modern language " "with\n" " constructs like pattern matching and built-in dependency management." msgstr "" #: src/why-rust.md:19 msgid "" "* Experience with Java, Go, Python, JavaScript...: You get the same memory " "safety\n" " as in those languages, plus a similar high-level language feeling. In " "addition\n" " you get fast and predictable performance like C and C++ (no garbage " "collector)\n" " as well as access to low-level hardware (should you need it)" msgstr "" #: src/why-rust/compile-time.md:1 msgid "# Compile Time Guarantees" msgstr "" #: src/why-rust/compile-time.md:3 msgid "Static memory management at compile time:" msgstr "" #: src/why-rust/compile-time.md:5 msgid "" "* No uninitialized variables.\n" "* No memory leaks (_mostly_, see notes).\n" "* No double-frees.\n" "* No use-after-free.\n" "* No `NULL` pointers.\n" "* No forgotten locked mutexes.\n" "* No data races between threads.\n" "* No iterator invalidation." msgstr "" #: src/why-rust/compile-time.md:16 msgid "" "It is possible to produce memory leaks in (safe) Rust. Some examples\n" "are:" msgstr "" #: src/why-rust/compile-time.md:19 msgid "" "* You can for use [`Box::leak`] to leak a pointer. A use of this could\n" " be to get runtime-initialized and runtime-sized static variables\n" "* You can use [`std::mem::forget`] to make the compiler \"forget\" about\n" " a value (meaning the destructor is never run).\n" "* You can also accidentally create a [reference cycle] with `Rc` or\n" " `Arc`." msgstr "" #: src/why-rust/compile-time.md:26 msgid "" "For the purpose of this course, \"No memory leaks\" should be understood\n" "as \"Pretty much no *accidental* memory leaks\"." msgstr "" #: src/why-rust/compile-time.md:29 msgid "" "[`Box::leak`]: https://doc.rust-lang.org/std/boxed/struct.Box.html#method." "leak\n" "[`std::mem::forget`]: https://doc.rust-lang.org/std/mem/fn.forget.html\n" "[reference cycle]: https://doc.rust-lang.org/book/ch15-06-reference-cycles." "html" msgstr "" #: src/why-rust/runtime.md:1 msgid "# Runtime Guarantees" msgstr "" #: src/why-rust/runtime.md:3 msgid "No undefined behavior at runtime:" msgstr "" #: src/why-rust/runtime.md:5 msgid "" "* Array access is bounds checked.\n" "* Integer overflow is defined." msgstr "" #: src/why-rust/runtime.md:12 msgid "" "* Integer overflow is defined via a compile-time flag. The options are\n" " either a panic (a controlled crash of the program) or wrap-around\n" " semantics. By default, you get panics in debug mode (`cargo build`)\n" " and wrap-around in release mode (`cargo build --release`)." msgstr "" #: src/why-rust/runtime.md:17 msgid "" "* Bounds checking cannot be disabled with a compiler flag. It can also\n" " not be disabled directly with the `unsafe` keyword. However,\n" " `unsafe` allows you to call functions such as `slice::get_unchecked`\n" " which does not do bounds checking." msgstr "" #: src/why-rust/modern.md:1 msgid "# Modern Features" msgstr "" #: src/why-rust/modern.md:3 msgid "Rust is built with all the experience gained in the last 40 years." msgstr "" #: src/why-rust/modern.md:5 msgid "## Language Features" msgstr "" #: src/why-rust/modern.md:7 msgid "" "* Enums and pattern matching.\n" "* Generics.\n" "* No overhead FFI." msgstr "" #: src/why-rust/modern.md:11 msgid "## Tooling" msgstr "" #: src/why-rust/modern.md:13 msgid "" "* Great compiler errors.\n" "* Built-in dependency manager.\n" "* Built-in support for testing." msgstr "" #: src/why-rust/modern.md:21 msgid "" "* Remind people to read the errors --- many developers have gotten used to\n" " ignore lengthly compiler output. The Rust compiler is significantly more\n" " talkative than other compilers. It will often provide you with " "_actionable_\n" " feedback, ready to copy-paste into your code." msgstr "" #: src/why-rust/modern.md:26 msgid "" "* The Rust standard library is small compared to languages like Java, " "Python,\n" " and Go. Rust does not come with several things you might consider standard " "and\n" " essential:" msgstr "" #: src/why-rust/modern.md:30 msgid "" " * a random number generator, but see [rand].\n" " * support for SSL or TLS, but see [rusttls].\n" " * support for JSON, but see [serde_json]." msgstr "" #: src/why-rust/modern.md:34 msgid "" " The reasoning behind this is that functionality in the standard library " "cannot\n" " go away, so it has to be very stable. For the examples above, the Rust\n" " community is still working on finding the best solution --- and perhaps " "there\n" " isn't a single \"best solution\" for some of these things." msgstr "" #: src/why-rust/modern.md:39 msgid "" " Rust comes with a built-in package manager in the form of Cargo and this " "makes\n" " it trivial to download and compile third-party crates. A consequence of " "this\n" " is that the standard library can be smaller." msgstr "" #: src/why-rust/modern.md:43 msgid "" " Discovering good third-party crates can be a problem. Sites like\n" " help with this by letting you compare health metrics " "for\n" " crates to find a good and trusted one." msgstr "" #: src/why-rust/modern.md:47 msgid "" "[rand]: https://docs.rs/rand/\n" "[rusttls]: https://docs.rs/rustls/\n" "[serde_json]: https://docs.rs/serde_json/" msgstr "" #: src/basic-syntax.md:1 msgid "# Basic Syntax" msgstr "" #: src/basic-syntax.md:3 msgid "Much of the Rust syntax will be familiar to you from C or C++:" msgstr "" #: src/basic-syntax.md:5 msgid "" "* Blocks and scopes are delimited by curly braces.\n" "* Line comments are started with `//`, block comments are delimited by `/" "* ...\n" " */`.\n" "* Keywords like `if` and `while` work the same.\n" "* Variable assignment is done with `=`, comparison is done with `==`." msgstr "" #: src/basic-syntax/scalar-types.md:1 msgid "# Scalar Types" msgstr "" #: src/basic-syntax/scalar-types.md:3 msgid "" "| | Types | " "Literals |\n" "|------------------------|--------------------------------------------|-------------------------------|\n" "| Signed integers | `i8`, `i16`, `i32`, `i64`, `i128`, `isize` | " "`-10`, `0`, `1_000`, `123i64` |\n" "| Unsigned integers | `u8`, `u16`, `u32`, `u64`, `u128`, `usize` | `0`, " "`123`, `10u16` |\n" "| Floating point numbers | `f32`, `f64` | " "`3.14`, `-10.0e20`, `2f32` |\n" "| Strings | `&str` | " "`\"foo\"`, `r#\"\\\\\"#` |\n" "| Unicode scalar values | `char` | " "`'a'`, `'α'`, `'∞'` |\n" "| Byte strings | `&[u8]` | " "`b\"abc\"`, `br#\" \" \"#` |\n" "| Booleans | `bool` | " "`true`, `false` |" msgstr "" #: src/basic-syntax/scalar-types.md:13 msgid "The types have widths as follows:" msgstr "" #: src/basic-syntax/scalar-types.md:15 msgid "" "* `iN`, `uN`, and `fN` are _N_ bits wide,\n" "* `isize` and `usize` are the width of a pointer,\n" "* `char` is 32 bit wide,\n" "* `bool` is 8 bit wide." msgstr "" #: src/basic-syntax/compound-types.md:1 msgid "# Compound Types" msgstr "" #: src/basic-syntax/compound-types.md:3 msgid "" "| | Types | Literals " "|\n" "|--------|-------------------------------|-----------------------------------|\n" "| Arrays | `[T; N]` | `[20, 30, 40]`, `[0; 3]` " "|\n" "| Tuples | `()`, `(T,)`, `(T1, T2)`, ... | `()`, `('x',)`, `('x', 1.2)`, ... " "|" msgstr "" #: src/basic-syntax/compound-types.md:8 msgid "Array assignment and access:" msgstr "" #: src/basic-syntax/compound-types.md:10 msgid "" "```rust,editable\n" "fn main() {\n" " let mut a: [i8; 10] = [42; 10];\n" " a[5] = 0;\n" " println!(\"a: {:?}\", a);\n" "}\n" "```" msgstr "" #: src/basic-syntax/compound-types.md:18 msgid "Tuple assignment and access:" msgstr "" #: src/basic-syntax/compound-types.md:20 msgid "" "```rust,editable\n" "fn main() {\n" " let t: (i8, bool) = (7, true);\n" " println!(\"1st index: {}\", t.0);\n" " println!(\"2nd index: {}\", t.1);\n" "}\n" "```" msgstr "" #: src/basic-syntax/compound-types.md:28 msgid "" "
\n" " \n" "Key points:\n" " \n" "Arrays:\n" " \n" "* Arrays have elements of the same type, `T`, and length, `N`, which is a " "compile-time constant." msgstr "" #: src/basic-syntax/compound-types.md:36 msgid "* We can use literals to assign values to arrays." msgstr "" #: src/basic-syntax/compound-types.md:38 msgid "" "* In the main function, the print statement asks for the debug " "implementation with the `?` format parameter: `{a}` gives the default " "output, `{a:?}` gives the debug output." msgstr "" #: src/basic-syntax/compound-types.md:40 msgid "" "* Adding `#`, eg `{a:#?}`, invokes a \"pretty printing\" format, which can " "be easier to read." msgstr "" #: src/basic-syntax/compound-types.md:42 msgid "Tuples:" msgstr "" #: src/basic-syntax/compound-types.md:44 msgid "* Like arrays, tuples have a fixed length." msgstr "" #: src/basic-syntax/compound-types.md:46 msgid "* Tuples group together values of different types into a compound type." msgstr "" #: src/basic-syntax/compound-types.md:48 msgid "" "* Fields that can be accessed by the period and the index of the value, e.g. " "`t.0`, `t.1`." msgstr "" #: src/basic-syntax/references.md:1 msgid "# References" msgstr "" #: src/basic-syntax/references.md:3 msgid "Like C++, Rust has references:" msgstr "" #: src/basic-syntax/references.md:5 msgid "" "```rust,editable\n" "fn main() {\n" " let mut x: i32 = 10;\n" " let ref_x: &mut i32 = &mut x;\n" " *ref_x = 20;\n" " println!(\"x: {x}\");\n" "}\n" "```" msgstr "" #: src/basic-syntax/references.md:14 msgid "Some differences from C++:" msgstr "" #: src/basic-syntax/references.md:16 msgid "" "* We must dereference `ref_x` when assigning to it, similar to C pointers,\n" "* Rust will auto-dereference in some cases, in particular when invoking\n" " methods (try `count_ones`).\n" "* References that are declared as `mut` can be bound to different values " "over their lifetime." msgstr "" #: src/basic-syntax/references-dangling.md:1 msgid "# Dangling References" msgstr "" #: src/basic-syntax/references-dangling.md:3 msgid "Rust will statically forbid dangling references:" msgstr "" #: src/basic-syntax/references-dangling.md:5 msgid "" "```rust,editable,compile_fail\n" "fn main() {\n" " let ref_x: &i32;\n" " {\n" " let x: i32 = 10;\n" " ref_x = &x;\n" " }\n" " println!(\"ref_x: {ref_x}\");\n" "}\n" "```" msgstr "" #: src/basic-syntax/references-dangling.md:16 msgid "" "* A reference is said to \"borrow\" the value it refers to.\n" "* Rust is tracking the lifetimes of all references to ensure they live long\n" " enough.\n" "* We will talk more about borrowing when we get to ownership." msgstr "" #: src/basic-syntax/slices.md:1 msgid "# Slices" msgstr "" #: src/basic-syntax/slices.md:3 msgid "A slice gives you a view into a larger collection:" msgstr "" #: src/basic-syntax/slices.md:5 msgid "" "```rust,editable\n" "fn main() {\n" " let a: [i32; 6] = [10, 20, 30, 40, 50, 60];\n" " println!(\"a: {a:?}\");" msgstr "" #: src/basic-syntax/slices.md:10 msgid "" " let s: &[i32] = &a[2..4];\n" " println!(\"s: {s:?}\");\n" "}\n" "```" msgstr "" #: src/basic-syntax/slices.md:15 msgid "" "* Slices borrow data from the sliced type.\n" "* Question: What happens if you modify `a[3]`?" msgstr "" #: src/basic-syntax/slices.md:20 msgid "" "* We create a slice by borrowing `a` and specifying the starting and ending " "indexes in brackets." msgstr "" #: src/basic-syntax/slices.md:22 msgid "" "* If the slice starts at index 0, Rust’s range syntax means we can drop the " "starting index. \n" " \n" "* The same is true for the last index, so `&a[2..a.len()]` and `&a[2..]` are " "equal." msgstr "" #: src/basic-syntax/slices.md:26 msgid "" "* `s` is a reference to a slice of `i32`s. Notice that the type of `s` no " "longer mentions the array length. This allows us to performing computations " "on slices of different sizes.\n" " \n" "* Slices always borrow from another object. In this example, `a` has to " "remain 'alive' so we can take a slice from it. " msgstr "" #: src/basic-syntax/string-slices.md:1 msgid "# `String` vs `str`" msgstr "" #: src/basic-syntax/string-slices.md:3 msgid "We can now understand the two string types in Rust:" msgstr "" #: src/basic-syntax/string-slices.md:5 msgid "" "```rust,editable\n" "fn main() {\n" " let s1: &str = \"Hello\";\n" " println!(\"s1: {s1}\");" msgstr "" #: src/basic-syntax/string-slices.md:10 msgid "" " let mut s2: String = String::from(\"Hello \");\n" " println!(\"s2: {s2}\");\n" " s2.push_str(s1);\n" " println!(\"s2: {s2}\");\n" "}\n" "```" msgstr "" #: src/basic-syntax/string-slices.md:17 msgid "Rust terminology:" msgstr "" #: src/basic-syntax/string-slices.md:19 msgid "" "* `&str` an immutable reference to a string slice.\n" "* `String` a mutable string buffer." msgstr "" #: src/basic-syntax/string-slices.md:24 msgid "" "* `&str` introduces a string slice, which is an immutable reference to UTF-8 " "encoded string data stored in a block of memory. String literals " "(`”Hello”`), are stored in the program’s binary." msgstr "" #: src/basic-syntax/string-slices.md:26 msgid "" "* Rust’s `String` type is a wrapper around a vector of bytes. As with a " "`Vec`, it is mutable and owned." msgstr "" #: src/basic-syntax/string-slices.md:28 msgid "" "* `String::from` creates a string from a string literal; `String::new` " "creates a new empty string, to which string data can be added using the " "`to_string` method." msgstr "" #: src/basic-syntax/string-slices.md:30 msgid "" "* The `push_str` method appends a string slice to the string.\n" " \n" "
" msgstr "" #: src/basic-syntax/functions.md:1 msgid "# Functions" msgstr "" #: src/basic-syntax/functions.md:3 msgid "" "A Rust version of the famous [FizzBuzz](https://en.wikipedia.org/wiki/" "Fizz_buzz) interview question:" msgstr "" #: src/basic-syntax/functions.md:5 msgid "" "```rust,editable\n" "fn main() {\n" " fizzbuzz_to(20); // Defined below, no forward declaration needed\n" "}" msgstr "" #: src/basic-syntax/functions.md:10 msgid "" "fn is_divisible_by(lhs: u32, rhs: u32) -> bool {\n" " if rhs == 0 {\n" " return false; // Corner case, early return\n" " }\n" " lhs % rhs == 0 // The last expression is the return value\n" "}" msgstr "" #: src/basic-syntax/functions.md:17 msgid "" "fn fizzbuzz(n: u32) -> () { // No return value means returning the unit " "type `()`\n" " match (is_divisible_by(n, 3), is_divisible_by(n, 5)) {\n" " (true, true) => println!(\"fizzbuzz\"),\n" " (true, false) => println!(\"fizz\"),\n" " (false, true) => println!(\"buzz\"),\n" " (false, false) => println!(\"{n}\"),\n" " }\n" "}" msgstr "" #: src/basic-syntax/functions.md:26 msgid "" "fn fizzbuzz_to(n: u32) { // `-> ()` is normally omitted\n" " for n in 1..=n {\n" " fizzbuzz(n);\n" " }\n" "}\n" "```" msgstr "" #: src/basic-syntax/methods.md:1 src/methods.md:1 msgid "# Methods" msgstr "" #: src/basic-syntax/methods.md:3 msgid "" "Rust has methods, they are simply functions that are associated with a " "particular type. The\n" "first argument of a method is an instance of the type it is associated with:" msgstr "" #: src/basic-syntax/methods.md:6 msgid "" "```rust,editable\n" "struct Rectangle {\n" " width: u32,\n" " height: u32,\n" "}" msgstr "" #: src/basic-syntax/methods.md:12 msgid "" "impl Rectangle {\n" " fn area(&self) -> u32 {\n" " self.width * self.height\n" " }" msgstr "" #: src/basic-syntax/methods.md:17 msgid "" " fn inc_width(&mut self, delta: u32) {\n" " self.width += delta;\n" " }\n" "}" msgstr "" #: src/basic-syntax/methods.md:22 msgid "" "fn main() {\n" " let mut rect = Rectangle { width: 10, height: 5 };\n" " println!(\"old area: {}\", rect.area());\n" " rect.inc_width(5);\n" " println!(\"new area: {}\", rect.area());\n" "}\n" "```" msgstr "" #: src/basic-syntax/methods.md:30 msgid "" "* We will look much more at methods in today's exercise and in tomorrow's " "class." msgstr "" #: src/basic-syntax/functions-interlude.md:1 msgid "# Function Overloading" msgstr "" #: src/basic-syntax/functions-interlude.md:3 msgid "Overloading is not supported:" msgstr "" #: src/basic-syntax/functions-interlude.md:5 msgid "" "* Each function has a single implementation:\n" " * Always takes a fixed number of parameters.\n" " * Always takes a single set of parameter types.\n" "* Default values are not supported:\n" " * All call sites have the same number of arguments.\n" " * Macros are sometimes used as an alternative." msgstr "" #: src/basic-syntax/functions-interlude.md:12 msgid "However, function parameters can be generic:" msgstr "" #: src/basic-syntax/functions-interlude.md:14 msgid "" "```rust,editable\n" "fn pick_one(a: T, b: T) -> T {\n" " if std::process::id() % 2 == 0 { a } else { b }\n" "}" msgstr "" #: src/basic-syntax/functions-interlude.md:19 msgid "" "fn main() {\n" " println!(\"coin toss: {}\", pick_one(\"heads\", \"tails\"));\n" " println!(\"cash prize: {}\", pick_one(500, 1000));\n" "}\n" "```" msgstr "" #: src/exercises/day-1/morning.md:1 msgid "# Day 1: Morning Exercises" msgstr "" #: src/exercises/day-1/morning.md:3 msgid "In these exercises, we will explore two parts of Rust:" msgstr "" #: src/exercises/day-1/morning.md:5 msgid "* Implicit conversions between types." msgstr "" #: src/exercises/day-1/morning.md:7 msgid "* Arrays and `for` loops." msgstr "" #: src/exercises/day-1/morning.md:11 msgid "A few things to consider while solving the exercises:" msgstr "" #: src/exercises/day-1/morning.md:13 msgid "" "* Use a local Rust installation, if possible. This way you can get\n" " auto-completion in your editor. See the page about [Using Cargo] for " "details\n" " on installing Rust." msgstr "" #: src/exercises/day-1/morning.md:17 msgid "* Alternatively, use the Rust Playground." msgstr "" #: src/exercises/day-1/morning.md:19 msgid "" "The code snippets are not editable on purpose: the inline code snippets " "lose\n" "their state if you navigate away from the page." msgstr "" #: src/exercises/day-1/morning.md:22 src/exercises/day-1/afternoon.md:11 #: src/exercises/day-2/morning.md:11 src/exercises/day-2/afternoon.md:7 #: src/exercises/day-3/morning.md:7 src/exercises/day-4/morning.md:12 msgid "" "After looking at the exercises, you can look at the [solutions] provided." msgstr "" #: src/exercises/day-1/morning.md:24 src/exercises/day-2/morning.md:13 #: src/exercises/day-3/morning.md:9 src/exercises/day-4/morning.md:14 msgid "[solutions]: solutions-morning.md" msgstr "" #: src/exercises/day-1/morning.md:26 msgid "[Using Cargo]: ../../cargo.md" msgstr "" #: src/exercises/day-1/implicit-conversions.md:1 msgid "# Implicit Conversions" msgstr "" #: src/exercises/day-1/implicit-conversions.md:3 msgid "" "Rust will not automatically apply _implicit conversions_ between types " "([unlike\n" "C++][3]). You can see this in a program like this:" msgstr "" #: src/exercises/day-1/implicit-conversions.md:6 msgid "" "```rust,editable,compile_fail\n" "fn multiply(x: i16, y: i16) -> i16 {\n" " x * y\n" "}" msgstr "" #: src/exercises/day-1/implicit-conversions.md:11 msgid "" "fn main() {\n" " let x: i8 = 15;\n" " let y: i16 = 1000;" msgstr "" #: src/exercises/day-1/implicit-conversions.md:15 msgid "" " println!(\"{x} * {y} = {}\", multiply(x, y));\n" "}\n" "```" msgstr "" #: src/exercises/day-1/implicit-conversions.md:19 msgid "" "The Rust integer types all implement the [`From`][1] and [`Into`][2]\n" "traits to let us convert between them. The `From` trait has a single " "`from()`\n" "method and similarly, the `Into` trait has a single `into()` method.\n" "Implementing these traits is how a type expresses that it can be converted " "into\n" "another type." msgstr "" #: src/exercises/day-1/implicit-conversions.md:25 msgid "" "The standard library has an implementation of `From for i16`, which " "means\n" "that we can convert a variable `x` of type `i8` to an `i16` by calling \n" "`i16::from(x)`. Or, simpler, with `x.into()`, because `From for i16`\n" "implementation automatically create an implementation of `Into for i8`." msgstr "" #: src/exercises/day-1/implicit-conversions.md:30 msgid "1. Execute the above program and look at the compiler error." msgstr "" #: src/exercises/day-1/implicit-conversions.md:32 msgid "2. Update the code above to use `into()` to do the conversion." msgstr "" #: src/exercises/day-1/implicit-conversions.md:34 msgid "" "3. Change the types of `x` and `y` to other things (such as `f32`, `bool`,\n" " `i128`) to see which types you can convert to which other types. Try\n" " converting small types to big types and the other way around. Check the\n" " [standard library documentation][1] to see if `From` is implemented " "for\n" " the pairs you check." msgstr "" #: src/exercises/day-1/implicit-conversions.md:40 msgid "" "[1]: https://doc.rust-lang.org/std/convert/trait.From.html\n" "[2]: https://doc.rust-lang.org/std/convert/trait.Into.html\n" "[3]: https://en.cppreference.com/w/cpp/language/implicit_conversion" msgstr "" #: src/exercises/day-1/for-loops.md:1 msgid "# Arrays and `for` Loops" msgstr "" #: src/exercises/day-1/for-loops.md:3 msgid "We saw that an array can be declared like this:" msgstr "" #: src/exercises/day-1/for-loops.md:5 msgid "" "```rust\n" "let array = [10, 20, 30];\n" "```" msgstr "" #: src/exercises/day-1/for-loops.md:9 msgid "" "You can print such an array by asking for its debug representation with `{:?}" "`:" msgstr "" #: src/exercises/day-1/for-loops.md:11 msgid "" "```rust,editable\n" "fn main() {\n" " let array = [10, 20, 30];\n" " println!(\"array: {array:?}\");\n" "}\n" "```" msgstr "" #: src/exercises/day-1/for-loops.md:18 msgid "" "Rust lets you iterate over things like arrays and ranges using the `for`\n" "keyword:" msgstr "" #: src/exercises/day-1/for-loops.md:21 msgid "" "```rust,editable\n" "fn main() {\n" " let array = [10, 20, 30];\n" " print!(\"Iterating over array:\");\n" " for n in array {\n" " print!(\" {n}\");\n" " }\n" " println!();" msgstr "" #: src/exercises/day-1/for-loops.md:30 msgid "" " print!(\"Iterating over range:\");\n" " for i in 0..3 {\n" " print!(\" {}\", array[i]);\n" " }\n" " println!();\n" "}\n" "```" msgstr "" #: src/exercises/day-1/for-loops.md:38 msgid "" "Use the above to write a function `pretty_print` which pretty-print a matrix " "and\n" "a function `transpose` which will transpose a matrix (turn rows into " "columns):" msgstr "" #: src/exercises/day-1/for-loops.md:41 msgid "" "```bob\n" " ⎛⎡1 2 3⎤⎞ ⎡1 4 7⎤\n" "\"transpose\"⎜⎢4 5 6⎥⎟ \"==\"⎢2 5 8⎥\n" " ⎝⎣7 8 9⎦⎠ ⎣3 6 9⎦\n" "```" msgstr "" "```bob\n" " ⎛⎡1 2 3⎤⎞ ⎡1 4 7⎤\n" "\"transpose\"⎜⎢4 5 6⎥⎟ \"==\"⎢2 5 8⎥\n" " ⎝⎣7 8 9⎦⎠ ⎣3 6 9⎦\n" "```" #: src/exercises/day-1/for-loops.md:47 msgid "Hard-code both functions to operate on 3 × 3 matrices." msgstr "" #: src/exercises/day-1/for-loops.md:49 msgid "" "Copy the code below to and implement the\n" "functions:" msgstr "" #: src/exercises/day-1/for-loops.md:52 src/exercises/day-1/book-library.md:20 #: src/exercises/day-2/health-statistics.md:13 msgid "" "```rust,should_panic\n" "// TODO: remove this when you're done with your implementation.\n" "#![allow(unused_variables, dead_code)]" msgstr "" #: src/exercises/day-1/for-loops.md:56 msgid "" "fn transpose(matrix: [[i32; 3]; 3]) -> [[i32; 3]; 3] {\n" " unimplemented!()\n" "}" msgstr "" #: src/exercises/day-1/for-loops.md:60 msgid "" "fn pretty_print(matrix: &[[i32; 3]; 3]) {\n" " unimplemented!()\n" "}" msgstr "" #: src/exercises/day-1/for-loops.md:64 msgid "" "fn main() {\n" " let matrix = [\n" " [101, 102, 103], // <-- the comment makes rustfmt add a newline\n" " [201, 202, 203],\n" " [301, 302, 303],\n" " ];" msgstr "" #: src/exercises/day-1/for-loops.md:71 #: src/exercises/day-1/solutions-morning.md:70 msgid "" " println!(\"matrix:\");\n" " pretty_print(&matrix);" msgstr "" #: src/exercises/day-1/for-loops.md:74 msgid "" " let transposed = transpose(matrix);\n" " println!(\"transposed:\");\n" " pretty_print(&transposed);\n" "}\n" "```" msgstr "" #: src/exercises/day-1/for-loops.md:80 msgid "## Bonus Question" msgstr "" #: src/exercises/day-1/for-loops.md:82 msgid "" "Could you use `&[i32]` slices instead of hard-coded 3 × 3 matrices for your\n" "argument and return types? Something like `&[&[i32]]` for a two-dimensional\n" "slice-of-slices. Why or why not?" msgstr "" #: src/exercises/day-1/for-loops.md:87 msgid "" "See the [`ndarray` crate](https://docs.rs/ndarray/) for a production " "quality\n" "implementation." msgstr "" #: src/basic-syntax/variables.md:1 msgid "# Variables" msgstr "" #: src/basic-syntax/variables.md:3 msgid "" "Rust provides type safety via static typing. Variable bindings are immutable " "by\n" "default:" msgstr "" #: src/basic-syntax/variables.md:6 msgid "" "```rust,editable\n" "fn main() {\n" " let x: i32 = 10;\n" " println!(\"x: {x}\");\n" " // x = 20;\n" " // println!(\"x: {x}\");\n" "}\n" "```" msgstr "" #: src/basic-syntax/variables.md:17 msgid "" "* Due to type inference the `i32` is optional. We will gradually show the " "types less and less as the type progresses.\n" "* Note that since `println!` is a macro, `x` is not moved, even using the " "function like syntax of `println!(\"x: {}\", x)`" msgstr "" #: src/basic-syntax/type-inference.md:1 msgid "# Type Inference" msgstr "" #: src/basic-syntax/type-inference.md:3 msgid "Rust will look at how the variable is _used_ to determine the type:" msgstr "" #: src/basic-syntax/type-inference.md:5 msgid "" "```rust,editable\n" "fn takes_u32(x: u32) {\n" " println!(\"u32: {x}\");\n" "}" msgstr "" #: src/basic-syntax/type-inference.md:10 msgid "" "fn takes_i8(y: i8) {\n" " println!(\"i8: {y}\");\n" "}" msgstr "" #: src/basic-syntax/type-inference.md:14 msgid "" "fn main() {\n" " let x = 10;\n" " let y = 20;" msgstr "" #: src/basic-syntax/type-inference.md:18 msgid "" " takes_u32(x);\n" " takes_i8(y);\n" " // takes_u32(y);\n" "}\n" "```" msgstr "" #: src/basic-syntax/type-inference.md:26 msgid "" "This slide demonstrates how the Rust compiler infers types based on " "constraints given by variable declarations and usages." msgstr "" #: src/basic-syntax/type-inference.md:28 msgid "" "The following code tells the compiler to copy into a certain generic " "container without the code ever explicitly specifying the contained type, " "using `_` as a placeholder:" msgstr "" #: src/basic-syntax/type-inference.md:30 msgid "" "```rust,editable\n" "fn main() {\n" " let mut v = Vec::new();\n" " v.push((10, false));\n" " v.push((20, true));\n" " println!(\"v: {v:?}\");" msgstr "" #: src/basic-syntax/type-inference.md:37 msgid "" " let vv = v.iter().collect::>();\n" " println!(\"vv: {vv:?}\");\n" "}\n" "```" msgstr "" #: src/basic-syntax/type-inference.md:42 msgid "" "[`collect`](https://doc.rust-lang.org/stable/std/iter/trait.Iterator." "html#method.collect) relies on `FromIterator`, which [`HashSet`](https://doc." "rust-lang.org/std/iter/trait.FromIterator.html) implements." msgstr "" #: src/basic-syntax/static-and-const.md:1 msgid "# Static and Constant Variables" msgstr "" #: src/basic-syntax/static-and-const.md:3 msgid "Global state is managed with static and constant variables." msgstr "" #: src/basic-syntax/static-and-const.md:5 msgid "## `const`" msgstr "" #: src/basic-syntax/static-and-const.md:7 msgid "You can declare compile-time constants:" msgstr "" #: src/basic-syntax/static-and-const.md:9 msgid "" "```rust,editable\n" "const DIGEST_SIZE: usize = 3;\n" "const ZERO: Option = Some(42);" msgstr "" #: src/basic-syntax/static-and-const.md:13 msgid "" "fn compute_digest(text: &str) -> [u8; DIGEST_SIZE] {\n" " let mut digest = [ZERO.unwrap_or(0); DIGEST_SIZE];\n" " for (idx, &b) in text.as_bytes().iter().enumerate() {\n" " digest[idx % DIGEST_SIZE] = digest[idx % DIGEST_SIZE]." "wrapping_add(b);\n" " }\n" " digest\n" "}" msgstr "" #: src/basic-syntax/static-and-const.md:21 msgid "" "fn main() {\n" " let digest = compute_digest(\"Hello\");\n" " println!(\"Digest: {digest:?}\");\n" "}\n" "```" msgstr "" #: src/basic-syntax/static-and-const.md:27 msgid "According the the [Rust RFC Book][1] these are inlined upon use." msgstr "" #: src/basic-syntax/static-and-const.md:29 msgid "## `static`" msgstr "" #: src/basic-syntax/static-and-const.md:31 msgid "You can also declare static variables:" msgstr "" #: src/basic-syntax/static-and-const.md:33 msgid "" "```rust,editable\n" "static BANNER: &str = \"Welcome to RustOS 3.14\";" msgstr "" #: src/basic-syntax/static-and-const.md:36 msgid "" "fn main() {\n" " println!(\"{BANNER}\");\n" "}\n" "```" msgstr "" #: src/basic-syntax/static-and-const.md:41 msgid "" "As noted in the [Rust RFC Book][1], these are not inlined upon use and have " "an actual associated memory location. This is useful for unsafe and " "embedded code, and have a `'static` lifetime." msgstr "" #: src/basic-syntax/static-and-const.md:44 msgid "" "We will look at mutating static data in the [chapter on Unsafe Rust](../" "unsafe.md)." msgstr "" #: src/basic-syntax/static-and-const.md:48 msgid "" "* Mention that `const` behaves semantically similar to C++'s `constexpr`.\n" "* `static`, on the other hand, is much more similar to a `const` or mutable " "global variable in C++.\n" "* It isn't super common that one would need a runtime evaluated constant, " "but it is helpful and safer than using a static." msgstr "" #: src/basic-syntax/static-and-const.md:54 msgid "[1]: https://rust-lang.github.io/rfcs/0246-const-vs-static.html" msgstr "" #: src/basic-syntax/scopes-shadowing.md:1 msgid "# Scopes and Shadowing" msgstr "" #: src/basic-syntax/scopes-shadowing.md:3 msgid "" "You can shadow variables, both those from outer scopes and variables from " "the\n" "same scope:" msgstr "" #: src/basic-syntax/scopes-shadowing.md:6 msgid "" "```rust,editable\n" "fn main() {\n" " let a = 10;\n" " println!(\"before: {a}\");" msgstr "" #: src/basic-syntax/scopes-shadowing.md:11 msgid "" " {\n" " let a = \"hello\";\n" " println!(\"inner scope: {a}\");" msgstr "" #: src/basic-syntax/scopes-shadowing.md:15 msgid "" " let a = true;\n" " println!(\"shadowed in inner scope: {a}\");\n" " }" msgstr "" #: src/basic-syntax/scopes-shadowing.md:19 msgid "" " println!(\"after: {a}\");\n" "}\n" "```" msgstr "" #: src/basic-syntax/scopes-shadowing.md:25 msgid "" "* Shadowing looks obscure at first, but is convenient for holding on to " "values after `.unwrap()`.\n" "* The following code demonstrates why the compiler can't simply reuse memory " "locations when shadowing an immutable variable in a scope, even if the type " "does not change." msgstr "" #: src/basic-syntax/scopes-shadowing.md:28 msgid "" "```rust,editable\n" "fn main() {\n" " let a = 1;\n" " let b = &a;\n" " let a = a + 1;\n" " println!(\"{a} {b}\");\n" "}\n" "```" msgstr "" #: src/memory-management.md:1 msgid "# Memory Management" msgstr "" #: src/memory-management.md:3 msgid "Traditionally, languages have fallen into two broad categories:" msgstr "" #: src/memory-management.md:5 msgid "" "* Full control via manual memory management: C, C++, Pascal, ...\n" "* Full safety via automatic memory management at runtime: Java, Python, Go, " "Haskell, ..." msgstr "" #: src/memory-management.md:8 msgid "Rust offers a new mix:" msgstr "" #: src/memory-management.md:10 msgid "" "> Full control *and* safety via compile time enforcement of correct memory\n" "> management." msgstr "" #: src/memory-management.md:13 msgid "It does this with an explicit ownership concept." msgstr "" #: src/memory-management.md:15 msgid "First, let's refresh how memory management works." msgstr "" #: src/memory-management/stack-vs-heap.md:1 msgid "# The Stack vs The Heap" msgstr "" #: src/memory-management/stack-vs-heap.md:3 msgid "" "* Stack: Continuous area of memory for local variables.\n" " * Values have fixed sizes known at compile time.\n" " * Extremely fast: just move a stack pointer.\n" " * Easy to manage: follows function calls.\n" " * Great memory locality." msgstr "" #: src/memory-management/stack-vs-heap.md:9 msgid "" "* Heap: Storage of values outside of function calls.\n" " * Values have dynamic sizes determined at runtime.\n" " * Slightly slower than the stack: some book-keeping needed.\n" " * No guarantee of memory locality." msgstr "" #: src/memory-management/stack.md:1 msgid "# Stack Memory" msgstr "" #: src/memory-management/stack.md:3 msgid "" "Creating a `String` puts fixed-sized data on the stack and dynamically " "sized\n" "data on the heap:" msgstr "" #: src/memory-management/stack.md:6 msgid "" "```rust,editable\n" "fn main() {\n" " let s1 = String::from(\"Hello\");\n" "}\n" "```" msgstr "" #: src/memory-management/stack.md:12 msgid "" "```bob\n" " Stack Heap\n" ".- - - - - - - - - - - - - -. .- - - - - - - - - - - - - - - -.\n" ": : : :\n" ": s1 : : :\n" ": +-----------+-------+ : : +----+----+----+----+----+ :\n" ": | ptr | o---+---+-----+-->| H | e | l | l | o | :\n" ": | len | 5 | : : +----+----+----+----+----+ :\n" ": | capacity | 5 | : : :\n" ": +-----------+-------+ : : :\n" ": : `- - - - - - - - - - - - - - - -'\n" "`- - - - - - - - - - - - - -'\n" "```" msgstr "" "```bob\n" " Stak Bunke\n" ".- - - - - - - - - - - - - -. .- - - - - - - - - - - - - - - -.\n" ": : : :\n" ": s1 : : :\n" ": +-----------+-------+ : : +----+----+----+----+----+ :\n" ": | ptr | o---+---+-----+-->| H | a | l | l | o | :\n" ": | len | 5 | : : +----+----+----+----+----+ :\n" ": | capacity | 5 | : : :\n" ": +-----------+-------+ : : :\n" ": : `- - - - - - - - - - - - - - - -'\n" "`- - - - - - - - - - - - - -'\n" "```" #: src/memory-management/stack.md:28 msgid "" "* Mention that a `String` is backed by a `Vec`, so it has a capacity and " "length and can grow if mutable via reallocation on the heap." msgstr "" #: src/memory-management/stack.md:30 msgid "" "* If students ask about it, you can mention that the underlying memory is " "heap allocated using the [System Allocator] and custom allocators can be " "implemented using the [Allocator API]" msgstr "" #: src/memory-management/stack.md:34 msgid "" "[System Allocator]: https://doc.rust-lang.org/std/alloc/struct.System.html\n" "[Allocator API]: https://doc.rust-lang.org/std/alloc/index.html" msgstr "" #: src/memory-management/manual.md:1 msgid "# Manual Memory Management" msgstr "# Manuel hukommelseshåndtering" #: src/memory-management/manual.md:3 msgid "You allocate and deallocate heap memory yourself." msgstr "Du allokerer og deallokerer din heap-memory." #: src/memory-management/manual.md:5 msgid "" "If not done with care, this can lead to crashes, bugs, security " "vulnerabilities, and memory leaks." msgstr "" #: src/memory-management/manual.md:7 msgid "## C Example" msgstr "## C-eksempel" #: src/memory-management/manual.md:9 msgid "You must call `free` on every pointer you allocate with `malloc`:" msgstr "" #: src/memory-management/manual.md:11 msgid "" "```c\n" "void foo(size_t n) {\n" " int* int_array = (int*)malloc(n * sizeof(int));\n" " //\n" " // ... lots of code\n" " //\n" " free(int_array);\n" "}\n" "```" msgstr "" #: src/memory-management/manual.md:21 msgid "" "Memory is leaked if the function returns early between `malloc` and `free`: " "the\n" "pointer is lost and we cannot deallocate the memory." msgstr "" #: src/memory-management/scope-based.md:1 msgid "# Scope-Based Memory Management" msgstr "" #: src/memory-management/scope-based.md:3 msgid "" "Constructors and destructors let you hook into the lifetime of an object." msgstr "" #: src/memory-management/scope-based.md:5 msgid "" "By wrapping a pointer in an object, you can free memory when the object is\n" "destroyed. The compiler guarantees that this happens, even if an exception " "is\n" "raised." msgstr "" #: src/memory-management/scope-based.md:9 msgid "" "This is often called _resource acquisition is initialization_ (RAII) and " "gives\n" "you smart pointers." msgstr "" #: src/memory-management/scope-based.md:12 msgid "## C++ Example" msgstr "" #: src/memory-management/scope-based.md:14 msgid "" "```c++\n" "void say_hello(std::unique_ptr person) {\n" " std::cout << \"Hello \" << person->name << std::endl;\n" "}\n" "```" msgstr "" #: src/memory-management/scope-based.md:20 msgid "" "* The `std::unique_ptr` object is allocated on the stack, and points to\n" " memory allocated on the heap.\n" "* At the end of `say_hello`, the `std::unique_ptr` destructor will run.\n" "* The destructor frees the `Person` object it points to." msgstr "" #: src/memory-management/scope-based.md:25 msgid "" "Special move constructors are used when passing ownership to a function:" msgstr "" #: src/memory-management/scope-based.md:27 msgid "" "```c++\n" "std::unique_ptr person = find_person(\"Carla\");\n" "say_hello(std::move(person));\n" "```" msgstr "" #: src/memory-management/garbage-collection.md:1 msgid "# Automatic Memory Management" msgstr "" #: src/memory-management/garbage-collection.md:3 msgid "" "An alternative to manual and scope-based memory management is automatic " "memory\n" "management:" msgstr "" #: src/memory-management/garbage-collection.md:6 msgid "" "* The programmer never allocates or deallocates memory explicitly.\n" "* A garbage collector finds unused memory and deallocates it for the " "programmer." msgstr "" #: src/memory-management/garbage-collection.md:9 msgid "## Java Example" msgstr "" #: src/memory-management/garbage-collection.md:11 msgid "The `person` object is not deallocated after `sayHello` returns:" msgstr "" #: src/memory-management/garbage-collection.md:13 msgid "" "```java\n" "void sayHello(Person person) {\n" " System.out.println(\"Hello \" + person.getName());\n" "}\n" "```" msgstr "" #: src/memory-management/rust.md:1 msgid "# Memory Management in Rust" msgstr "" #: src/memory-management/rust.md:3 msgid "Memory management in Rust is a mix:" msgstr "" #: src/memory-management/rust.md:5 msgid "" "* Safe and correct like Java, but without a garbage collector.\n" "* Depending on which abstraction (or combination of abstractions) you " "choose, can be a single unique pointer, reference counted, or atomically " "reference counted.\n" "* Scope-based like C++, but the compiler enforces full adherence.\n" "* A Rust user can choose the right abstraction for the situation, some even " "have no cost at runtime like C." msgstr "" #: src/memory-management/rust.md:10 msgid "It achieves this by modeling _ownership_ explicitly." msgstr "" #: src/memory-management/rust.md:14 msgid "" "* If asked how at this point, you can mention that in Rust this is usually " "handled by RAII wrapper types such as [Box], [Vec], [Rc], or [Arc]. These " "encapsulate ownership and memory allocation via various means, and prevent " "the potential errors in C." msgstr "" #: src/memory-management/rust.md:16 msgid "" "* You may be asked about destructors here, the [Drop] trait is the Rust " "equivalent." msgstr "" #: src/memory-management/rust.md:20 msgid "" "[Box]: https://doc.rust-lang.org/std/boxed/struct.Box.html\n" "[Vec]: https://doc.rust-lang.org/std/vec/struct.Vec.html\n" "[Rc]: https://doc.rust-lang.org/std/rc/struct.Rc.html\n" "[Arc]: https://doc.rust-lang.org/std/sync/struct.Arc.html\n" "[Drop]: https://doc.rust-lang.org/std/ops/trait.Drop.html" msgstr "" #: src/memory-management/comparison.md:1 msgid "# Comparison" msgstr "" #: src/memory-management/comparison.md:3 msgid "Here is a rough comparison of the memory management techniques." msgstr "" #: src/memory-management/comparison.md:5 msgid "## Pros of Different Memory Management Techniques" msgstr "" #: src/memory-management/comparison.md:7 msgid "" "* Manual like C:\n" " * No runtime overhead.\n" "* Automatic like Java:\n" " * Fully automatic.\n" " * Safe and correct.\n" "* Scope-based like C++:\n" " * Partially automatic.\n" " * No runtime overhead.\n" "* Compiler-enforced scope-based like Rust:\n" " * Enforced by compiler.\n" " * No runtime overhead.\n" " * Safe and correct." msgstr "" #: src/memory-management/comparison.md:20 msgid "## Cons of Different Memory Management Techniques" msgstr "" #: src/memory-management/comparison.md:22 msgid "" "* Manual like C:\n" " * Use-after-free.\n" " * Double-frees.\n" " * Memory leaks.\n" "* Automatic like Java:\n" " * Garbage collection pauses.\n" " * Destructor delays.\n" "* Scope-based like C++:\n" " * Complex, opt-in by programmer.\n" " * Potential for use-after-free.\n" "* Compiler-enforced and scope-based like Rust:\n" " * Some upfront complexity.\n" " * Can reject valid programs." msgstr "" #: src/ownership.md:1 msgid "# Ownership" msgstr "" #: src/ownership.md:3 msgid "" "All variable bindings have a _scope_ where they are valid and it is an error " "to\n" "use a variable outside its scope:" msgstr "" #: src/ownership.md:6 msgid "" "```rust,editable,compile_fail\n" "struct Point(i32, i32);" msgstr "" #: src/ownership.md:9 msgid "" "fn main() {\n" " {\n" " let p = Point(3, 4);\n" " println!(\"x: {}\", p.0);\n" " }\n" " println!(\"y: {}\", p.1);\n" "}\n" "```" msgstr "" #: src/ownership.md:18 msgid "" "* At the end of the scope, the variable is _dropped_ and the data is freed.\n" "* A destructor can run here to free up resources.\n" "* We say that the variable _owns_ the value." msgstr "" #: src/ownership/move-semantics.md:1 msgid "# Move Semantics" msgstr "" #: src/ownership/move-semantics.md:3 msgid "An assignment will transfer ownership between variables:" msgstr "" #: src/ownership/move-semantics.md:5 msgid "" "```rust,editable\n" "fn main() {\n" " let s1: String = String::from(\"Hello!\");\n" " let s2: String = s1;\n" " println!(\"s2: {s2}\");\n" " // println!(\"s1: {s1}\");\n" "}\n" "```" msgstr "" #: src/ownership/move-semantics.md:14 msgid "" "* The assignment of `s1` to `s2` transfers ownership.\n" "* The data was _moved_ from `s1` and `s1` is no longer accessible.\n" "* When `s1` goes out of scope, nothing happens: it has no ownership.\n" "* When `s2` goes out of scope, the string data is freed.\n" "* There is always _exactly_ one variable binding which owns a value." msgstr "" #: src/ownership/move-semantics.md:22 msgid "" "* Mention that this is the opposite of the defaults in C++, which copies by " "value unless you use `std::move` (and the move constructor is defined!)." msgstr "" #: src/ownership/move-semantics.md:24 msgid "* In Rust, you clones are explicit (by using `clone`)." msgstr "" #: src/ownership/moved-strings-rust.md:1 msgid "# Moved Strings in Rust" msgstr "" #: src/ownership/moved-strings-rust.md:3 msgid "" "```rust,editable\n" "fn main() {\n" " let s1: String = String::from(\"Rust\");\n" " let s2: String = s1;\n" "}\n" "```" msgstr "" #: src/ownership/moved-strings-rust.md:10 msgid "" "* The heap data from `s1` is reused for `s2`.\n" "* When `s1` goes out of scope, nothing happens (it has been moved from)." msgstr "" #: src/ownership/moved-strings-rust.md:13 msgid "Before move to `s2`:" msgstr "" #: src/ownership/moved-strings-rust.md:15 msgid "" "```bob\n" " Stack Heap\n" ".- - - - - - - - - - - - - -. .- - - - - - - - - - - - - -.\n" ": : : :\n" ": s1 : : :\n" ": +-----------+-------+ : : +----+----+----+----+ :\n" ": | ptr | o---+---+-----+-->| R | u | s | t | :\n" ": | len | 4 | : : +----+----+----+----+ :\n" ": | capacity | 4 | : : :\n" ": +-----------+-------+ : : :\n" ": : `- - - - - - - - - - - - - -'\n" ": :\n" "`- - - - - - - - - - - - - -'\n" "```" msgstr "" #: src/ownership/moved-strings-rust.md:30 msgid "After move to `s2`:" msgstr "" #: src/ownership/moved-strings-rust.md:32 #, fuzzy msgid "" "```bob\n" " Stack Heap\n" ".- - - - - - - - - - - - - -. .- - - - - - - - - - - - - -.\n" ": : : :\n" ": s1 \"(inaccessible)\" : : :\n" ": +-----------+-------+ : : +----+----+----+----+ :\n" ": | ptr | o---+---+--+--+-->| R | u | s | t | :\n" ": | len | 4 | : | : +----+----+----+----+ :\n" ": | capacity | 4 | : | : :\n" ": +-----------+-------+ : | : :\n" ": : | `- - - - - - - - - - - - - -'\n" ": s2 : |\n" ": +-----------+-------+ : |\n" ": | ptr | o---+---+--'\n" ": | len | 4 | :\n" ": | capacity | 4 | :\n" ": +-----------+-------+ :\n" ": :\n" "`- - - - - - - - - - - - - -'\n" "```" msgstr "" "```bob\n" " Stak Bunke\n" ".- - - - - - - - - - - - - -. .- - - - - - - - - - - - - - - -.\n" ": : : :\n" ": s1 : : :\n" ": +-----------+-------+ : : +----+----+----+----+----+ :\n" ": | ptr | o---+---+-----+-->| H | a | l | l | o | :\n" ": | len | 5 | : : +----+----+----+----+----+ :\n" ": | capacity | 5 | : : :\n" ": +-----------+-------+ : : :\n" ": : `- - - - - - - - - - - - - - - -'\n" "`- - - - - - - - - - - - - -'\n" "```" #: src/ownership/double-free-modern-cpp.md:1 msgid "# Double Frees in Modern C++" msgstr "" #: src/ownership/double-free-modern-cpp.md:3 msgid "Modern C++ solves this differently:" msgstr "" #: src/ownership/double-free-modern-cpp.md:5 msgid "" "```c++\n" "std::string s1 = \"Cpp\";\n" "std::string s2 = s1; // Duplicate the data in s1.\n" "```" msgstr "" #: src/ownership/double-free-modern-cpp.md:10 msgid "" "* The heap data from `s1` is duplicated and `s2` gets its own independent " "copy.\n" "* When `s1` and `s2` go out of scope, they each free their own memory." msgstr "" #: src/ownership/double-free-modern-cpp.md:13 msgid "Before copy-assignment:" msgstr "" #: src/ownership/double-free-modern-cpp.md:16 msgid "" "```bob\n" " Stack Heap\n" ".- - - - - - - - - - - - - -. .- - - - - - - - - - - -.\n" ": : : :\n" ": s1 : : :\n" ": +-----------+-------+ : : +----+----+----+ :\n" ": | ptr | o---+---+--+--+-->| C | p | p | :\n" ": | len | 3 | : : +----+----+----+ :\n" ": | capacity | 3 | : : :\n" ": +-----------+-------+ : : :\n" ": : `- - - - - - - - - - - -'\n" "`- - - - - - - - - - - - - -'\n" "```" msgstr "" #: src/ownership/double-free-modern-cpp.md:30 msgid "After copy-assignment:" msgstr "" #: src/ownership/double-free-modern-cpp.md:32 #, fuzzy msgid "" "```bob\n" " Stack Heap\n" ".- - - - - - - - - - - - - -. .- - - - - - - - - - - -.\n" ": : : :\n" ": s1 : : :\n" ": +-----------+-------+ : : +----+----+----+ :\n" ": | ptr | o---+---+--+--+-->| C | p | p | :\n" ": | len | 3 | : : +----+----+----+ :\n" ": | capacity | 3 | : : :\n" ": +-----------+-------+ : : :\n" ": : : :\n" ": s2 : : :\n" ": +-----------+-------+ : : +----+----+----+ :\n" ": | ptr | o---+---+-----+-->| C | p | p | :\n" ": | len | 3 | : : +----+----+----+ :\n" ": | capacity | 3 | : : :\n" ": +-----------+-------+ : : :\n" ": : `- - - - - - - - - - - -'\n" "`- - - - - - - - - - - - - -'\n" "```" msgstr "" "```bob\n" " Stak Bunke\n" ".- - - - - - - - - - - - - -. .- - - - - - - - - - - - - - - -.\n" ": : : :\n" ": s1 : : :\n" ": +-----------+-------+ : : +----+----+----+----+----+ :\n" ": | ptr | o---+---+-----+-->| H | a | l | l | o | :\n" ": | len | 5 | : : +----+----+----+----+----+ :\n" ": | capacity | 5 | : : :\n" ": +-----------+-------+ : : :\n" ": : `- - - - - - - - - - - - - - - -'\n" "`- - - - - - - - - - - - - -'\n" "```" #: src/ownership/moves-function-calls.md:1 msgid "# Moves in Function Calls" msgstr "" #: src/ownership/moves-function-calls.md:3 msgid "" "When you pass a value to a function, the value is assigned to the function\n" "parameter. This transfers ownership:" msgstr "" #: src/ownership/moves-function-calls.md:6 msgid "" "```rust,editable\n" "fn say_hello(name: String) {\n" " println!(\"Hello {name}\")\n" "}" msgstr "" #: src/ownership/moves-function-calls.md:11 msgid "" "fn main() {\n" " let name = String::from(\"Alice\");\n" " say_hello(name);\n" " // say_hello(name);\n" "}\n" "```" msgstr "" #: src/ownership/moves-function-calls.md:20 msgid "" "* With the first call to `say_hello`, `main` gives up ownership of `name`. " "Afterwards, `name` cannot be used anymore within `main`.\n" "* `main` can retain ownership if it passes `name` as a reference (`&name`) " "and if `say_hello` accepts a reference as a parameter.\n" "* Alternatively, `main` can pass a clone of `name` in the first call (`name." "clone()`).\n" "* Rust makes it harder than C++ to inadvertently create copies by making " "move semantics the default, and by forcing programmers to make clones " "explicit." msgstr "" #: src/ownership/copy-clone.md:1 msgid "# Copying and Cloning" msgstr "" #: src/ownership/copy-clone.md:3 msgid "" "While move semantics are the default, certain types are copied by default:" msgstr "" #: src/ownership/copy-clone.md:5 msgid "" "```rust,editable\n" "fn main() {\n" " let x = 42;\n" " let y = x;\n" " println!(\"x: {x}\");\n" " println!(\"y: {y}\");\n" "}\n" "```" msgstr "" #: src/ownership/copy-clone.md:14 msgid "These types implement the `Copy` trait." msgstr "" #: src/ownership/copy-clone.md:16 msgid "You can opt-in your own types to use copy semantics:" msgstr "" #: src/ownership/copy-clone.md:18 msgid "" "```rust,editable\n" "#[derive(Copy, Clone, Debug)]\n" "struct Point(i32, i32);" msgstr "" #: src/ownership/copy-clone.md:22 msgid "" "fn main() {\n" " let p1 = Point(3, 4);\n" " let p2 = p1;\n" " println!(\"p1: {p1:?}\");\n" " println!(\"p2: {p2:?}\");\n" "}\n" "```" msgstr "" #: src/ownership/copy-clone.md:30 msgid "" "* After the assignment, both `p1` and `p2` own their own data.\n" "* We can also use `p1.clone()` to explicitly copy the data." msgstr "" #: src/ownership/copy-clone.md:35 msgid "Copying and cloning are not the same thing:" msgstr "" #: src/ownership/copy-clone.md:37 msgid "" "* Copying refers to bitwise copies of memory regions and does not work on " "arbitrary objects.\n" "* Copying does not allow for custom logic (unlike copy constructors in C+" "+).\n" "* Cloning is a more general operation and also allows for custom behavior by " "implementing the `Clone` trait.\n" "* Copying does not work on types that implement the `Drop` trait." msgstr "" #: src/ownership/copy-clone.md:42 src/ownership/lifetimes-function-calls.md:29 msgid "In the above example, try the following:" msgstr "" #: src/ownership/copy-clone.md:44 msgid "" "* Add a `String` field to `struct Point`. It will not compile because " "`String` is not a `Copy` type.\n" "* Remove `Copy` from the `derive` attribute. The compiler error is now in " "the `println!` for `p1`.\n" "* Show that it works if you clone `p1` instead." msgstr "" #: src/ownership/borrowing.md:1 msgid "# Borrowing" msgstr "" #: src/ownership/borrowing.md:3 msgid "" "Instead of transferring ownership when calling a function, you can let a\n" "function _borrow_ the value:" msgstr "" #: src/ownership/borrowing.md:6 src/ownership/lifetimes-function-calls.md:5 msgid "" "```rust,editable\n" "#[derive(Debug)]\n" "struct Point(i32, i32);" msgstr "" #: src/ownership/borrowing.md:10 msgid "" "fn add(p1: &Point, p2: &Point) -> Point {\n" " Point(p1.0 + p2.0, p1.1 + p2.1)\n" "}" msgstr "" #: src/ownership/borrowing.md:14 msgid "" "fn main() {\n" " let p1 = Point(3, 4);\n" " let p2 = Point(10, 20);\n" " let p3 = add(&p1, &p2);\n" " println!(\"{p1:?} + {p2:?} = {p3:?}\");\n" "}\n" "```" msgstr "" #: src/ownership/borrowing.md:22 msgid "" "* The `add` function _borrows_ two points and returns a new point.\n" "* The caller retains ownership of the inputs." msgstr "" #: src/ownership/borrowing.md:27 msgid "" "Notes on stack returns:\n" "* Demonstrate that the return from `add` is cheap because the compiler can " "eliminate the copy operation. Change the above code to print stack addresses " "and run it on the [Playground]. In the \"DEBUG\" optimization level, the " "addresses should change, while the stay the same when changing to the " "\"RELEASE\" setting:" msgstr "" #: src/ownership/borrowing.md:30 msgid "" " ```rust,editable\n" " #[derive(Debug)]\n" " struct Point(i32, i32);" msgstr "" #: src/ownership/borrowing.md:34 msgid "" " fn add(p1: &Point, p2: &Point) -> Point {\n" " let p = Point(p1.0 + p2.0, p1.1 + p2.1);\n" " println!(\"&p.0: {:p}\", &p.0);\n" " p\n" " }" msgstr "" #: src/ownership/borrowing.md:40 msgid "" " fn main() {\n" " let p1 = Point(3, 4);\n" " let p2 = Point(10, 20);\n" " let p3 = add(&p1, &p2);\n" " println!(\"&p3.0: {:p}\", &p3.0);\n" " println!(\"{p1:?} + {p2:?} = {p3:?}\");\n" " }\n" " ```\n" "* The Rust compiler can do return value optimization (RVO).\n" "* In C++, copy elision has to be defined in the language specification " "because constructors can have side effects. In Rust, this is not an issue at " "all." msgstr "" #: src/ownership/borrowing.md:53 msgid "[Playground]: https://play.rust-lang.org/" msgstr "" #: src/ownership/shared-unique-borrows.md:1 msgid "# Shared and Unique Borrows" msgstr "" #: src/ownership/shared-unique-borrows.md:3 msgid "Rust puts constraints on the ways you can borrow values:" msgstr "" #: src/ownership/shared-unique-borrows.md:5 msgid "" "* You can have one or more `&T` values at any given time, _or_\n" "* You can have exactly one `&mut T` value." msgstr "" #: src/ownership/shared-unique-borrows.md:8 msgid "" "```rust,editable,compile_fail\n" "fn main() {\n" " let mut a: i32 = 10;\n" " let b: &i32 = &a;" msgstr "" #: src/ownership/shared-unique-borrows.md:13 msgid "" " {\n" " let c: &mut i32 = &mut a;\n" " *c = 20;\n" " }" msgstr "" #: src/ownership/shared-unique-borrows.md:18 src/std/rc.md:13 msgid "" " println!(\"a: {a}\");\n" " println!(\"b: {b}\");\n" "}\n" "```" msgstr "" #: src/ownership/shared-unique-borrows.md:25 msgid "" "* The above code does not compile because `a` is borrowed as mutable " "(through `c`) and as immutable (through `b`) at the same time.\n" "* Move the `println!` statement for `b` before the scope that introduces `c` " "to make the code compile.\n" "* After that change, the compiler realizes that `b` is only ever used before " "the new mutable borrow of `a` through `c`. This is a feature of the borrow " "checker called \"non-lexical lifetimes\"." msgstr "" #: src/ownership/lifetimes.md:1 msgid "# Lifetimes" msgstr "" #: src/ownership/lifetimes.md:3 msgid "A borrowed value has a _lifetime_:" msgstr "" #: src/ownership/lifetimes.md:5 msgid "" "* The lifetime can be elided: `add(p1: &Point, p2: &Point) -> Point`.\n" "* Lifetimes can also be explicit: `&'a Point`, `&'document str`.\n" "* Read `&'a Point` as \"a borrowed `Point` which is valid for at least the\n" " lifetime `a`\".\n" "* Lifetimes are always inferred by the compiler: you cannot assign a " "lifetime\n" " yourself.\n" " * Lifetime annotations create constraints; the compiler verifies that " "there is\n" " a valid solution." msgstr "" #: src/ownership/lifetimes-function-calls.md:1 msgid "# Lifetimes in Function Calls" msgstr "" #: src/ownership/lifetimes-function-calls.md:3 msgid "" "In addition to borrowing its arguments, a function can return a borrowed " "value:" msgstr "" #: src/ownership/lifetimes-function-calls.md:9 msgid "" "fn left_most<'a>(p1: &'a Point, p2: &'a Point) -> &'a Point {\n" " if p1.0 < p2.0 { p1 } else { p2 }\n" "}" msgstr "" #: src/ownership/lifetimes-function-calls.md:13 msgid "" "fn main() {\n" " let p1: Point = Point(10, 10);\n" " let p2: Point = Point(20, 20);\n" " let p3: &Point = left_most(&p1, &p2);\n" " println!(\"left-most point: {:?}\", p3);\n" "}\n" "```" msgstr "" #: src/ownership/lifetimes-function-calls.md:21 msgid "" "* `'a` is a generic parameter, it is inferred by the compiler.\n" "* Lifetimes start with `'` and `'a` is a typical default name.\n" "* Read `&'a Point` as \"a borrowed `Point` which is valid for at least the\n" " lifetime `a`\".\n" " * The _at least_ part is important when parameters are in different scopes." msgstr "" #: src/ownership/lifetimes-function-calls.md:31 msgid "" "* Move the declaration of `p2` and `p3` into a a new scope (`{ ... }`), " "resulting in the following code:\n" " ```rust,ignore\n" " #[derive(Debug)]\n" " struct Point(i32, i32);" msgstr "" #: src/ownership/lifetimes-function-calls.md:36 msgid "" " fn left_most<'a>(p1: &'a Point, p2: &'a Point) -> &'a Point {\n" " if p1.0 < p2.0 { p1 } else { p2 }\n" " }" msgstr "" #: src/ownership/lifetimes-function-calls.md:40 msgid "" " fn main() {\n" " let p1: Point = Point(10, 10);\n" " let p3: &Point;\n" " {\n" " let p2: Point = Point(20, 20);\n" " p3 = left_most(&p1, &p2);\n" " }\n" " println!(\"left-most point: {:?}\", p3);\n" " }\n" " ```\n" " Note how this does not compile since `p3` outlives `p2`." msgstr "" #: src/ownership/lifetimes-function-calls.md:52 msgid "" "* Reset the workspace and change the function signature to `fn left_most<'a, " "'b>(p1: &'a Point, p2: &'a Point) -> &'b Point`. This will not compile " "because the relationship between the lifetimes `'a` and `'b` is unclear." msgstr "" #: src/ownership/lifetimes-data-structures.md:1 msgid "# Lifetimes in Data Structures" msgstr "" #: src/ownership/lifetimes-data-structures.md:3 msgid "" "If a data type stores borrowed data, it must be annotated with a lifetime:" msgstr "" #: src/ownership/lifetimes-data-structures.md:5 msgid "" "```rust,editable\n" "#[derive(Debug)]\n" "struct Highlight<'doc>(&'doc str);" msgstr "" #: src/ownership/lifetimes-data-structures.md:9 msgid "" "fn erase(text: String) {\n" " println!(\"Bye {text}!\");\n" "}" msgstr "" #: src/ownership/lifetimes-data-structures.md:13 msgid "" "fn main() {\n" " let text = String::from(\"The quick brown fox jumps over the lazy dog." "\");\n" " let fox = Highlight(&text[4..19]);\n" " let dog = Highlight(&text[35..43]);\n" " // erase(text);\n" " println!(\"{fox:?}\");\n" " println!(\"{dog:?}\");\n" "}\n" "```" msgstr "" #: src/ownership/lifetimes-data-structures.md:25 msgid "" "* In the above example, the annotation on `Highlight` enforces that the data " "underlying the contained `&str` lives at least as long as any instance of " "`Highlight` that uses that data.\n" "* If `text` is consumed before the end of the lifetime of `fox` (or `dog`), " "the borrow checker throws an error.\n" "* Types with borrowed data force users to hold on to the original data. This " "can be useful for creating lightweight views, but it generally makes them " "somewhat harder to use.\n" "* When possible, make data structures own their data directly." msgstr "" #: src/exercises/day-1/afternoon.md:1 msgid "# Day 1: Afternoon Exercises" msgstr "" #: src/exercises/day-1/afternoon.md:3 msgid "We will look at two things:" msgstr "" #: src/exercises/day-1/afternoon.md:5 msgid "* A small book library," msgstr "" #: src/exercises/day-1/afternoon.md:7 msgid "* Iterators and ownership (hard)." msgstr "" #: src/exercises/day-1/afternoon.md:13 src/exercises/day-2/afternoon.md:9 #: src/exercises/day-3/afternoon.md:9 msgid "[solutions]: solutions-afternoon.md" msgstr "" #: src/exercises/day-1/book-library.md:1 msgid "# Designing a Library" msgstr "" #: src/exercises/day-1/book-library.md:3 msgid "" "We will learn much more about structs and the `Vec` type tomorrow. For " "now,\n" "you just need to know part of its API:" msgstr "" #: src/exercises/day-1/book-library.md:6 msgid "" "```rust,editable\n" "fn main() {\n" " let mut vec = vec![10, 20];\n" " vec.push(30);\n" " println!(\"middle value: {}\", vec[vec.len() / 2]);\n" " for item in vec.iter() {\n" " println!(\"item: {item}\");\n" " }\n" "}\n" "```" msgstr "" #: src/exercises/day-1/book-library.md:17 msgid "" "Use this to create a library application. Copy the code below to\n" " and update the types to make it compile:" msgstr "" #: src/exercises/day-1/book-library.md:24 msgid "" "struct Library {\n" " books: Vec,\n" "}" msgstr "" #: src/exercises/day-1/book-library.md:28 #: src/exercises/day-1/solutions-afternoon.md:27 msgid "" "struct Book {\n" " title: String,\n" " year: u16,\n" "}" msgstr "" #: src/exercises/day-1/book-library.md:33 #: src/exercises/day-1/solutions-afternoon.md:32 msgid "" "impl Book {\n" " // This is a constructor, used below.\n" " fn new(title: &str, year: u16) -> Book {\n" " Book {\n" " title: String::from(title),\n" " year,\n" " }\n" " }\n" "}" msgstr "" #: src/exercises/day-1/book-library.md:43 msgid "" "// This makes it possible to print Book values with {}.\n" "impl std::fmt::Display for Book {\n" " fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n" " write!(f, \"{} ({})\", self.title, self.year)\n" " }\n" "}" msgstr "" #: src/exercises/day-1/book-library.md:50 msgid "" "impl Library {\n" " fn new() -> Library {\n" " unimplemented!()\n" " }" msgstr "" #: src/exercises/day-1/book-library.md:55 msgid "" " //fn len(self) -> usize {\n" " // unimplemented!()\n" " //}" msgstr "" #: src/exercises/day-1/book-library.md:59 msgid "" " //fn is_empty(self) -> bool {\n" " // unimplemented!()\n" " //}" msgstr "" #: src/exercises/day-1/book-library.md:63 msgid "" " //fn add_book(self, book: Book) {\n" " // unimplemented!()\n" " //}" msgstr "" #: src/exercises/day-1/book-library.md:67 msgid "" " //fn print_books(self) {\n" " // unimplemented!()\n" " //}" msgstr "" #: src/exercises/day-1/book-library.md:71 msgid "" " //fn oldest_book(self) -> Option<&Book> {\n" " // unimplemented!()\n" " //}\n" "}" msgstr "" #: src/exercises/day-1/book-library.md:76 msgid "" "// This shows the desired behavior. Uncomment the code below and\n" "// implement the missing methods. You will need to update the\n" "// method signatures, including the \"self\" parameter! You may\n" "// also need to update the variable bindings within main.\n" "fn main() {\n" " let library = Library::new();" msgstr "" #: src/exercises/day-1/book-library.md:83 msgid "" " //println!(\"Our library is empty: {}\", library.is_empty());\n" " //\n" " //library.add_book(Book::new(\"Lord of the Rings\", 1954));\n" " //library.add_book(Book::new(\"Alice's Adventures in Wonderland\", " "1865));\n" " //\n" " //library.print_books();\n" " //\n" " //match library.oldest_book() {\n" " // Some(book) => println!(\"My oldest book is {book}\"),\n" " // None => println!(\"My library is empty!\"),\n" " //}\n" " //\n" " //println!(\"Our library has {} books\", library.len());\n" "}\n" "```" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:1 msgid "# Iterators and Ownership" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:3 msgid "" "The ownership model of Rust affects many APIs. An example of this is the\n" "[`Iterator`](https://doc.rust-lang.org/std/iter/trait.Iterator.html) and\n" "[`IntoIterator`](https://doc.rust-lang.org/std/iter/trait.IntoIterator." "html)\n" "traits." msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:8 msgid "## `Iterator`" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:10 msgid "" "Traits are like interfaces: they describe behavior (methods) for a type. " "The\n" "`Iterator` trait simply says that you can call `next` until you get `None` " "back:" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:13 msgid "" "```rust\n" "pub trait Iterator {\n" " type Item;\n" " fn next(&mut self) -> Option;\n" "}\n" "```" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:20 msgid "You use this trait like this:" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:22 msgid "" "```rust,editable\n" "fn main() {\n" " let v: Vec = vec![10, 20, 30];\n" " let mut iter = v.iter();" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:27 msgid "" " println!(\"v[0]: {:?}\", iter.next());\n" " println!(\"v[1]: {:?}\", iter.next());\n" " println!(\"v[2]: {:?}\", iter.next());\n" " println!(\"No more items: {:?}\", iter.next());\n" "}\n" "```" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:34 msgid "What is the type returned by the iterator? Test your answer here:" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:36 msgid "" "```rust,editable,compile_fail\n" "fn main() {\n" " let v: Vec = vec![10, 20, 30];\n" " let mut iter = v.iter();" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:41 #: src/exercises/day-1/iterators-and-ownership.md:78 msgid "" " let v0: Option<..> = iter.next();\n" " println!(\"v0: {v0:?}\");\n" "}\n" "```" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:46 msgid "Why is this type used?" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:48 msgid "## `IntoIterator`" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:50 msgid "" "The `Iterator` trait tells you how to _iterate_ once you have created an\n" "iterator. The related trait `IntoIterator` tells you how to create the " "iterator:" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:53 msgid "" "```rust\n" "pub trait IntoIterator {\n" " type Item;\n" " type IntoIter: Iterator;" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:58 msgid "" " fn into_iter(self) -> Self::IntoIter;\n" "}\n" "```" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:62 msgid "" "The syntax here means that every implementation of `IntoIterator` must\n" "declare two types:" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:65 msgid "" "* `Item`: the type we iterate over, such as `i8`,\n" "* `IntoIter`: the `Iterator` type returned by the `into_iter` method." msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:68 msgid "" "Note that `IntoIter` and `Item` are linked: the iterator must have the same\n" "`Item` type, which means that it returns `Option`" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:71 msgid "Like before, what is the type returned by the iterator?" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:73 msgid "" "```rust,editable,compile_fail\n" "fn main() {\n" " let v: Vec = vec![String::from(\"foo\"), String::" "from(\"bar\")];\n" " let mut iter = v.into_iter();" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:83 msgid "## `for` Loops" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:85 msgid "" "Now that we know both `Iterator` and `IntoIterator`, we can build `for` " "loops.\n" "They call `into_iter()` on an expression and iterates over the resulting\n" "iterator:" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:89 msgid "" "```rust,editable\n" "fn main() {\n" " let v: Vec = vec![String::from(\"foo\"), String::from(\"bar\")];" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:93 msgid "" " for word in &v {\n" " println!(\"word: {word}\");\n" " }" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:97 msgid "" " for word in v {\n" " println!(\"word: {word}\");\n" " }\n" "}\n" "```" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:103 msgid "What is the type of `word` in each loop?" msgstr "" #: src/exercises/day-1/iterators-and-ownership.md:105 msgid "" "Experiment with the code above and then consult the documentation for " "[`impl\n" "IntoIterator for\n" "&Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-" "IntoIterator-for-%26%27a%20Vec%3CT%2C%20A%3E)\n" "and [`impl IntoIterator for\n" "Vec`](https://doc.rust-lang.org/std/vec/struct.Vec.html#impl-IntoIterator-" "for-%26%27a%20Vec%3CT%2C%20A%3E)\n" "to check your answers." msgstr "" #: src/welcome-day-2.md:1 msgid "# Welcome to Day 2" msgstr "" #: src/welcome-day-2.md:3 msgid "Now that we have seen a fair amount of Rust, we will continue with:" msgstr "" #: src/welcome-day-2.md:5 msgid "* Structs, enums, methods." msgstr "" #: src/welcome-day-2.md:7 msgid "* Pattern matching: destructuring enums, structs, and arrays." msgstr "" #: src/welcome-day-2.md:9 msgid "" "* Control flow constructs: `if`, `if let`, `while`, `while let`, `break`, " "and\n" " `continue`." msgstr "" #: src/welcome-day-2.md:12 msgid "" "* The Standard Library: `String`, `Option` and `Result`, `Vec`, `HashMap`, " "`Rc`\n" " and `Arc`." msgstr "" #: src/welcome-day-2.md:15 msgid "* Modules: visibility, paths, and filesystem hierarchy." msgstr "" #: src/structs.md:1 msgid "# Structs" msgstr "" #: src/structs.md:3 msgid "Like C and C++, Rust has support for custom structs:" msgstr "" #: src/structs.md:5 msgid "" "```rust,editable\n" "struct Person {\n" " name: String,\n" " age: u8,\n" "}" msgstr "" #: src/structs.md:11 msgid "" "fn main() {\n" " let peter = Person {\n" " name: String::from(\"Peter\"),\n" " age: 27,\n" " };" msgstr "" #: src/structs.md:17 msgid "" " println!(\"{} is {} years old\", peter.name, peter.age);\n" "}\n" "```" msgstr "" #: src/structs/tuple-structs.md:1 msgid "# Tuple Structs" msgstr "" #: src/structs/tuple-structs.md:3 msgid "If the field names are unimportant, you can use a tuple struct:" msgstr "" #: src/structs/tuple-structs.md:5 msgid "" "```rust,editable\n" "struct Point(i32, i32);" msgstr "" #: src/structs/tuple-structs.md:8 msgid "" "fn main() {\n" " let p = Point(17, 23);\n" " println!(\"({}, {})\", p.0, p.1);\n" "}\n" "```" msgstr "" #: src/structs/tuple-structs.md:14 msgid "This is often used for single-field wrappers (called newtypes):" msgstr "" #: src/structs/tuple-structs.md:16 msgid "" "```rust,editable,compile_fail\n" "struct PoundOfForce(f64);\n" "struct Newtons(f64);" msgstr "" #: src/structs/tuple-structs.md:20 msgid "" "fn compute_thruster_force() -> PoundOfForce {\n" " todo!(\"Ask a rocket scientist at NASA\")\n" "}" msgstr "" #: src/structs/tuple-structs.md:24 msgid "" "fn set_thruster_force(force: Newtons) {\n" " // ...\n" "}" msgstr "" #: src/structs/tuple-structs.md:28 msgid "" "fn main() {\n" " let force = compute_thruster_force();\n" " set_thruster_force(force);\n" "}" msgstr "" #: src/structs/tuple-structs.md:33 src/generics/trait-objects.md:86 msgid "```" msgstr "" #: src/structs/field-shorthand.md:1 msgid "# Field Shorthand Syntax" msgstr "" #: src/structs/field-shorthand.md:3 msgid "" "If you already have variables with the right names, then you can create the\n" "struct using a shorthand:" msgstr "" #: src/structs/field-shorthand.md:6 src/methods.md:6 msgid "" "```rust,editable\n" "#[derive(Debug)]\n" "struct Person {\n" " name: String,\n" " age: u8,\n" "}" msgstr "" #: src/structs/field-shorthand.md:13 msgid "" "impl Person {\n" " fn new(name: String, age: u8) -> Person {\n" " Person { name, age }\n" " }\n" "}" msgstr "" #: src/structs/field-shorthand.md:19 msgid "" "fn main() {\n" " let peter = Person::new(String::from(\"Peter\"), 27);\n" " println!(\"{peter:?}\");\n" "}\n" "```" msgstr "" #: src/enums.md:1 msgid "# Enums" msgstr "" #: src/enums.md:3 msgid "" "The `enum` keyword allows the creation of a type which has a few\n" "different variants:" msgstr "" #: src/enums.md:6 msgid "" "```rust,editable\n" "fn generate_random_number() -> i32 {\n" " 4 // Chosen by fair dice roll. Guaranteed to be random.\n" "}" msgstr "" #: src/enums.md:11 msgid "" "#[derive(Debug)]\n" "enum CoinFlip {\n" " Heads,\n" " Tails,\n" "}" msgstr "" #: src/enums.md:17 msgid "" "fn flip_coin() -> CoinFlip {\n" " let random_number = generate_random_number();\n" " if random_number % 2 == 0 {\n" " return CoinFlip::Heads;\n" " } else {\n" " return CoinFlip::Tails;\n" " }\n" "}" msgstr "" #: src/enums.md:26 msgid "" "fn main() {\n" " println!(\"You got: {:?}\", flip_coin());\n" "}\n" "```" msgstr "" #: src/enums/variant-payloads.md:1 msgid "# Variant Payloads" msgstr "" #: src/enums/variant-payloads.md:3 msgid "" "You can define richer enums where the variants carry data. You can then use " "the\n" "`match` statement to extract the data from each variant:" msgstr "" #: src/enums/variant-payloads.md:6 msgid "" "```rust,editable\n" "enum WebEvent {\n" " PageLoad, // Variant without payload\n" " KeyPress(char), // Tuple struct variant\n" " Click { x: i64, y: i64 }, // Full struct variant\n" "}" msgstr "" #: src/enums/variant-payloads.md:13 msgid "" "#[rustfmt::skip]\n" "fn inspect(event: WebEvent) {\n" " match event {\n" " WebEvent::PageLoad => println!(\"page loaded\"),\n" " WebEvent::KeyPress(c) => println!(\"pressed '{c}'\"),\n" " WebEvent::Click { x, y } => println!(\"clicked at x={x}, y={y}\"),\n" " }\n" "}" msgstr "" #: src/enums/variant-payloads.md:22 msgid "" "fn main() {\n" " let load = WebEvent::PageLoad;\n" " let press = WebEvent::KeyPress('x');\n" " let click = WebEvent::Click { x: 20, y: 80 };" msgstr "" #: src/enums/variant-payloads.md:27 msgid "" " inspect(load);\n" " inspect(press);\n" " inspect(click);\n" "}\n" "```" msgstr "" #: src/enums/variant-payloads.md:35 msgid "" "* In the above example, accessing the `char` in `KeyPress`, or `x` and `y` " "in `Click` only works within a `match` statement.\n" "* `match` inspects a hidden discriminant field in the `enum`.\n" "* `WebEvent::Click { ... }` is not exactly the same as `WebEvent::" "Click(Click)` with a top level `struct Click { ... }`. The inlined version " "cannot implement traits, for example." msgstr "" #: src/enums/sizes.md:1 msgid "# Enum Sizes" msgstr "" #: src/enums/sizes.md:3 msgid "" "Rust enums are packed tightly, taking constraints due to alignment into " "account:" msgstr "" #: src/enums/sizes.md:5 msgid "" "```rust,editable\n" "use std::mem::{align_of, size_of};" msgstr "" #: src/enums/sizes.md:8 msgid "" "macro_rules! dbg_size {\n" " ($t:ty) => {\n" " println!(\"{}: size {} bytes, align: {} bytes\",\n" " stringify!($t), size_of::<$t>(), align_of::<$t>());\n" " };\n" "}" msgstr "" #: src/enums/sizes.md:15 msgid "" "enum Foo {\n" " A,\n" " B,\n" "}" msgstr "" #: src/enums/sizes.md:20 msgid "" "fn main() {\n" " dbg_size!(Foo);\n" " dbg_size!(bool);\n" " dbg_size!(Option);\n" " dbg_size!(&i32);\n" " dbg_size!(Option<&i32>);\n" "}\n" "```" msgstr "" #: src/enums/sizes.md:29 msgid "" "* See the [Rust Reference](https://doc.rust-lang.org/reference/type-layout." "html)." msgstr "" #: src/enums/sizes.md:33 msgid "" "* `Option` is another example of tight packing.\n" "* For [some types](https://doc.rust-lang.org/std/option/#representation), " "Rust guarantees that `size_of::()` equals `size_of::>()`.\n" "* Zero-sized types allow for efficient implementation of `HashSet` using " "`HashMap` with `()` as the value." msgstr "" #: src/methods.md:3 msgid "" "Rust allows you to associate functions with your new types. You do this with " "an\n" "`impl` block:" msgstr "" #: src/methods.md:13 msgid "" "impl Person {\n" " fn say_hello(&self) {\n" " println!(\"Hello, my name is {}\", self.name);\n" " }\n" "}" msgstr "" #: src/methods.md:19 msgid "" "fn main() {\n" " let peter = Person {\n" " name: String::from(\"Peter\"),\n" " age: 27,\n" " };\n" " peter.say_hello();\n" "}\n" "```" msgstr "" #: src/methods/receiver.md:1 msgid "# Method Receiver" msgstr "" #: src/methods/receiver.md:3 msgid "" "The `&self` above indicates that the method borrows the object immutably. " "There\n" "are other possible receivers for a method:" msgstr "" #: src/methods/receiver.md:6 msgid "" "* `&self`: borrows the object from the caller using a shared and immutable\n" " reference. The object can be used again afterwards.\n" "* `&mut self`: borrows the object from the caller using a unique and " "mutable\n" " reference. The object can be used again afterwards.\n" "* `self`: takes ownership of the object and moves it away from the caller. " "The\n" " method becomes the owner of the object. The object will be dropped " "(deallocated)\n" " when the method returns, unless its ownership is explicitly\n" " transmitted.\n" "* No receiver: this becomes a static method on the struct. Typically used " "to\n" " create constructors which are called `new` by convention." msgstr "" #: src/methods/receiver.md:17 msgid "" "Beyond variants on `self`, there are also\n" "[special wrapper types](https://doc.rust-lang.org/reference/special-types-" "and-traits.html)\n" "allowed to be receiver types, such as `Box`." msgstr "" #: src/methods/example.md:1 src/concurrency/shared_state/example.md:1 msgid "# Example" msgstr "" #: src/methods/example.md:3 msgid "" "```rust,editable\n" "#[derive(Debug)]\n" "struct Race {\n" " name: String,\n" " laps: Vec,\n" "}" msgstr "" #: src/methods/example.md:10 msgid "" "impl Race {\n" " fn new(name: &str) -> Race { // No receiver, a static method\n" " Race { name: String::from(name), laps: Vec::new() }\n" " }" msgstr "" #: src/methods/example.md:15 msgid "" " fn add_lap(&mut self, lap: i32) { // Exclusive borrowed read-write " "access to self\n" " self.laps.push(lap);\n" " }" msgstr "" #: src/methods/example.md:19 msgid "" " fn print_laps(&self) { // Shared and read-only borrowed access to self\n" " println!(\"Recorded {} laps for {}:\", self.laps.len(), self.name);\n" " for (idx, lap) in self.laps.iter().enumerate() {\n" " println!(\"Lap {idx}: {lap} sec\");\n" " }\n" " }" msgstr "" #: src/methods/example.md:26 msgid "" " fn finish(self) { // Exclusive ownership of self\n" " let total = self.laps.iter().sum::();\n" " println!(\"Race {} is finished, total lap time: {}\", self.name, " "total);\n" " }\n" "}" msgstr "" #: src/methods/example.md:32 msgid "" "fn main() {\n" " let mut race = Race::new(\"Monaco Grand Prix\");\n" " race.add_lap(70);\n" " race.add_lap(68);\n" " race.print_laps();\n" " race.add_lap(71);\n" " race.print_laps();\n" " race.finish();\n" "}\n" "```" msgstr "" #: src/pattern-matching.md:1 msgid "# Pattern Matching" msgstr "" #: src/pattern-matching.md:3 msgid "" "The `match` keyword let you match a value against one or more _patterns_. " "The\n" "comparisons are done from top to bottom and the first match wins." msgstr "" #: src/pattern-matching.md:6 msgid "The patterns can be simple values, similarly to `switch` in C and C++:" msgstr "" #: src/pattern-matching.md:8 msgid "" "```rust,editable\n" "fn main() {\n" " let input = 'x';" msgstr "" #: src/pattern-matching.md:12 msgid "" " match input {\n" " 'q' => println!(\"Quitting\"),\n" " 'a' | 's' | 'w' | 'd' => println!(\"Moving around\"),\n" " '0'..='9' => println!(\"Number input\"),\n" " _ => println!(\"Something else\"),\n" " }\n" "}\n" "```" msgstr "" #: src/pattern-matching.md:21 msgid "The `_` pattern is a wildcard pattern which matches any value." msgstr "" #: src/pattern-matching/destructuring-enums.md:1 msgid "# Destructuring Enums" msgstr "" #: src/pattern-matching/destructuring-enums.md:3 msgid "" "Patterns can also be used to bind variables to parts of your values. This is " "how\n" "you inspect the structure of your types. Let us start with a simple `enum` " "type:" msgstr "" #: src/pattern-matching/destructuring-enums.md:6 msgid "" "```rust,editable\n" "enum Result {\n" " Ok(i32),\n" " Err(String),\n" "}" msgstr "" #: src/pattern-matching/destructuring-enums.md:12 msgid "" "fn divide_in_two(n: i32) -> Result {\n" " if n % 2 == 0 {\n" " Result::Ok(n / 2)\n" " } else {\n" " Result::Err(format!(\"cannot divide {} into two equal parts\", n))\n" " }\n" "}" msgstr "" #: src/pattern-matching/destructuring-enums.md:20 msgid "" "fn main() {\n" " let n = 100;\n" " match divide_in_two(n) {\n" " Result::Ok(half) => println!(\"{n} divided in two is {half}\"),\n" " Result::Err(msg) => println!(\"sorry, an error happened: {msg}\"),\n" " }\n" "}\n" "```" msgstr "" #: src/pattern-matching/destructuring-enums.md:29 msgid "" "Here we have used the arms to _destructure_ the `Result` value. In the " "first\n" "arm, `half` is bound to the value inside the `Ok` variant. In the second " "arm,\n" "`msg` is bound to the error message." msgstr "" #: src/pattern-matching/destructuring-structs.md:1 msgid "# Destructuring Structs" msgstr "" #: src/pattern-matching/destructuring-structs.md:3 msgid "You can also destructure `structs`:" msgstr "" #: src/pattern-matching/destructuring-structs.md:5 msgid "" "```rust,editable\n" "struct Foo {\n" " x: (u32, u32),\n" " y: u32,\n" "}" msgstr "" #: src/pattern-matching/destructuring-structs.md:11 msgid "" "#[rustfmt::skip]\n" "fn main() {\n" " let foo = Foo { x: (1, 2), y: 3 };\n" " match foo {\n" " Foo { x: (1, b), y } => println!(\"x.0 = 1, b = {b}, y = {y}\"),\n" " Foo { y: 2, x: i } => println!(\"y = 2, i = {i:?}\"),\n" " Foo { y, .. } => println!(\"y = {y}, other fields were " "ignored\"),\n" " }\n" "}\n" "```" msgstr "" #: src/pattern-matching/destructuring-arrays.md:1 msgid "# Destructuring Arrays" msgstr "" #: src/pattern-matching/destructuring-arrays.md:3 msgid "" "You can destructure arrays, tuples, and slices by matching on their elements:" msgstr "" #: src/pattern-matching/destructuring-arrays.md:5 msgid "" "```rust,editable\n" "#[rustfmt::skip]\n" "fn main() {\n" " let triple = [0, -2, 3];\n" " println!(\"Tell me about {triple:?}\");\n" " match triple {\n" " [0, y, z] => println!(\"First is 0, y = {y}, and z = {z}\"),\n" " [1, ..] => println!(\"First is 1 and the rest were ignored\"),\n" " _ => println!(\"All elements were ignored\"),\n" " }\n" "}\n" "```" msgstr "" #: src/pattern-matching/match-guards.md:1 msgid "# Match Guards" msgstr "" #: src/pattern-matching/match-guards.md:3 msgid "" "When matching, you can add a _guard_ to a pattern. This is an arbitrary " "Boolean\n" "expression which will be executed if the pattern matches:" msgstr "" #: src/pattern-matching/match-guards.md:6 msgid "" "```rust,editable\n" "#[rustfmt::skip]\n" "fn main() {\n" " let pair = (2, -2);\n" " println!(\"Tell me about {pair:?}\");\n" " match pair {\n" " (x, y) if x == y => println!(\"These are twins\"),\n" " (x, y) if x + y == 0 => println!(\"Antimatter, kaboom!\"),\n" " (x, _) if x % 2 == 1 => println!(\"The first one is odd\"),\n" " _ => println!(\"No correlation...\"),\n" " }\n" "}\n" "```" msgstr "" #: src/exercises/day-2/morning.md:1 msgid "# Day 2: Morning Exercises" msgstr "" #: src/exercises/day-2/morning.md:3 msgid "We will look at implementing methods in two contexts:" msgstr "" #: src/exercises/day-2/morning.md:5 msgid "* Simple struct which tracks health statistics." msgstr "" #: src/exercises/day-2/morning.md:7 msgid "* Multiple structs and enums for a drawing library." msgstr "" #: src/exercises/day-2/health-statistics.md:1 msgid "# Health Statistics" msgstr "" #: src/exercises/day-2/health-statistics.md:3 msgid "" "You're working on implementing a health-monitoring system. As part of that, " "you\n" "need to keep track of users' health statistics." msgstr "" #: src/exercises/day-2/health-statistics.md:6 msgid "" "You'll start with some stubbed functions in an `impl` block as well as a " "`User`\n" "struct definition. Your goal is to implement the stubbed out methods on the\n" "`User` `struct` defined in the `impl` block." msgstr "" #: src/exercises/day-2/health-statistics.md:10 msgid "" "Copy the code below to and fill in the " "missing\n" "methods:" msgstr "" #: src/exercises/day-2/health-statistics.md:17 msgid "" "struct User {\n" " name: String,\n" " age: u32,\n" " weight: f32,\n" "}" msgstr "" #: src/exercises/day-2/health-statistics.md:23 msgid "" "impl User {\n" " pub fn new(name: String, age: u32, weight: f32) -> Self {\n" " unimplemented!()\n" " }" msgstr "" #: src/exercises/day-2/health-statistics.md:28 msgid "" " pub fn name(&self) -> &str {\n" " unimplemented!()\n" " }" msgstr "" #: src/exercises/day-2/health-statistics.md:32 msgid "" " pub fn age(&self) -> u32 {\n" " unimplemented!()\n" " }" msgstr "" #: src/exercises/day-2/health-statistics.md:36 msgid "" " pub fn weight(&self) -> f32 {\n" " unimplemented!()\n" " }" msgstr "" #: src/exercises/day-2/health-statistics.md:40 msgid "" " pub fn set_age(&mut self, new_age: u32) {\n" " unimplemented!()\n" " }" msgstr "" #: src/exercises/day-2/health-statistics.md:44 msgid "" " pub fn set_weight(&mut self, new_weight: f32) {\n" " unimplemented!()\n" " }\n" "}" msgstr "" #: src/exercises/day-2/health-statistics.md:49 msgid "" "fn main() {\n" " let bob = User::new(String::from(\"Bob\"), 32, 155.2);\n" " println!(\"I'm {} and my age is {}\", bob.name(), bob.age());\n" "}" msgstr "" #: src/exercises/day-2/health-statistics.md:54 msgid "" "#[test]\n" "fn test_weight() {\n" " let bob = User::new(String::from(\"Bob\"), 32, 155.2);\n" " assert_eq!(bob.weight(), 155.2);\n" "}" msgstr "" #: src/exercises/day-2/health-statistics.md:60 msgid "" "#[test]\n" "fn test_set_age() {\n" " let mut bob = User::new(String::from(\"Bob\"), 32, 155.2);\n" " assert_eq!(bob.age(), 32);\n" " bob.set_age(33);\n" " assert_eq!(bob.age(), 33);\n" "}\n" "```" msgstr "" #: src/exercises/day-2/points-polygons.md:1 msgid "# Polygon Struct" msgstr "" #: src/exercises/day-2/points-polygons.md:3 msgid "" "We will create a `Polygon` struct which contain some points. Copy the code " "below\n" "to and fill in the missing methods to make " "the\n" "tests pass:" msgstr "" #: src/exercises/day-2/points-polygons.md:7 src/exercises/day-2/luhn.md:23 #: src/exercises/day-2/strings-iterators.md:12 msgid "" "```rust\n" "// TODO: remove this when you're done with your implementation.\n" "#![allow(unused_variables, dead_code)]" msgstr "" #: src/exercises/day-2/points-polygons.md:11 msgid "" "pub struct Point {\n" " // add fields\n" "}" msgstr "" #: src/exercises/day-2/points-polygons.md:15 msgid "" "impl Point {\n" " // add methods\n" "}" msgstr "" #: src/exercises/day-2/points-polygons.md:19 msgid "" "pub struct Polygon {\n" " // add fields\n" "}" msgstr "" #: src/exercises/day-2/points-polygons.md:23 msgid "" "impl Polygon {\n" " // add methods\n" "}" msgstr "" #: src/exercises/day-2/points-polygons.md:27 msgid "" "pub struct Circle {\n" " // add fields\n" "}" msgstr "" #: src/exercises/day-2/points-polygons.md:31 msgid "" "impl Circle {\n" " // add methods\n" "}" msgstr "" #: src/exercises/day-2/points-polygons.md:35 msgid "" "pub enum Shape {\n" " Polygon(Polygon),\n" " Circle(Circle),\n" "}" msgstr "" #: src/exercises/day-2/points-polygons.md:40 src/testing/test-modules.md:15 msgid "" "#[cfg(test)]\n" "mod tests {\n" " use super::*;" msgstr "" #: src/exercises/day-2/points-polygons.md:44 #: src/exercises/day-2/solutions-morning.md:165 msgid "" " fn round_two_digits(x: f64) -> f64 {\n" " (x * 100.0).round() / 100.0\n" " }" msgstr "" #: src/exercises/day-2/points-polygons.md:48 #: src/exercises/day-2/solutions-morning.md:169 msgid "" " #[test]\n" " fn test_point_magnitude() {\n" " let p1 = Point::new(12, 13);\n" " assert_eq!(round_two_digits(p1.magnitude()), 17.69);\n" " }" msgstr "" #: src/exercises/day-2/points-polygons.md:54 #: src/exercises/day-2/solutions-morning.md:175 msgid "" " #[test]\n" " fn test_point_dist() {\n" " let p1 = Point::new(10, 10);\n" " let p2 = Point::new(14, 13);\n" " assert_eq!(round_two_digits(p1.dist(p2)), 5.00);\n" " }" msgstr "" #: src/exercises/day-2/points-polygons.md:61 #: src/exercises/day-2/solutions-morning.md:182 msgid "" " #[test]\n" " fn test_point_add() {\n" " let p1 = Point::new(16, 16);\n" " let p2 = p1 + Point::new(-4, 3);\n" " assert_eq!(p2, Point::new(12, 19));\n" " }" msgstr "" #: src/exercises/day-2/points-polygons.md:68 #: src/exercises/day-2/solutions-morning.md:189 msgid "" " #[test]\n" " fn test_polygon_left_most_point() {\n" " let p1 = Point::new(12, 13);\n" " let p2 = Point::new(16, 16);" msgstr "" #: src/exercises/day-2/points-polygons.md:73 #: src/exercises/day-2/solutions-morning.md:194 msgid "" " let mut poly = Polygon::new();\n" " poly.add_point(p1);\n" " poly.add_point(p2);\n" " assert_eq!(poly.left_most_point(), Some(p1));\n" " }" msgstr "" #: src/exercises/day-2/points-polygons.md:79 #: src/exercises/day-2/solutions-morning.md:200 msgid "" " #[test]\n" " fn test_polygon_iter() {\n" " let p1 = Point::new(12, 13);\n" " let p2 = Point::new(16, 16);" msgstr "" #: src/exercises/day-2/points-polygons.md:84 #: src/exercises/day-2/solutions-morning.md:205 msgid "" " let mut poly = Polygon::new();\n" " poly.add_point(p1);\n" " poly.add_point(p2);" msgstr "" #: src/exercises/day-2/points-polygons.md:88 #: src/exercises/day-2/solutions-morning.md:209 msgid "" " let points = poly.iter().cloned().collect::>();\n" " assert_eq!(points, vec![Point::new(12, 13), Point::new(16, 16)]);\n" " }" msgstr "" #: src/exercises/day-2/points-polygons.md:92 msgid "" " #[test]\n" " fn test_shape_circumferences() {\n" " let mut poly = Polygon::new();\n" " poly.add_point(Point::new(12, 13));\n" " poly.add_point(Point::new(17, 11));\n" " poly.add_point(Point::new(16, 16));\n" " let shapes = vec![\n" " Shape::from(poly),\n" " Shape::from(Circle::new(Point::new(10, 20), 5)),\n" " ];\n" " let circumferences = shapes\n" " .iter()\n" " .map(Shape::circumference)\n" " .map(round_two_digits)\n" " .collect::>();\n" " assert_eq!(circumferences, vec![15.48, 31.42]);\n" " }\n" "}" msgstr "" #: src/exercises/day-2/points-polygons.md:111 src/exercises/day-2/luhn.md:68 #: src/exercises/day-2/solutions-morning.md:233 msgid "" "#[allow(dead_code)]\n" "fn main() {}\n" "```" msgstr "" #: src/control-flow.md:1 msgid "# Control Flow" msgstr "" #: src/control-flow.md:3 msgid "" "As we have seen, `if` is an expression in Rust. It is used to conditionally\n" "evaluate one of two blocks, but the blocks can have a value which then " "becomes\n" "the value of the `if` expression. Other control flow expressions work " "similarly\n" "in Rust." msgstr "" #: src/control-flow/blocks.md:1 msgid "# Blocks" msgstr "" #: src/control-flow/blocks.md:3 msgid "" "A block in Rust has a value and a type: the value is the last expression of " "the\n" "block:" msgstr "" #: src/control-flow/blocks.md:6 msgid "" "```rust,editable\n" "fn main() {\n" " let x = {\n" " let y = 10;\n" " println!(\"y: {y}\");\n" " let z = {\n" " let w = {\n" " 3 + 4\n" " };\n" " println!(\"w: {w}\");\n" " y * w\n" " };\n" " println!(\"z: {z}\");\n" " z - y\n" " };\n" " println!(\"x: {x}\");\n" "}\n" "```" msgstr "" #: src/control-flow/blocks.md:25 msgid "" "The same rule is used for functions: the value of the function body is the\n" "return value:" msgstr "" #: src/control-flow/blocks.md:28 msgid "" "```rust,editable\n" "fn double(x: i32) -> i32 {\n" " x + x\n" "}" msgstr "" #: src/control-flow/blocks.md:33 msgid "" "fn main() {\n" " println!(\"doubled: {}\", double(7));\n" "}\n" "```" msgstr "" #: src/control-flow/if-expressions.md:1 msgid "# `if` expressions" msgstr "" #: src/control-flow/if-expressions.md:3 msgid "You use `if` very similarly to how you would in other languages:" msgstr "" #: src/control-flow/if-expressions.md:5 msgid "" "```rust,editable\n" "fn main() {\n" " let mut x = 10;\n" " if x % 2 == 0 {\n" " x = x / 2;\n" " } else {\n" " x = 3 * x + 1;\n" " }\n" "}\n" "```" msgstr "" #: src/control-flow/if-expressions.md:16 msgid "" "In addition, you can use it as an expression. This does the same as above:" msgstr "" #: src/control-flow/if-expressions.md:18 msgid "" "```rust,editable\n" "fn main() {\n" " let mut x = 10;\n" " x = if x % 2 == 0 {\n" " x / 2\n" " } else {\n" " 3 * x + 1\n" " };\n" "}\n" "```" msgstr "" #: src/control-flow/if-let-expressions.md:1 msgid "# `if let` expressions" msgstr "" #: src/control-flow/if-let-expressions.md:3 msgid "If you want to match a value against a pattern, you can use `if let`:" msgstr "" #: src/control-flow/if-let-expressions.md:5 msgid "" "```rust,editable\n" "fn main() {\n" " let arg = std::env::args().next();\n" " if let Some(value) = arg {\n" " println!(\"Program name: {value}\");\n" " } else {\n" " println!(\"Missing name?\");\n" " }\n" "}\n" "```" msgstr "" #: src/control-flow/if-let-expressions.md:16 #: src/control-flow/while-let-expressions.md:21 #: src/control-flow/match-expressions.md:22 msgid "" "See [pattern matching](../pattern-matching.md) for more details on patterns " "in\n" "Rust." msgstr "" #: src/control-flow/if-let-expressions.md:21 msgid "" "* `if let` can be more concise than `match`, e.g., when only one case is " "interesting. In contrast, `match` requires all branches to be covered.\n" "* A common usage is handling `Some` values when working with `Option`.\n" "* Unlike `match`, `if let` does not support guard clauses for pattern " "matching." msgstr "" #: src/control-flow/while-expressions.md:1 msgid "# `while` expressions" msgstr "" #: src/control-flow/while-expressions.md:3 msgid "The `while` keyword works very similar to other languages:" msgstr "" #: src/control-flow/while-expressions.md:5 msgid "" "```rust,editable\n" "fn main() {\n" " let mut x = 10;\n" " while x != 1 {\n" " x = if x % 2 == 0 {\n" " x / 2\n" " } else {\n" " 3 * x + 1\n" " };\n" " }\n" " println!(\"Final x: {x}\");\n" "}\n" "```" msgstr "" #: src/control-flow/while-let-expressions.md:1 msgid "# `while let` expressions" msgstr "" #: src/control-flow/while-let-expressions.md:3 msgid "" "Like with `if`, there is a `while let` variant which repeatedly tests a " "value\n" "against a pattern:" msgstr "" #: src/control-flow/while-let-expressions.md:6 msgid "" "```rust,editable\n" "fn main() {\n" " let v = vec![10, 20, 30];\n" " let mut iter = v.into_iter();" msgstr "" #: src/control-flow/while-let-expressions.md:11 msgid "" " while let Some(x) = iter.next() {\n" " println!(\"x: {x}\");\n" " }\n" "}\n" "```" msgstr "" #: src/control-flow/while-let-expressions.md:17 msgid "" "Here the iterator returned by `v.iter()` will return a `Option` on " "every\n" "call to `next()`. It returns `Some(x)` until it is done, after which it " "will\n" "return `None`. The `while let` lets us keep iterating through all items." msgstr "" #: src/control-flow/for-expressions.md:1 msgid "# `for` expressions" msgstr "" #: src/control-flow/for-expressions.md:3 msgid "" "The `for` expression is closely related to the `while let` expression. It " "will\n" "automatically call `into_iter()` on the expression and then iterate over it:" msgstr "" #: src/control-flow/for-expressions.md:6 msgid "" "```rust,editable\n" "fn main() {\n" " let v = vec![10, 20, 30];" msgstr "" #: src/control-flow/for-expressions.md:10 msgid "" " for x in v {\n" " println!(\"x: {x}\");\n" " }\n" "}\n" "```" msgstr "" #: src/control-flow/for-expressions.md:16 msgid "You can use `break` and `continue` here as usual." msgstr "" #: src/control-flow/loop-expressions.md:1 msgid "# `loop` expressions" msgstr "" #: src/control-flow/loop-expressions.md:3 msgid "" "Finally, there is a `loop` keyword which creates an endless loop. Here you " "must\n" "either `break` or `return` to stop the loop:" msgstr "" #: src/control-flow/loop-expressions.md:6 msgid "" "```rust,editable\n" "fn main() {\n" " let mut x = 10;\n" " loop {\n" " x = if x % 2 == 0 {\n" " x / 2\n" " } else {\n" " 3 * x + 1\n" " };\n" " if x == 1 {\n" " break;\n" " }\n" " }\n" " println!(\"Final x: {x}\");\n" "}\n" "```" msgstr "" #: src/control-flow/match-expressions.md:1 msgid "# `match` expressions" msgstr "" #: src/control-flow/match-expressions.md:3 msgid "" "The `match` keyword is used to match a value against one or more patterns. " "In\n" "that sense, it works like a series of `if let` expressions:" msgstr "" #: src/control-flow/match-expressions.md:6 msgid "" "```rust,editable\n" "fn main() {\n" " match std::env::args().next().as_deref() {\n" " Some(\"cat\") => println!(\"Will do cat things\"),\n" " Some(\"ls\") => println!(\"Will ls some files\"),\n" " Some(\"mv\") => println!(\"Let's move some files\"),\n" " Some(\"rm\") => println!(\"Uh, dangerous!\"),\n" " None => println!(\"Hmm, no program name?\"),\n" " _ => println!(\"Unknown program name!\"),\n" " }\n" "}\n" "```" msgstr "" #: src/control-flow/match-expressions.md:19 msgid "" "Like `if let`, each match arm must have the same type. The type is the last\n" "expression of the block, if any. In the example above, the type is `()`." msgstr "" #: src/control-flow/break-continue.md:1 msgid "# `break` and `continue`" msgstr "" #: src/control-flow/break-continue.md:3 msgid "" "If you want to exit a loop early, use `break`, if you want to immediately " "start\n" "the next iteration use `continue`. Both `continue` and `break` can " "optionally\n" "take a label argument which is used to break out of nested loops:" msgstr "" #: src/control-flow/break-continue.md:7 msgid "" "```rust,editable\n" "fn main() {\n" " let v = vec![10, 20, 30];\n" " let mut iter = v.into_iter();\n" " 'outer: while let Some(x) = iter.next() {\n" " println!(\"x: {x}\");\n" " let mut i = 0;\n" " while i < x {\n" " println!(\"x: {x}, i: {i}\");\n" " i += 1;\n" " if i == 3 {\n" " break 'outer;\n" " }\n" " }\n" " }\n" "}\n" "```" msgstr "" #: src/control-flow/break-continue.md:25 msgid "" "In this case we break the outer loop after 3 iterations of the inner loop." msgstr "" #: src/std.md:1 msgid "# Standard Library" msgstr "" #: src/std.md:3 msgid "" "Rust comes with a standard library which helps establish a set of common " "types\n" "used by Rust library and programs. This way, two libraries can work " "together\n" "smoothly because they both use the same `String` type." msgstr "" #: src/std.md:7 msgid "The common vocabulary types include:" msgstr "" #: src/std.md:9 msgid "" "* [`Option` and `Result`](std/option-result.md) types: used for optional " "values\n" " and [error handling](error-handling.md)." msgstr "" #: src/std.md:12 msgid "" "* [`String`](std/string.md): the default string type used for owned data." msgstr "" #: src/std.md:14 msgid "* [`Vec`](std/vec.md): a standard extensible vector." msgstr "" #: src/std.md:16 msgid "" "* [`HashMap`](std/hashmap.md): a hash map type with a configurable hashing\n" " algorithm." msgstr "" #: src/std.md:19 msgid "* [`Box`](std/box.md): an owned pointer for heap-allocated data." msgstr "" #: src/std.md:21 msgid "" "* [`Rc`](std/rc.md): a shared reference-counted pointer for heap-allocated " "data." msgstr "" #: src/std/string.md:1 msgid "# String" msgstr "" #: src/std/string.md:3 msgid "" "[`String`][1] is the standard heap-allocated growable UTF-8 string buffer:" msgstr "" #: src/std/string.md:5 msgid "" "```rust,editable\n" "fn main() {\n" " let mut s1 = String::new();\n" " s1.push_str(\"Hello\");\n" " println!(\"s1: len = {}, capacity = {}\", s1.len(), s1.capacity());" msgstr "" #: src/std/string.md:11 msgid "" " let mut s2 = String::with_capacity(s1.len() + 1);\n" " s2.push_str(&s1);\n" " s2.push('!');\n" " println!(\"s2: len = {}, capacity = {}\", s2.len(), s2.capacity());" msgstr "" #: src/std/string.md:16 msgid "" " let s3 = String::from(\"🇨🇭\");\n" " println!(\"s3: len = {}, number of chars = {}\", s3.len(),\n" " s3.chars().count());\n" "}\n" "```" msgstr "" #: src/std/string.md:22 msgid "" "`String` implements [`Deref`][2], which means that you can " "call all\n" "`str` methods on a `String`." msgstr "" #: src/std/string.md:25 msgid "" "[1]: https://doc.rust-lang.org/std/string/struct.String.html\n" "[2]: https://doc.rust-lang.org/std/string/struct.String.html#deref-methods-" "str" msgstr "" #: src/std/string.md:30 msgid "" "* `len` returns the size of the `String` in bytes, not its length in " "characters.\n" "* `chars` returns an iterator over the actual characters.\n" "* `String` implements `Deref` which transparently gives it " "access to `str`'s methods." msgstr "" #: src/std/option-result.md:1 msgid "# `Option` and `Result`" msgstr "" #: src/std/option-result.md:3 msgid "The types represent optional data:" msgstr "" #: src/std/option-result.md:5 msgid "" "```rust,editable\n" "fn main() {\n" " let numbers = vec![10, 20, 30];\n" " let first: Option<&i8> = numbers.first();\n" " println!(\"first: {first:?}\");" msgstr "" #: src/std/option-result.md:11 msgid "" " let idx: Result = numbers.binary_search(&10);\n" " println!(\"idx: {idx:?}\");\n" "}\n" "```" msgstr "" #: src/std/option-result.md:18 msgid "" "* `Option` and `Result` are widely used not just in the standard library.\n" "* `Option<&T>` has zero space overhead compared to `&T`.\n" "* `Result` is the standard type to implement error handling as we will see " "on Day 3.\n" "* `binary_search` returns `Result`.\n" " * If found, `Result::Ok` holds the index where the element is found.\n" " * Otherwise, `Result::Err` contains the index where such an element should " "be inserted." msgstr "" #: src/std/vec.md:1 msgid "# `Vec`" msgstr "" #: src/std/vec.md:3 msgid "[`Vec`][1] is the standard resizable heap-allocated buffer:" msgstr "" #: src/std/vec.md:5 msgid "" "```rust,editable\n" "fn main() {\n" " let mut numbers = Vec::new();\n" " numbers.push(42);" msgstr "" #: src/std/vec.md:10 msgid "" " let mut v1 = Vec::new();\n" " v1.push(42);\n" " println!(\"v1: len = {}, capacity = {}\", v1.len(), v1.capacity());" msgstr "" #: src/std/vec.md:14 msgid "" " let mut v2 = Vec::with_capacity(v1.len() + 1);\n" " v2.extend(v1.iter());\n" " v2.push(9999);\n" " println!(\"v2: len = {}, capacity = {}\", v2.len(), v2.capacity());\n" "}\n" "```" msgstr "" #: src/std/vec.md:21 msgid "" "`Vec` implements [`Deref`][2], which means that you can call " "slice\n" "methods on a `Vec`." msgstr "" #: src/std/vec.md:24 msgid "" "[1]: https://doc.rust-lang.org/std/vec/struct.Vec.html\n" "[2]: https://doc.rust-lang.org/std/vec/struct.Vec.html#deref-methods-[T]" msgstr "" #: src/std/hashmap.md:1 msgid "# `HashMap`" msgstr "" #: src/std/hashmap.md:3 msgid "Standard hash map with protection against HashDoS attacks:" msgstr "" #: src/std/hashmap.md:5 msgid "" "```rust,editable\n" "use std::collections::HashMap;" msgstr "" #: src/std/hashmap.md:8 msgid "" "fn main() {\n" " let mut page_counts = HashMap::new();\n" " page_counts.insert(\"Adventures of Huckleberry Finn\".to_string(), " "207);\n" " page_counts.insert(\"Grimms' Fairy Tales\".to_string(), 751);\n" " page_counts.insert(\"Pride and Prejudice\".to_string(), 303);" msgstr "" #: src/std/hashmap.md:14 msgid "" " if !page_counts.contains_key(\"Les Misérables\") {\n" " println!(\"We've know about {} books, but not Les Misérables.\",\n" " page_counts.len());\n" " }" msgstr "" #: src/std/hashmap.md:19 msgid "" " for book in [\"Pride and Prejudice\", \"Alice's Adventure in " "Wonderland\"] {\n" " match page_counts.get(book) {\n" " Some(count) => println!(\"{book}: {count} pages\"),\n" " None => println!(\"{book} is unknown.\")\n" " }\n" " }\n" "}\n" "```" msgstr "" #: src/std/box.md:1 msgid "# `Box`" msgstr "" #: src/std/box.md:3 msgid "[`Box`][1] is an owned pointer to data on the heap:" msgstr "" #: src/std/box.md:5 msgid "" "```rust,editable\n" "fn main() {\n" " let five = Box::new(5);\n" " println!(\"five: {}\", *five);\n" "}\n" "```" msgstr "" #: src/std/box.md:13 msgid "" "```bob\n" " Stack Heap\n" ".- - - - - - -. .- - - - - - -.\n" ": : : :\n" ": five : : :\n" ": +-----+ : : +-----+ :\n" ": | o---|---+-----+-->| 5 | :\n" ": +-----+ : : +-----+ :\n" ": : : :\n" ": : : :\n" "`- - - - - - -' `- - - - - - -'\n" "```" msgstr "" #: src/std/box.md:26 msgid "" "`Box` implements `Deref`, which means that you can [call " "methods\n" "from `T` directly on a `Box`][2]." msgstr "" #: src/std/box.md:29 msgid "" "[1]: https://doc.rust-lang.org/std/boxed/struct.Box.html\n" "[2]: https://doc.rust-lang.org/std/ops/trait.Deref.html#more-on-deref-" "coercion" msgstr "" #: src/std/box.md:34 msgid "" "* `Box` is like `std::unique_ptr` in C++.\n" "* In the above example, you can even leave out the `*` in the `println!` " "statement thanks to `Deref`." msgstr "" #: src/std/box-recursive.md:1 msgid "# Box with Recursive Data Structures" msgstr "" #: src/std/box-recursive.md:3 msgid "" "Recursive data types or data types with dynamic sizes need to use a `Box`:" msgstr "" #: src/std/box-recursive.md:5 src/std/box-niche.md:3 msgid "" "```rust,editable\n" "#[derive(Debug)]\n" "enum List {\n" " Cons(T, Box>),\n" " Nil,\n" "}" msgstr "" #: src/std/box-recursive.md:12 src/std/box-niche.md:10 msgid "" "fn main() {\n" " let list: List = List::Cons(1, Box::new(List::Cons(2, Box::" "new(List::Nil))));\n" " println!(\"{list:?}\");\n" "}\n" "```" msgstr "" #: src/std/box-recursive.md:18 msgid "" "```bob\n" " Stack Heap\n" ".- - - - - - - - - - - - -. .- - - - - - - - - - - - - - - - - - - - - - " "- -.\n" ": : : :\n" ": " "list : : :\n" ": +--------+-------+ : : +--------+--------+ +--------+------" "+ :\n" ": | Tag | Cons | : : .->| Tag | Cons | .->| Tag | Nil " "| :\n" ": | 0 | 1 | : : | | 0 | 2 | | | ////// | //// " "| :\n" ": | 1 | o-----+----+-----+-' | 1 | o------+-' | ////// | //// " "| :\n" ": +--------+-------+ : : +--------+--------+ +--------+------" "+ :\n" ": : : :\n" ": : : :\n" "`- - - - - - - - - - - - -' '- - - - - - - - - - - - - - - - - - - - - - " "- -'\n" "```" msgstr "" #: src/std/box-niche.md:1 msgid "# Niche Optimization" msgstr "" #: src/std/box-niche.md:16 msgid "" "A `Box` cannot be empty, so the pointer is always valid and non-`null`. " "This\n" "allows the compiler to optimize the memory layout:" msgstr "" #: src/std/box-niche.md:19 #, fuzzy msgid "" "```bob\n" " Stack Heap\n" ".- - - - - - - - - - - - -. .- - - - - - - - - - - - - - - - - - - - - - " "- -.\n" ": : : :\n" ": " "list : : :\n" ": +--------+-------+ : : +--------+--------+ +--------+------" "+ :\n" ": | 0 | 1 | : : .->| 0 | 2 | .->| ////// | //// " "| :\n" ": | \"1/Tag\"| o-----+----+-----+-' | \"1/Tag\"| o-----+-' | \"1/Tag\"| " "null | :\n" ": +--------+-------+ : : +--------+--------+ +--------+------" "+ :\n" ": : : :\n" ": : : :\n" "`- - - - - - - - - - - - -' '- - - - - - - - - - - - - - - - - - - - - - " "- -'\n" "```" msgstr "" "```bob\n" " Stak Bunke\n" ".- - - - - - - - - - - - - -. .- - - - - - - - - - - - - - - -.\n" ": : : :\n" ": s1 : : :\n" ": +-----------+-------+ : : +----+----+----+----+----+ :\n" ": | ptr | o---+---+-----+-->| H | a | l | l | o | :\n" ": | len | 5 | : : +----+----+----+----+----+ :\n" ": | capacity | 5 | : : :\n" ": +-----------+-------+ : : :\n" ": : `- - - - - - - - - - - - - - - -'\n" "`- - - - - - - - - - - - - -'\n" "```" #: src/std/rc.md:1 msgid "# `Rc`" msgstr "" #: src/std/rc.md:3 msgid "" "[`Rc`][1] is a reference-counted shared pointer. Use this when you need to " "refer\n" "to the same data from multiple places:" msgstr "" #: src/std/rc.md:6 msgid "" "```rust,editable\n" "use std::rc::Rc;" msgstr "" #: src/std/rc.md:9 msgid "" "fn main() {\n" " let mut a = Rc::new(10);\n" " let mut b = a.clone();" msgstr "" #: src/std/rc.md:18 msgid "" "If you need to mutate the data inside an `Rc`, you will need to wrap the " "data in\n" "a type such as [`Cell` or `RefCell`][2]. See [`Arc`][3] if you are in a " "multi-threaded\n" "context." msgstr "" #: src/std/rc.md:22 msgid "" "[1]: https://doc.rust-lang.org/std/rc/struct.Rc.html\n" "[2]: https://doc.rust-lang.org/std/cell/index.html\n" "[3]: ../concurrency/shared_state/arc.md" msgstr "" #: src/std/rc.md:28 msgid "" "* Like C++'s `std::shared_ptr`.\n" "* `clone` is cheap: creates a pointer to the same allocation and increases " "the reference count.\n" "* `make_mut` actually clones the inner value if necessary (\"clone-on-" "write\") and returns a mutable reference." msgstr "" #: src/modules.md:1 msgid "# Modules" msgstr "" #: src/modules.md:3 msgid "We have seen how `impl` blocks let us namespace functions to a type." msgstr "" #: src/modules.md:5 msgid "Similarly, `mod` lets us namespace types and functions:" msgstr "" #: src/modules.md:7 msgid "" "```rust,editable\n" "mod foo {\n" " pub fn do_something() {\n" " println!(\"In the foo module\");\n" " }\n" "}" msgstr "" #: src/modules.md:14 msgid "" "mod bar {\n" " pub fn do_something() {\n" " println!(\"In the bar module\");\n" " }\n" "}" msgstr "" #: src/modules.md:20 msgid "" "fn main() {\n" " foo::do_something();\n" " bar::do_something();\n" "}\n" "```" msgstr "" #: src/modules/visibility.md:1 msgid "# Visibility" msgstr "" #: src/modules/visibility.md:3 msgid "Modules are a privacy boundary:" msgstr "" #: src/modules/visibility.md:5 msgid "" "* Module items are private by default (hides implementation details).\n" "* Parent and sibling items are always visible." msgstr "" #: src/modules/visibility.md:8 msgid "" "```rust,editable\n" "mod outer {\n" " fn private() {\n" " println!(\"outer::private\");\n" " }" msgstr "" #: src/modules/visibility.md:14 msgid "" " pub fn public() {\n" " println!(\"outer::public\");\n" " }" msgstr "" #: src/modules/visibility.md:18 msgid "" " mod inner {\n" " fn private() {\n" " println!(\"outer::inner::private\");\n" " }" msgstr "" #: src/modules/visibility.md:23 msgid "" " pub fn public() {\n" " println!(\"outer::inner::public\");\n" " super::private();\n" " }\n" " }\n" "}" msgstr "" #: src/modules/visibility.md:30 msgid "" "fn main() {\n" " outer::public();\n" "}\n" "```" msgstr "" #: src/modules/paths.md:1 msgid "# Paths" msgstr "" #: src/modules/paths.md:3 msgid "Paths are resolved as follows:" msgstr "" #: src/modules/paths.md:5 msgid "" "1. As a relative path:\n" " * `foo` or `self::foo` refers to `foo` in the current module,\n" " * `super::foo` refers to `foo` in the parent module." msgstr "" #: src/modules/paths.md:9 msgid "" "2. As an absolute path:\n" " * `crate::foo` refers to `foo` in the root of the current crate,\n" " * `bar::foo` refers to `foo` in the `bar` crate." msgstr "" #: src/modules/filesystem.md:1 msgid "# Filesystem Hierarchy" msgstr "" #: src/modules/filesystem.md:3 msgid "The module content can be omitted:" msgstr "" #: src/modules/filesystem.md:5 msgid "" "```rust,editable,compile_fail\n" "mod garden;\n" "```" msgstr "" #: src/modules/filesystem.md:9 msgid "The `garden` module content is found at:" msgstr "" #: src/modules/filesystem.md:11 msgid "" "* `src/garden.rs` (modern Rust 2018 style)\n" "* `src/garden/mod.rs` (older Rust 2015 style)" msgstr "" #: src/modules/filesystem.md:14 msgid "Similarly, a `garden::vegetables` module can be found at:" msgstr "" #: src/modules/filesystem.md:16 msgid "" "* `src/garden/vegetables.rs` (modern Rust 2018 style)\n" "* `src/garden/vegetables/mod.rs` (older Rust 2015 style)" msgstr "" #: src/modules/filesystem.md:19 msgid "The `crate` root is in:" msgstr "" #: src/modules/filesystem.md:21 msgid "" "* `src/lib.rs` (for a library crate)\n" "* `src/main.rs` (for a binary crate)" msgstr "" #: src/exercises/day-2/afternoon.md:1 msgid "# Day 2: Afternoon Exercises" msgstr "" #: src/exercises/day-2/afternoon.md:3 msgid "The exercises for this afternoon will focus on strings and iterators." msgstr "" #: src/exercises/day-2/luhn.md:1 msgid "# Luhn Algorithm" msgstr "" #: src/exercises/day-2/luhn.md:3 msgid "" "The [Luhn algorithm](https://en.wikipedia.org/wiki/Luhn_algorithm) is used " "to\n" "validate credit card numbers. The algorithm takes a string as input and does " "the\n" "following to validate the credit card number:" msgstr "" #: src/exercises/day-2/luhn.md:7 msgid "* Ignore all spaces. Reject number with less than two digits." msgstr "" #: src/exercises/day-2/luhn.md:9 msgid "" "* Moving from right to left, double every second digit: for the number " "`1234`,\n" " we double `3` and `1`." msgstr "" #: src/exercises/day-2/luhn.md:12 msgid "" "* After doubling a digit, sum the digits. So doubling `7` becomes `14` " "which\n" " becomes `5`." msgstr "" #: src/exercises/day-2/luhn.md:15 msgid "* Sum all the undoubled and doubled digits." msgstr "" #: src/exercises/day-2/luhn.md:17 msgid "* The credit card number is valid if the sum ends with `0`." msgstr "" #: src/exercises/day-2/luhn.md:19 msgid "" "Copy the following code to and implement the\n" "function:" msgstr "" #: src/exercises/day-2/luhn.md:27 msgid "" "pub fn luhn(cc_number: &str) -> bool {\n" " unimplemented!()\n" "}" msgstr "" #: src/exercises/day-2/luhn.md:31 msgid "" "#[test]\n" "fn test_non_digit_cc_number() {\n" " assert!(!luhn(\"foo\"));\n" "}" msgstr "" #: src/exercises/day-2/luhn.md:36 src/exercises/day-2/solutions-afternoon.md:64 msgid "" "#[test]\n" "fn test_empty_cc_number() {\n" " assert!(!luhn(\"\"));\n" " assert!(!luhn(\" \"));\n" " assert!(!luhn(\" \"));\n" " assert!(!luhn(\" \"));\n" "}" msgstr "" #: src/exercises/day-2/luhn.md:44 src/exercises/day-2/solutions-afternoon.md:72 msgid "" "#[test]\n" "fn test_single_digit_cc_number() {\n" " assert!(!luhn(\"0\"));\n" "}" msgstr "" #: src/exercises/day-2/luhn.md:49 src/exercises/day-2/solutions-afternoon.md:77 msgid "" "#[test]\n" "fn test_two_digit_cc_number() {\n" " assert!(luhn(\" 0 0 \"));\n" "}" msgstr "" #: src/exercises/day-2/luhn.md:54 src/exercises/day-2/solutions-afternoon.md:82 msgid "" "#[test]\n" "fn test_valid_cc_number() {\n" " assert!(luhn(\"4263 9826 4026 9299\"));\n" " assert!(luhn(\"4539 3195 0343 6467\"));\n" " assert!(luhn(\"7992 7398 713\"));\n" "}" msgstr "" #: src/exercises/day-2/luhn.md:61 msgid "" "#[test]\n" "fn test_invalid_cc_number() {\n" " assert!(!luhn(\"4223 9826 4026 9299\"));\n" " assert!(!luhn(\"4539 3195 0343 6476\"));\n" " assert!(!luhn(\"8273 1232 7352 0569\"));\n" "}" msgstr "" #: src/exercises/day-2/strings-iterators.md:1 msgid "# Strings and Iterators" msgstr "" #: src/exercises/day-2/strings-iterators.md:3 msgid "" "In this exercise, you are implementing a routing component of a web server. " "The\n" "server is configured with a number of _path prefixes_ which are matched " "against\n" "_request paths_. The path prefixes can contain a wildcard character which\n" "matches a full segment. See the unit tests below." msgstr "" #: src/exercises/day-2/strings-iterators.md:8 msgid "" "Copy the following code to and make the tests\n" "pass. Try avoiding allocating a `Vec` for your intermediate results:" msgstr "" #: src/exercises/day-2/strings-iterators.md:16 msgid "" "pub fn prefix_matches(prefix: &str, request_path: &str) -> bool {\n" " unimplemented!()\n" "}" msgstr "" #: src/exercises/day-2/strings-iterators.md:20 msgid "" "#[test]\n" "fn test_matches_without_wildcard() {\n" " assert!(prefix_matches(\"/v1/publishers\", \"/v1/publishers\"));\n" " assert!(prefix_matches(\"/v1/publishers\", \"/v1/publishers/" "abc-123\"));\n" " assert!(prefix_matches(\"/v1/publishers\", \"/v1/publishers/abc/" "books\"));" msgstr "" #: src/exercises/day-2/strings-iterators.md:26 #: src/exercises/day-2/solutions-afternoon.md:146 msgid "" " assert!(!prefix_matches(\"/v1/publishers\", \"/v1\"));\n" " assert!(!prefix_matches(\"/v1/publishers\", \"/v1/publishersBooks\"));\n" " assert!(!prefix_matches(\"/v1/publishers\", \"/v1/parent/" "publishers\"));\n" "}" msgstr "" #: src/exercises/day-2/strings-iterators.md:31 #: src/exercises/day-2/solutions-afternoon.md:151 msgid "" "#[test]\n" "fn test_matches_with_wildcard() {\n" " assert!(prefix_matches(\n" " \"/v1/publishers/*/books\",\n" " \"/v1/publishers/foo/books\"\n" " ));\n" " assert!(prefix_matches(\n" " \"/v1/publishers/*/books\",\n" " \"/v1/publishers/bar/books\"\n" " ));\n" " assert!(prefix_matches(\n" " \"/v1/publishers/*/books\",\n" " \"/v1/publishers/foo/books/book1\"\n" " ));" msgstr "" #: src/exercises/day-2/strings-iterators.md:46 msgid "" " assert!(!prefix_matches(\"/v1/publishers/*/books\", \"/v1/" "publishers\"));\n" " assert!(!prefix_matches(\n" " \"/v1/publishers/*/books\",\n" " \"/v1/publishers/foo/booksByAuthor\"\n" " ));\n" "}\n" "```" msgstr "" #: src/welcome-day-3.md:1 msgid "# Welcome to Day 3" msgstr "" #: src/welcome-day-3.md:3 msgid "Today, we will cover some more advanced topics of Rust:" msgstr "" #: src/welcome-day-3.md:5 msgid "" "* Traits: deriving traits, default methods, and important standard library\n" " traits." msgstr "" #: src/welcome-day-3.md:8 msgid "" "* Generics: generic data types, generic methods, monomorphization, and " "trait\n" " objects." msgstr "" #: src/welcome-day-3.md:11 msgid "* Error handling: panics, `Result`, and the try operator `?`." msgstr "" #: src/welcome-day-3.md:13 msgid "* Testing: unit tests, documentation tests, and integration tests." msgstr "" #: src/welcome-day-3.md:15 msgid "" "* Unsafe Rust: raw pointers, static variables, unsafe functions, and extern\n" " functions." msgstr "" #: src/traits.md:1 msgid "# Traits" msgstr "" #: src/traits.md:3 msgid "" "Rust lets you abstract over types with traits. They're similar to interfaces:" msgstr "" #: src/traits.md:5 msgid "" "```rust,editable\n" "trait Greet {\n" " fn say_hello(&self);\n" "}" msgstr "" #: src/traits.md:10 msgid "" "struct Dog {\n" " name: String,\n" "}" msgstr "" #: src/traits.md:14 msgid "struct Cat; // No name, cats won't respond to it anyway." msgstr "" #: src/traits.md:16 msgid "" "impl Greet for Dog {\n" " fn say_hello(&self) {\n" " println!(\"Wuf, my name is {}!\", self.name);\n" " }\n" "}" msgstr "" #: src/traits.md:22 msgid "" "impl Greet for Cat {\n" " fn say_hello(&self) {\n" " println!(\"Miau!\");\n" " }\n" "}" msgstr "" #: src/traits.md:28 msgid "" "fn main() {\n" " let pets: Vec> = vec![\n" " Box::new(Dog { name: String::from(\"Fido\") }),\n" " Box::new(Cat),\n" " ];\n" " for pet in pets {\n" " pet.say_hello();\n" " }\n" "}\n" "```" msgstr "" #: src/traits/deriving-traits.md:1 msgid "# Deriving Traits" msgstr "" #: src/traits/deriving-traits.md:3 msgid "You can let the compiler derive a number of traits:" msgstr "" #: src/traits/deriving-traits.md:5 msgid "" "```rust,editable\n" "#[derive(Debug, Clone, PartialEq, Eq, Default)]\n" "struct Player {\n" " name: String,\n" " strength: u8,\n" " hit_points: u8,\n" "}" msgstr "" #: src/traits/deriving-traits.md:13 msgid "" "fn main() {\n" " let p1 = Player::default();\n" " let p2 = p1.clone();\n" " println!(\"Is {:?}\\nequal to {:?}?\\nThe answer is {}!\", &p1, &p2,\n" " if p1 == p2 { \"yes\" } else { \"no\" });\n" "}\n" "```" msgstr "" #: src/traits/default-methods.md:1 msgid "# Default Methods" msgstr "" #: src/traits/default-methods.md:3 msgid "Traits can implement behavior in terms of other trait methods:" msgstr "" #: src/traits/default-methods.md:5 msgid "" "```rust,editable\n" "trait Equals {\n" " fn equal(&self, other: &Self) -> bool;\n" " fn not_equal(&self, other: &Self) -> bool {\n" " !self.equal(other)\n" " }\n" "}" msgstr "" #: src/traits/default-methods.md:13 msgid "" "#[derive(Debug)]\n" "struct Centimeter(i16);" msgstr "" #: src/traits/default-methods.md:16 msgid "" "impl Equals for Centimeter {\n" " fn equal(&self, other: &Centimeter) -> bool {\n" " self.0 == other.0\n" " }\n" "}" msgstr "" #: src/traits/default-methods.md:22 msgid "" "fn main() {\n" " let a = Centimeter(10);\n" " let b = Centimeter(20);\n" " println!(\"{a:?} equals {b:?}: {}\", a.equal(&b));\n" " println!(\"{a:?} not_equals {b:?}: {}\", a.not_equal(&b));\n" "}\n" "```" msgstr "" #: src/traits/important-traits.md:1 msgid "# Important Traits" msgstr "" #: src/traits/important-traits.md:3 msgid "" "We will now look at some of the most common traits of the Rust standard " "library:" msgstr "" #: src/traits/important-traits.md:5 msgid "" "* `Iterator` and `IntoIterator` used in `for` loops,\n" "* `From` and `Into` used to convert values,\n" "* `Read` and `Write` used for IO,\n" "* `Add`, `Mul`, ... used for operator overloading, and\n" "* `Drop` used for defining destructors." msgstr "" #: src/traits/iterator.md:1 msgid "# Iterators" msgstr "" #: src/traits/iterator.md:3 msgid "You can implement the `Iterator` trait on your own types:" msgstr "" #: src/traits/iterator.md:5 msgid "" "```rust,editable\n" "struct Fibonacci {\n" " curr: u32,\n" " next: u32,\n" "}" msgstr "" #: src/traits/iterator.md:11 msgid "" "impl Iterator for Fibonacci {\n" " type Item = u32;" msgstr "" #: src/traits/iterator.md:14 msgid "" " fn next(&mut self) -> Option {\n" " let new_next = self.curr + self.next;\n" " self.curr = self.next;\n" " self.next = new_next;\n" " Some(self.curr)\n" " }\n" "}" msgstr "" #: src/traits/iterator.md:22 msgid "" "fn main() {\n" " let fib = Fibonacci { curr: 0, next: 1 };\n" " for (i, n) in fib.enumerate().take(5) {\n" " println!(\"fib({i}): {n}\");\n" " }\n" "}\n" "```" msgstr "" #: src/traits/iterator.md:32 msgid "" "`IntoIterator` is the trait that makes for loops work. It is implemented by " "collection types such as\n" "`Vec` and references to them such as `&Vec` and `&[T]`. Ranges also " "implement it." msgstr "" #: src/traits/from-iterator.md:1 msgid "# FromIterator" msgstr "" #: src/traits/from-iterator.md:3 msgid "`FromIterator` lets you build a collection from an `Iterator`." msgstr "" #: src/traits/from-iterator.md:5 msgid "" "```rust,editable\n" "fn main() {\n" " let primes = vec![2, 3, 5, 7];\n" " let prime_squares = primes.into_iter().map(|prime| prime * prime)." "collect::>();\n" "}\n" "```" msgstr "" #: src/traits/from-iterator.md:14 msgid "" "`Iterator` implements\n" "`fn collect(self) -> B\n" "where\n" " B: FromIterator,\n" " Self: Sized`" msgstr "" #: src/traits/from-iterator.md:20 msgid "" "There are also implementations which let you do cool things like convert an\n" "`Iterator>` into a `Result, E>`." msgstr "" #: src/traits/read-write.md:1 msgid "# `Read` and `Write`" msgstr "" #: src/traits/read-write.md:3 msgid "Using `Read` and `BufRead`, you can abstract over `u8` sources:" msgstr "" #: src/traits/read-write.md:5 msgid "" "```rust,editable\n" "use std::io::{BufRead, BufReader, Read, Result};" msgstr "" #: src/traits/read-write.md:8 msgid "" "fn count_lines(reader: R) -> usize {\n" " let buf_reader = BufReader::new(reader);\n" " buf_reader.lines().count()\n" "}" msgstr "" #: src/traits/read-write.md:13 msgid "" "fn main() -> Result<()> {\n" " let slice: &[u8] = b\"foo\\nbar\\nbaz\\n\";\n" " println!(\"lines in slice: {}\", count_lines(slice));" msgstr "" #: src/traits/read-write.md:17 msgid "" " let file = std::fs::File::open(std::env::current_exe()?)?;\n" " println!(\"lines in file: {}\", count_lines(file));\n" " Ok(())\n" "}\n" "```" msgstr "" #: src/traits/read-write.md:23 msgid "Similarly, `Write` lets you abstract over `u8` sinks:" msgstr "" #: src/traits/read-write.md:25 msgid "" "```rust,editable\n" "use std::io::{Result, Write};" msgstr "" #: src/traits/read-write.md:28 msgid "" "fn log(writer: &mut W, msg: &str) -> Result<()> {\n" " writer.write_all(msg.as_bytes())?;\n" " writer.write_all(\"\\n\".as_bytes())\n" "}" msgstr "" #: src/traits/read-write.md:33 msgid "" "fn main() -> Result<()> {\n" " let mut buffer = Vec::new();\n" " log(&mut buffer, \"Hello\")?;\n" " log(&mut buffer, \"World\")?;\n" " println!(\"Logged: {:?}\", buffer);\n" " Ok(())\n" "}\n" "```" msgstr "" #: src/traits/operators.md:1 msgid "# `Add`, `Mul`, ..." msgstr "" #: src/traits/operators.md:3 msgid "Operator overloading is implemented via traits in `std::ops`:" msgstr "" #: src/traits/operators.md:5 msgid "" "```rust,editable\n" "#[derive(Debug, Copy, Clone)]\n" "struct Point { x: i32, y: i32 }" msgstr "" #: src/traits/operators.md:9 src/exercises/day-2/solutions-morning.md:46 msgid "" "impl std::ops::Add for Point {\n" " type Output = Self;" msgstr "" #: src/traits/operators.md:12 msgid "" " fn add(self, other: Self) -> Self {\n" " Self {x: self.x + other.x, y: self.y + other.y}\n" " }\n" "}" msgstr "" #: src/traits/operators.md:17 msgid "" "fn main() {\n" " let p1 = Point { x: 10, y: 20 };\n" " let p2 = Point { x: 100, y: 200 };\n" " println!(\"{:?} + {:?} = {:?}\", p1, p2, p1 + p2);\n" "}\n" "```" msgstr "" #: src/traits/drop.md:1 msgid "# The `Drop` Trait" msgstr "" #: src/traits/drop.md:3 msgid "" "Values which implement `Drop` can specify code to run when they go out of " "scope:" msgstr "" #: src/traits/drop.md:5 msgid "" "```rust,editable\n" "struct Droppable {\n" " name: &'static str,\n" "}" msgstr "" #: src/traits/drop.md:10 msgid "" "impl Drop for Droppable {\n" " fn drop(&mut self) {\n" " println!(\"Dropping {}\", self.name);\n" " }\n" "}" msgstr "" #: src/traits/drop.md:16 msgid "" "fn main() {\n" " let a = Droppable { name: \"a\" };\n" " {\n" " let b = Droppable { name: \"b\" };\n" " {\n" " let c = Droppable { name: \"c\" };\n" " let d = Droppable { name: \"d\" };\n" " println!(\"Exiting block B\");\n" " }\n" " println!(\"Exiting block A\");\n" " }\n" " drop(a);\n" " println!(\"Exiting main\");\n" "}\n" "```" msgstr "" #: src/generics.md:1 msgid "# Generics" msgstr "" #: src/generics.md:3 msgid "" "Rust support generics, which lets you abstract an algorithm (such as " "sorting)\n" "over the types used in the algorithm." msgstr "" #: src/generics/data-types.md:1 msgid "# Generic Data Types" msgstr "" #: src/generics/data-types.md:3 msgid "You can use generics to abstract over the concrete field type:" msgstr "" #: src/generics/data-types.md:5 msgid "" "```rust,editable\n" "#[derive(Debug)]\n" "struct Point {\n" " x: T,\n" " y: T,\n" "}" msgstr "" #: src/generics/data-types.md:12 msgid "" "fn main() {\n" " let integer = Point { x: 5, y: 10 };\n" " let float = Point { x: 1.0, y: 4.0 };\n" " println!(\"{integer:?} and {float:?}\");\n" "}\n" "```" msgstr "" #: src/generics/methods.md:1 msgid "# Generic Methods" msgstr "" #: src/generics/methods.md:3 msgid "You can declare a generic type on your `impl` block:" msgstr "" #: src/generics/methods.md:5 msgid "" "```rust,editable\n" "#[derive(Debug)]\n" "struct Point(T, T);" msgstr "" #: src/generics/methods.md:9 msgid "" "impl Point {\n" " fn x(&self) -> &T {\n" " &self.0 // + 10\n" " }" msgstr "" #: src/generics/methods.md:14 msgid "" " // fn set_x(&mut self, x: T)\n" "}" msgstr "" #: src/generics/methods.md:17 msgid "" "fn main() {\n" " let p = Point(5, 10);\n" " println!(\"p.x = {}\", p.x());\n" "}\n" "```" msgstr "" #: src/generics/trait-bounds.md:1 msgid "# Trait Bounds" msgstr "" #: src/generics/trait-bounds.md:3 msgid "" "When working with generics, you often want to limit the types. You can do " "this\n" "with `T: Trait` or `impl Trait`:" msgstr "" #: src/generics/trait-bounds.md:6 msgid "" "```rust,editable\n" "fn duplicate(a: T) -> (T, T) {\n" " (a.clone(), a.clone())\n" "}" msgstr "" #: src/generics/trait-bounds.md:11 msgid "// struct NotClonable;" msgstr "" #: src/generics/trait-bounds.md:13 msgid "" "fn main() {\n" " let foo = String::from(\"foo\");\n" " let pair = duplicate(foo);\n" "}\n" "```" msgstr "" #: src/generics/impl-trait.md:1 msgid "# `impl Trait`" msgstr "" #: src/generics/impl-trait.md:3 msgid "" "Similar to trait bounds, an `impl Trait` syntax can be used in function\n" "arguments and return values:" msgstr "" #: src/generics/impl-trait.md:6 src/generics/trait-objects.md:5 #: src/generics/trait-objects.md:28 msgid "" "```rust,editable\n" "use std::fmt::Display;" msgstr "" #: src/generics/impl-trait.md:9 msgid "" "fn get_x(name: impl Display) -> impl Display {\n" " format!(\"Hello {name}\")\n" "}" msgstr "" #: src/generics/impl-trait.md:13 msgid "" "fn main() {\n" " let x = get_x(\"foo\");\n" " println!(\"{x}\");\n" "}\n" "```" msgstr "" #: src/generics/impl-trait.md:19 msgid "" "* `impl Trait` cannot be used with the `::<>` turbo fish syntax.\n" "* `impl Trait` allows you to work with types which you cannot name." msgstr "" #: src/generics/impl-trait.md:24 msgid "" "The meaning of `impl Trait` is a bit different in the different positions." msgstr "" #: src/generics/impl-trait.md:26 msgid "" "* For a parameter, `impl Trait` is like an anonymous generic parameter with " "a trait bound.\n" "* For a return type, it means that the return type is some concrete type " "that implements the trait,\n" " without naming the type. This can be useful when you don't want to expose " "the concrete type in a\n" " public API." msgstr "" #: src/generics/closures.md:1 msgid "# Closures" msgstr "" #: src/generics/closures.md:3 msgid "" "Closures or lambda expressions have types which cannot be named. However, " "they\n" "implement special [`Fn`](https://doc.rust-lang.org/std/ops/trait.Fn.html),\n" "[`FnMut`](https://doc.rust-lang.org/std/ops/trait.FnMut.html), and\n" "[`FnOnce`](https://doc.rust-lang.org/std/ops/trait.FnOnce.html) traits:" msgstr "" #: src/generics/closures.md:8 msgid "" "```rust,editable\n" "fn apply_with_log(func: impl FnOnce(i32) -> i32, input: i32) -> i32 {\n" " println!(\"Calling function on {input}\");\n" " func(input)\n" "}" msgstr "" #: src/generics/closures.md:14 msgid "" "fn main() {\n" " let add_3 = |x| x + 3;\n" " let mul_5 = |x| x * 5;" msgstr "" #: src/generics/closures.md:18 msgid "" " println!(\"add_3: {}\", apply_with_log(add_3, 10));\n" " println!(\"mul_5: {}\", apply_with_log(mul_5, 20));\n" "}\n" "```" msgstr "" #: src/generics/closures.md:25 msgid "" "If you have an `FnOnce`, you may only call it once. It might consume " "captured values." msgstr "" #: src/generics/closures.md:27 msgid "" "An `FnMut` might mutate captured values, so you can call it multiple times " "but not concurrently." msgstr "" #: src/generics/closures.md:29 msgid "" "An `Fn` neither consumes nor mutates captured values, or perhaps captures " "nothing at all, so it can\n" "be called multiple times concurrently." msgstr "" #: src/generics/closures.md:32 msgid "" "`FnMut` is a subtype of `FnOnce`. `Fn` is a subtype of `FnMut` and `FnOnce`. " "I.e. you can use an\n" "`FnMut` wherever an `FnOnce` is called for, and you can use an `Fn` wherever " "an `FnMut` or `FnOnce`\n" "is called for." msgstr "" #: src/generics/closures.md:36 msgid "`move` closures only implement `FnOnce`." msgstr "" #: src/generics/monomorphization.md:1 msgid "# Monomorphization" msgstr "" #: src/generics/monomorphization.md:3 msgid "Generic code is turned into non-generic code based on the call sites:" msgstr "" #: src/generics/monomorphization.md:5 msgid "" "```rust,editable\n" "fn main() {\n" " let integer = Some(5);\n" " let float = Some(5.0);\n" "}\n" "```" msgstr "" #: src/generics/monomorphization.md:12 msgid "behaves as if you wrote" msgstr "" #: src/generics/monomorphization.md:14 msgid "" "```rust,editable\n" "enum Option_i32 {\n" " Some(i32),\n" " None,\n" "}" msgstr "" #: src/generics/monomorphization.md:20 msgid "" "enum Option_f64 {\n" " Some(f64),\n" " None,\n" "}" msgstr "" #: src/generics/monomorphization.md:25 msgid "" "fn main() {\n" " let integer = Option_i32::Some(5);\n" " let float = Option_f64::Some(5.0);\n" "}\n" "```" msgstr "" #: src/generics/monomorphization.md:31 msgid "" "This is a zero-cost abstraction: you get exactly the same result as if you " "had\n" "hand-coded the data structures without the abstraction." msgstr "" #: src/generics/trait-objects.md:1 msgid "# Trait Objects" msgstr "" #: src/generics/trait-objects.md:3 msgid "We've seen how a function can take arguments which implement a trait:" msgstr "" #: src/generics/trait-objects.md:8 msgid "" "fn print(x: T) {\n" " println!(\"Your value: {}\", x);\n" "}" msgstr "" #: src/generics/trait-objects.md:12 msgid "" "fn main() {\n" " print(123);\n" " print(\"Hello\");\n" "}\n" "```" msgstr "" #: src/generics/trait-objects.md:18 msgid "" "However, how can we store a collection of mixed types which implement " "`Display`?" msgstr "" #: src/generics/trait-objects.md:20 msgid "" "```rust,editable,compile_fail\n" "fn main() {\n" " let xs = vec![123, \"Hello\"];\n" "}\n" "```" msgstr "" #: src/generics/trait-objects.md:26 msgid "For this, we need _trait objects_:" msgstr "" #: src/generics/trait-objects.md:31 msgid "" "fn main() {\n" " let xs: Vec> = vec![Box::new(123), Box::" "new(\"Hello\")];\n" " for x in xs {\n" " println!(\"x: {x}\");\n" " }\n" "}\n" "```" msgstr "" #: src/generics/trait-objects.md:39 msgid "Memory layout after allocating `xs`:" msgstr "" #: src/generics/trait-objects.md:41 msgid "" "```bob\n" " Stack Heap\n" ".- - - - - - - - - - - - - -. .- - - - - - - - - - - - - - - - - - - - - " "- - -.\n" ": : : :\n" ": " "xs : : :\n" ": +-----------+-------+ : : +-----+-----" "+ :\n" ": | ptr | o---+---+-----+-->| o o | o o " "| :\n" ": | len | 2 | : : +-|-|-+-|-|-" "+ :\n" ": | capacity | 2 | : : | | | | +----+----+----+----+----" "+ :\n" ": +-----------+-------+ : : | | | '-->| H | e | l | l | o " "| :\n" ": : : | | | +----+----+----+----+----" "+ :\n" "`- - - - - - - - - - - - - -' : | | " "| :\n" " : | | | " "+-------------------------+ :\n" " : | | '---->| \"::" "fmt\" | :\n" " : | | " "+-------------------------+ :\n" " : | " "| :\n" " : | | +----+----+----+----" "+ :\n" " : | '-->| 7b | 00 | 00 | 00 " "| :\n" " : | +----+----+----+----" "+ :\n" " : " "| :\n" " : | +-------------------------" "+ :\n" " : '---->| \"::fmt\" " "| :\n" " : +-------------------------" "+ :\n" " : :\n" " : :\n" " '- - - - - - - - - - - - - - - - - - - - - " "- - -'\n" "```" msgstr "" #: src/generics/trait-objects.md:69 msgid "" "Similarly, you need a trait object if you want to return different values\n" "implementing a trait:" msgstr "" #: src/generics/trait-objects.md:72 msgid "" "```rust,editable\n" "fn numbers(n: i32) -> Box> {\n" " if n > 0 {\n" " Box::new(0..n)\n" " } else {\n" " Box::new((n..0).rev())\n" " }\n" "}" msgstr "" #: src/generics/trait-objects.md:81 msgid "" "fn main() {\n" " println!(\"{:?}\", numbers(-5).collect::>());\n" " println!(\"{:?}\", numbers(5).collect::>());\n" "}" msgstr "" #: src/exercises/day-3/morning.md:1 msgid "# Day 3: Morning Exercises" msgstr "" #: src/exercises/day-3/morning.md:3 msgid "We will design a classical GUI library traits and trait objects." msgstr "" #: src/exercises/day-3/simple-gui.md:1 msgid "# A Simple GUI Library" msgstr "" #: src/exercises/day-3/simple-gui.md:3 msgid "" "Let us design a classical GUI library using our new knowledge of traits and\n" "trait objects." msgstr "" #: src/exercises/day-3/simple-gui.md:6 msgid "We will have a number of widgets in our library:" msgstr "" #: src/exercises/day-3/simple-gui.md:8 msgid "" "* `Window`: has a `title` and contains other widgets.\n" "* `Button`: has a `label` and a callback function which is invoked when the\n" " button is pressed.\n" "* `Label`: has a `label`." msgstr "" #: src/exercises/day-3/simple-gui.md:13 msgid "The widgets will implement a `Widget` trait, see below." msgstr "" #: src/exercises/day-3/simple-gui.md:15 msgid "" "Copy the code below to , fill in the missing\n" "`draw_into` methods so that you implement the `Widget` trait:" msgstr "" #: src/exercises/day-3/simple-gui.md:18 #: src/exercises/day-3/safe-ffi-wrapper.md:25 msgid "" "```rust,should_panic\n" "// TODO: remove this when you're done with your implementation.\n" "#![allow(unused_imports, unused_variables, dead_code)]" msgstr "" #: src/exercises/day-3/simple-gui.md:22 msgid "" "pub trait Widget {\n" " /// Natural width of `self`.\n" " fn width(&self) -> usize;" msgstr "" #: src/exercises/day-3/simple-gui.md:26 #: src/exercises/day-3/solutions-morning.md:27 msgid "" " /// Draw the widget into a buffer.\n" " fn draw_into(&self, buffer: &mut dyn std::fmt::Write);" msgstr "" #: src/exercises/day-3/simple-gui.md:29 #: src/exercises/day-3/solutions-morning.md:30 msgid "" " /// Draw the widget on standard output.\n" " fn draw(&self) {\n" " let mut buffer = String::new();\n" " self.draw_into(&mut buffer);\n" " println!(\"{}\", &buffer);\n" " }\n" "}" msgstr "" #: src/exercises/day-3/simple-gui.md:37 #: src/exercises/day-3/solutions-morning.md:38 msgid "" "pub struct Label {\n" " label: String,\n" "}" msgstr "" #: src/exercises/day-3/simple-gui.md:41 #: src/exercises/day-3/solutions-morning.md:42 msgid "" "impl Label {\n" " fn new(label: &str) -> Label {\n" " Label {\n" " label: label.to_owned(),\n" " }\n" " }\n" "}" msgstr "" #: src/exercises/day-3/simple-gui.md:49 #: src/exercises/day-3/solutions-morning.md:50 msgid "" "pub struct Button {\n" " label: Label,\n" " callback: Box,\n" "}" msgstr "" #: src/exercises/day-3/simple-gui.md:54 #: src/exercises/day-3/solutions-morning.md:55 msgid "" "impl Button {\n" " fn new(label: &str, callback: Box) -> Button {\n" " Button {\n" " label: Label::new(label),\n" " callback,\n" " }\n" " }\n" "}" msgstr "" #: src/exercises/day-3/simple-gui.md:63 #: src/exercises/day-3/solutions-morning.md:64 msgid "" "pub struct Window {\n" " title: String,\n" " widgets: Vec>,\n" "}" msgstr "" #: src/exercises/day-3/simple-gui.md:68 #: src/exercises/day-3/solutions-morning.md:69 msgid "" "impl Window {\n" " fn new(title: &str) -> Window {\n" " Window {\n" " title: title.to_owned(),\n" " widgets: Vec::new(),\n" " }\n" " }" msgstr "" #: src/exercises/day-3/simple-gui.md:76 #: src/exercises/day-3/solutions-morning.md:77 msgid "" " fn add_widget(&mut self, widget: Box) {\n" " self.widgets.push(widget);\n" " }\n" "}" msgstr "" #: src/exercises/day-3/simple-gui.md:82 msgid "" "impl Widget for Label {\n" " fn width(&self) -> usize {\n" " unimplemented!()\n" " }" msgstr "" #: src/exercises/day-3/simple-gui.md:87 src/exercises/day-3/simple-gui.md:97 #: src/exercises/day-3/simple-gui.md:107 msgid "" " fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {\n" " unimplemented!()\n" " }\n" "}" msgstr "" #: src/exercises/day-3/simple-gui.md:92 msgid "" "impl Widget for Button {\n" " fn width(&self) -> usize {\n" " unimplemented!()\n" " }" msgstr "" #: src/exercises/day-3/simple-gui.md:102 msgid "" "impl Widget for Window {\n" " fn width(&self) -> usize {\n" " unimplemented!()\n" " }" msgstr "" #: src/exercises/day-3/simple-gui.md:112 msgid "" "fn main() {\n" " let mut window = Window::new(\"Rust GUI Demo 1.23\");\n" " window.add_widget(Box::new(Label::new(\"This is a small text GUI demo." "\")));\n" " window.add_widget(Box::new(Button::new(\n" " \"Click me!\",\n" " Box::new(|| println!(\"You clicked the button!\")),\n" " )));\n" " window.draw();\n" "}\n" "```" msgstr "" #: src/exercises/day-3/simple-gui.md:123 msgid "The output of the above program can be something simple like this:" msgstr "" #: src/exercises/day-3/simple-gui.md:125 msgid "" "```text\n" "========\n" "Rust GUI Demo 1.23\n" "========" msgstr "" #: src/exercises/day-3/simple-gui.md:130 msgid "This is a small text GUI demo." msgstr "" #: src/exercises/day-3/simple-gui.md:132 msgid "" "| Click me! |\n" "```" msgstr "" #: src/exercises/day-3/simple-gui.md:135 msgid "" "If you want to draw aligned text, you can use the\n" "[fill/alignment](https://doc.rust-lang.org/std/fmt/index." "html#fillalignment)\n" "formatting operators. In particular, notice how you can pad with different\n" "characters (here a `'/'`) and how you can control alignment:" msgstr "" #: src/exercises/day-3/simple-gui.md:140 msgid "" "```rust,editable\n" "fn main() {\n" " let width = 10;\n" " println!(\"left aligned: |{:/width$}|\", \"foo\");\n" "}\n" "```" msgstr "" #: src/exercises/day-3/simple-gui.md:149 msgid "" "Using such alignment tricks, you can for example produce output like this:" msgstr "" #: src/exercises/day-3/simple-gui.md:151 msgid "" "```text\n" "+--------------------------------+\n" "| Rust GUI Demo 1.23 |\n" "+================================+\n" "| This is a small text GUI demo. |\n" "| +-----------+ |\n" "| | Click me! | |\n" "| +-----------+ |\n" "+--------------------------------+\n" "```" msgstr "" #: src/error-handling.md:1 msgid "# Error Handling" msgstr "" #: src/error-handling.md:3 msgid "Error handling in Rust is done using explicit control flow:" msgstr "" #: src/error-handling.md:5 msgid "" "* Functions that can have errors list this in their return type,\n" "* There are no exceptions." msgstr "" #: src/error-handling/panics.md:1 msgid "# Panics" msgstr "" #: src/error-handling/panics.md:3 msgid "Rust will trigger a panic if a fatal error happens at runtime:" msgstr "" #: src/error-handling/panics.md:5 msgid "" "```rust,editable,should_panic\n" "fn main() {\n" " let v = vec![10, 20, 30];\n" " println!(\"v[100]: {}\", v[100]);\n" "}\n" "```" msgstr "" #: src/error-handling/panics.md:12 msgid "" "* Panics are for unrecoverable and unexpected errors.\n" " * Panics are symptoms of bugs in the program.\n" "* Use non-panicking APIs (such as `Vec::get`) if crashing is not acceptable." msgstr "" #: src/error-handling/panic-unwind.md:1 msgid "# Catching the Stack Unwinding" msgstr "" #: src/error-handling/panic-unwind.md:3 msgid "" "By default, a panic will cause the stack to unwind. The unwinding can be " "caught:" msgstr "" #: src/error-handling/panic-unwind.md:5 msgid "" "```rust\n" "use std::panic;" msgstr "" #: src/error-handling/panic-unwind.md:8 msgid "" "let result = panic::catch_unwind(|| {\n" " println!(\"hello!\");\n" "});\n" "assert!(result.is_ok());" msgstr "" #: src/error-handling/panic-unwind.md:13 msgid "" "let result = panic::catch_unwind(|| {\n" " panic!(\"oh no!\");\n" "});\n" "assert!(result.is_err());\n" "```" msgstr "" #: src/error-handling/panic-unwind.md:19 msgid "" "* This can be useful in servers which should keep running even if a single\n" " request crashes.\n" "* This does not work if `panic = abort` is set in your `Cargo.toml`." msgstr "" #: src/error-handling/result.md:1 msgid "# Structured Error Handling with `Result`" msgstr "" #: src/error-handling/result.md:3 msgid "" "We have already seen the `Result` enum. This is used pervasively when errors " "are\n" "expected as part of normal operation:" msgstr "" #: src/error-handling/result.md:6 msgid "" "```rust\n" "use std::fs::File;\n" "use std::io::Read;" msgstr "" #: src/error-handling/result.md:10 msgid "" "fn main() {\n" " let file = File::open(\"diary.txt\");\n" " match file {\n" " Ok(mut file) => {\n" " let mut contents = String::new();\n" " file.read_to_string(&mut contents);\n" " println!(\"Dear diary: {contents}\");\n" " },\n" " Err(err) => {\n" " println!(\"The diary could not be opened: {err}\");\n" " }\n" " }\n" "}\n" "```" msgstr "" #: src/error-handling/try-operator.md:1 msgid "# Propagating Errors with `?`" msgstr "" #: src/error-handling/try-operator.md:3 msgid "" "The try-operator `?` is used to return errors to the caller. It lets you " "turn\n" "the common" msgstr "" #: src/error-handling/try-operator.md:6 msgid "" "```rust,ignore\n" "match some_expression {\n" " Ok(value) => value,\n" " Err(err) => return Err(err),\n" "}\n" "```" msgstr "" #: src/error-handling/try-operator.md:13 msgid "into the much simpler" msgstr "" #: src/error-handling/try-operator.md:15 msgid "" "```rust,ignore\n" "some_expression?\n" "```" msgstr "" #: src/error-handling/try-operator.md:19 msgid "We can use this to simplify our error handing code:" msgstr "" #: src/error-handling/try-operator.md:21 msgid "" "```rust,editable\n" "use std::fs;\n" "use std::io::{self, Read};" msgstr "" #: src/error-handling/try-operator.md:25 msgid "" "fn read_username(path: &str) -> Result {\n" " let username_file_result = fs::File::open(path);" msgstr "" #: src/error-handling/try-operator.md:28 msgid "" " let mut username_file = match username_file_result {\n" " Ok(file) => file,\n" " Err(e) => return Err(e),\n" " };" msgstr "" #: src/error-handling/try-operator.md:33 msgid " let mut username = String::new();" msgstr "" #: src/error-handling/try-operator.md:35 msgid "" " match username_file.read_to_string(&mut username) {\n" " Ok(_) => Ok(username),\n" " Err(e) => Err(e),\n" " }\n" "}" msgstr "" #: src/error-handling/try-operator.md:41 msgid "" "fn main() {\n" " //fs::write(\"config.dat\", \"alice\").unwrap();\n" " let username = read_username(\"config.dat\");\n" " println!(\"username or error: {username:?}\");\n" "}\n" "```" msgstr "" #: src/error-handling/try-operator.md:52 #: src/error-handling/converting-error-types.md:57 msgid "" "* The `username` variable can be either `Ok(string)` or `Err(error)`.\n" "* Use the `fs::write` call to test out the different scenarios: no file, " "empty file, file with username." msgstr "" #: src/error-handling/converting-error-types.md:1 msgid "# Converting Error Types" msgstr "" #: src/error-handling/converting-error-types.md:3 msgid "" "The effective expansion of `?` is a little more complicated than previously " "indicated:" msgstr "" #: src/error-handling/converting-error-types.md:5 msgid "" "```rust,ignore\n" "expression?\n" "```" msgstr "" #: src/error-handling/converting-error-types.md:9 msgid "works the same as" msgstr "" #: src/error-handling/converting-error-types.md:11 msgid "" "```rust,ignore\n" "match expression {\n" " Ok(value) => value,\n" " Err(err) => return Err(From::from(err)),\n" "}\n" "```" msgstr "" #: src/error-handling/converting-error-types.md:18 msgid "" "The `From::from` call here means we attempt to convert the error type to " "the\n" "type returned by the function:" msgstr "" #: src/error-handling/converting-error-types.md:21 msgid "" "```rust,editable\n" "use std::{fs, io};\n" "use std::io::Read;" msgstr "" #: src/error-handling/converting-error-types.md:25 msgid "" "#[derive(Debug)]\n" "enum ReadUsernameError {\n" " IoError(io::Error),\n" " EmptyUsername(String),\n" "}" msgstr "" #: src/error-handling/converting-error-types.md:31 msgid "" "impl From for ReadUsernameError {\n" " fn from(err: io::Error) -> ReadUsernameError {\n" " ReadUsernameError::IoError(err)\n" " }\n" "}" msgstr "" #: src/error-handling/converting-error-types.md:37 #: src/error-handling/deriving-error-enums.md:19 msgid "" "fn read_username(path: &str) -> Result {\n" " let mut username = String::with_capacity(100);\n" " fs::File::open(path)?.read_to_string(&mut username)?;\n" " if username.is_empty() {\n" " return Err(ReadUsernameError::EmptyUsername(String::from(path)));\n" " }\n" " Ok(username)\n" "}" msgstr "" #: src/error-handling/converting-error-types.md:46 msgid "" "fn main() {\n" " //fs::write(\"config.dat\", \"\").unwrap();\n" " let username = read_username(\"config.dat\");\n" " println!(\"username or error: {username:?}\");\n" "}\n" "```" msgstr "" #: src/error-handling/deriving-error-enums.md:1 msgid "# Deriving Error Enums" msgstr "" #: src/error-handling/deriving-error-enums.md:3 msgid "" "The [thiserror](https://docs.rs/thiserror/) crate is a popular way to create " "an\n" "error enum like we did on the previous page:" msgstr "" #: src/error-handling/deriving-error-enums.md:6 msgid "" "```rust,editable,compile_fail\n" "use std::{fs, io};\n" "use std::io::Read;\n" "use thiserror::Error;" msgstr "" #: src/error-handling/deriving-error-enums.md:11 msgid "" "#[derive(Error, Debug)]\n" "enum ReadUsernameError {\n" " #[error(\"Could not read: {0}\")]\n" " IoError(#[from] io::Error),\n" " #[error(\"Found no username in {0}\")]\n" " EmptyUsername(String),\n" "}" msgstr "" #: src/error-handling/deriving-error-enums.md:28 msgid "" "fn main() {\n" " //fs::write(\"config.dat\", \"\").unwrap();\n" " match read_username(\"config.dat\") {\n" " Ok(username) => println!(\"Username: {username}\"),\n" " Err(err) => println!(\"Error: {err}\"),\n" " }\n" "}\n" "```" msgstr "" #: src/error-handling/error-contexts.md:1 msgid "# Adding Context to Errors" msgstr "" #: src/error-handling/error-contexts.md:3 msgid "" "The widely used [anyhow](https://docs.rs/anyhow/) crate can help you add\n" "contextual information to your errors and allows you to have fewer\n" "custom error types:" msgstr "" #: src/error-handling/error-contexts.md:7 msgid "" "```rust,editable,compile_fail\n" "use std::{fs, io};\n" "use std::io::Read;\n" "use thiserror::Error;\n" "use anyhow::{Context, Result};" msgstr "" #: src/error-handling/error-contexts.md:13 msgid "" "#[derive(Error, Debug)]\n" "enum ReadUsernameError {\n" " #[error(\"Found no username in {0}\")]\n" " EmptyUsername(String),\n" "}" msgstr "" #: src/error-handling/error-contexts.md:19 msgid "" "fn read_username(path: &str) -> Result {\n" " let mut username = String::with_capacity(100);\n" " fs::File::open(path)\n" " .context(format!(\"Failed to open {path}\"))?\n" " .read_to_string(&mut username)\n" " .context(\"Failed to read\")?;\n" " if username.is_empty() {\n" " return Err(ReadUsernameError::EmptyUsername(String::from(path)))?;\n" " }\n" " Ok(username)\n" "}" msgstr "" #: src/error-handling/error-contexts.md:31 msgid "" "fn main() {\n" " //fs::write(\"config.dat\", \"\").unwrap();\n" " match read_username(\"config.dat\") {\n" " Ok(username) => println!(\"Username: {username}\"),\n" " Err(err) => println!(\"Error: {err:?}\"),\n" " }\n" "}\n" "```" msgstr "" #: src/testing.md:1 msgid "# Testing" msgstr "" #: src/testing.md:3 msgid "Rust and Cargo come with a simple unit test framework:" msgstr "" #: src/testing.md:5 msgid "* Unit tests are supported throughout your code." msgstr "" #: src/testing.md:7 msgid "* Integration tests are supported via the `tests/` directory." msgstr "" #: src/testing/unit-tests.md:1 msgid "# Unit Tests" msgstr "" #: src/testing/unit-tests.md:3 msgid "Mark unit tests with `#[test]`:" msgstr "" #: src/testing/unit-tests.md:5 msgid "" "```rust,editable\n" "fn first_word(text: &str) -> &str {\n" " match text.find(' ') {\n" " Some(idx) => &text[..idx],\n" " None => &text,\n" " }\n" "}" msgstr "" #: src/testing/unit-tests.md:13 msgid "" "#[test]\n" "fn test_empty() {\n" " assert_eq!(first_word(\"\"), \"\");\n" "}" msgstr "" #: src/testing/unit-tests.md:18 msgid "" "#[test]\n" "fn test_single_word() {\n" " assert_eq!(first_word(\"Hello\"), \"Hello\");\n" "}" msgstr "" #: src/testing/unit-tests.md:23 msgid "" "#[test]\n" "fn test_multiple_words() {\n" " assert_eq!(first_word(\"Hello World\"), \"Hello\");\n" "}\n" "```" msgstr "" #: src/testing/unit-tests.md:29 msgid "Use `cargo test` to find and run the unit tests." msgstr "" #: src/testing/test-modules.md:1 msgid "# Test Modules" msgstr "" #: src/testing/test-modules.md:3 msgid "" "Unit tests are often put in a nested module (run tests on the\n" "[Playground](https://play.rust-lang.org/)):" msgstr "" #: src/testing/test-modules.md:6 msgid "" "```rust,editable\n" "fn helper(a: &str, b: &str) -> String {\n" " format!(\"{a} {b}\")\n" "}" msgstr "" #: src/testing/test-modules.md:11 msgid "" "pub fn main() {\n" " println!(\"{}\", helper(\"Hello\", \"World\"));\n" "}" msgstr "" #: src/testing/test-modules.md:19 msgid "" " #[test]\n" " fn test_helper() {\n" " assert_eq!(helper(\"foo\", \"bar\"), \"foo bar\");\n" " }\n" "}\n" "```" msgstr "" #: src/testing/test-modules.md:26 msgid "" "* This lets you unit test private helpers.\n" "* The `#[cfg(test)]` attribute is only active when you run `cargo test`." msgstr "" #: src/testing/doc-tests.md:1 msgid "# Documentation Tests" msgstr "" #: src/testing/doc-tests.md:3 msgid "Rust has built-in support for documentation tests:" msgstr "" #: src/testing/doc-tests.md:5 msgid "" "```rust\n" "/// Shortens a string to the given length.\n" "///\n" "/// ```\n" "/// use playground::shorten_string;\n" "/// assert_eq!(shorten_string(\"Hello World\", 5), \"Hello\");\n" "/// assert_eq!(shorten_string(\"Hello World\", 20), \"Hello World\");\n" "/// ```\n" "pub fn shorten_string(s: &str, length: usize) -> &str {\n" " &s[..std::cmp::min(length, s.len())]\n" "}\n" "```" msgstr "" #: src/testing/doc-tests.md:18 msgid "" "* Code blocks in `///` comments are automatically seen as Rust code.\n" "* The code will be compiled and executed as part of `cargo test`.\n" "* Test the above code on the [Rust Playground](https://play.rust-lang.org/?" "version=stable&mode=debug&edition=2021&gist=3ce2ad13ea1302f6572cb15cd96becf0)." msgstr "" #: src/testing/integration-tests.md:1 msgid "# Integration Tests" msgstr "" #: src/testing/integration-tests.md:3 msgid "If you want to test your library as a client, use an integration test." msgstr "" #: src/testing/integration-tests.md:5 msgid "Create a `.rs` file under `tests/`:" msgstr "" #: src/testing/integration-tests.md:7 msgid "" "```rust,ignore\n" "use my_library::init;" msgstr "" #: src/testing/integration-tests.md:10 msgid "" "#[test]\n" "fn test_init() {\n" " assert!(init().is_ok());\n" "}\n" "```" msgstr "" #: src/testing/integration-tests.md:16 msgid "These tests only have access to the public API of your crate." msgstr "" #: src/unsafe.md:1 msgid "# Unsafe Rust" msgstr "" #: src/unsafe.md:3 msgid "The Rust language has two parts:" msgstr "" #: src/unsafe.md:5 msgid "" "* **Safe Rust:** memory safe, no undefined behavior possible.\n" "* **Unsafe Rust:** can trigger undefined behavior if preconditions are " "violated." msgstr "" #: src/unsafe.md:8 msgid "" "We will be seeing mostly safe Rust in this course, but it's important to " "know\n" "what Unsafe Rust is." msgstr "" #: src/unsafe.md:11 msgid "Unsafe Rust gives you access to five new capabilities:" msgstr "" #: src/unsafe.md:13 msgid "" "* Dereference raw pointers.\n" "* Access or modify mutable static variables.\n" "* Access `union` fields.\n" "* Call `unsafe` functions, including `extern` functions.\n" "* Implement `unsafe` traits." msgstr "" #: src/unsafe.md:19 msgid "" "We will briefly cover these capabilities next. For full details, please see\n" "[Chapter 19.1 in the Rust Book](https://doc.rust-lang.org/book/ch19-01-" "unsafe-rust.html)\n" "and the [Rustonomicon](https://doc.rust-lang.org/nomicon/)." msgstr "" #: src/unsafe/raw-pointers.md:1 msgid "# Dereferencing Raw Pointers" msgstr "" #: src/unsafe/raw-pointers.md:3 msgid "Creating pointers is safe, but dereferencing them requires `unsafe`:" msgstr "" #: src/unsafe/raw-pointers.md:5 msgid "" "```rust,editable\n" "fn main() {\n" " let mut num = 5;" msgstr "" #: src/unsafe/raw-pointers.md:9 msgid "" " let r1 = &mut num as *mut i32;\n" " let r2 = &num as *const i32;" msgstr "" #: src/unsafe/raw-pointers.md:12 msgid "" " unsafe {\n" " println!(\"r1 is: {}\", *r1);\n" " *r1 = 10; // Data race if r1 is being written concurrently!\n" " println!(\"r2 is: {}\", *r2);\n" " }\n" "}\n" "```" msgstr "" #: src/unsafe/mutable-static-variables.md:1 msgid "# Mutable Static Variables" msgstr "" #: src/unsafe/mutable-static-variables.md:3 msgid "It is safe to read an immutable static variable:" msgstr "" #: src/unsafe/mutable-static-variables.md:5 msgid "" "```rust,editable\n" "static HELLO_WORLD: &str = \"Hello, world!\";" msgstr "" #: src/unsafe/mutable-static-variables.md:8 msgid "" "fn main() {\n" " println!(\"name is: {}\", HELLO_WORLD);\n" "}\n" "```" msgstr "" #: src/unsafe/mutable-static-variables.md:13 msgid "" "However, since data races can occur, it is unsafe to read and write mutable\n" "static variables:" msgstr "" #: src/unsafe/mutable-static-variables.md:16 msgid "" "```rust,editable\n" "static mut COUNTER: u32 = 0;" msgstr "" #: src/unsafe/mutable-static-variables.md:19 msgid "" "fn add_to_counter(inc: u32) {\n" " unsafe { COUNTER += inc; } // Potential data race!\n" "}" msgstr "" #: src/unsafe/mutable-static-variables.md:23 msgid "" "fn main() {\n" " add_to_counter(42);" msgstr "" #: src/unsafe/mutable-static-variables.md:26 msgid "" " unsafe { println!(\"COUNTER: {}\", COUNTER); } // Potential data race!\n" "}\n" "```" msgstr "" #: src/unsafe/unsafe-functions.md:1 msgid "# Calling Unsafe Functions" msgstr "" #: src/unsafe/unsafe-functions.md:3 msgid "" "A function or method can be marked `unsafe` if it has extra preconditions " "you\n" "must uphold:" msgstr "" #: src/unsafe/unsafe-functions.md:6 msgid "" "```rust,editable\n" "fn main() {\n" " let emojis = \"🗻∈🌏\";\n" " unsafe {\n" " // Undefined behavior if indices do not lie on UTF-8 sequence " "boundaries.\n" " println!(\"{}\", emojis.get_unchecked(0..4));\n" " println!(\"{}\", emojis.get_unchecked(4..7));\n" " println!(\"{}\", emojis.get_unchecked(7..11));\n" " }\n" "}\n" "```" msgstr "" #: src/unsafe/extern-functions.md:1 msgid "# Calling External Code" msgstr "" #: src/unsafe/extern-functions.md:3 msgid "" "Functions from other languages might violate the guarantees of Rust. " "Calling\n" "them is thus unsafe:" msgstr "" #: src/unsafe/extern-functions.md:6 msgid "" "```rust,editable\n" "extern \"C\" {\n" " fn abs(input: i32) -> i32;\n" "}" msgstr "" #: src/unsafe/extern-functions.md:11 msgid "" "fn main() {\n" " unsafe {\n" " // Undefined behavior if abs misbehaves.\n" " println!(\"Absolute value of -3 according to C: {}\", abs(-3));\n" " }\n" "}\n" "```" msgstr "" #: src/unsafe/unions.md:1 msgid "# Unions" msgstr "" #: src/unsafe/unions.md:3 msgid "Unions are like enums, but you need to track the active field yourself:" msgstr "" #: src/unsafe/unions.md:5 msgid "" "```rust,editable\n" "#[repr(C)]\n" "union MyUnion {\n" " i: u8,\n" " b: bool,\n" "}" msgstr "" #: src/unsafe/unions.md:12 msgid "" "fn main() {\n" " let u = MyUnion { i: 42 };\n" " println!(\"int: {}\", unsafe { u.i });\n" " println!(\"bool: {}\", unsafe { u.b }); // Undefined behavior!\n" "}\n" "```" msgstr "" #: src/exercises/day-3/afternoon.md:1 msgid "# Day 3: Afternoon Exercises" msgstr "" #: src/exercises/day-3/afternoon.md:3 msgid "Let us build a safe wrapper for reading directory content!" msgstr "" #: src/exercises/day-3/afternoon.md:7 msgid "After looking at the exercise, you can look at the [solution] provided." msgstr "" #: src/exercises/day-3/safe-ffi-wrapper.md:1 msgid "# Safe FFI Wrapper" msgstr "" #: src/exercises/day-3/safe-ffi-wrapper.md:3 msgid "" "Rust has great support for calling functions through a _foreign function\n" "interface_ (FFI). We will use this to build a safe wrapper the `glibc` " "functions\n" "you would use from C to read the filenames of a directory." msgstr "" #: src/exercises/day-3/safe-ffi-wrapper.md:7 msgid "You will want to consult the manual pages:" msgstr "" #: src/exercises/day-3/safe-ffi-wrapper.md:9 msgid "" "* [`opendir(3)`](https://man7.org/linux/man-pages/man3/opendir.3.html)\n" "* [`readdir(3)`](https://man7.org/linux/man-pages/man3/readdir.3.html)\n" "* [`closedir(3)`](https://man7.org/linux/man-pages/man3/closedir.3.html)" msgstr "" #: src/exercises/day-3/safe-ffi-wrapper.md:13 msgid "" "You will also want to browse the [`std::ffi`] module, particular for " "[`CStr`]\n" "and [`CString`] types which are used to hold NUL-terminated strings coming " "from\n" "C. The [Nomicon] also has a very useful chapter about FFI." msgstr "" #: src/exercises/day-3/safe-ffi-wrapper.md:17 msgid "" "[`std::ffi`]: https://doc.rust-lang.org/std/ffi/\n" "[`CStr`]: https://doc.rust-lang.org/std/ffi/struct.CStr.html\n" "[`CString`]: https://doc.rust-lang.org/std/ffi/struct.CString.html\n" "[Nomicon]: https://doc.rust-lang.org/nomicon/ffi.html" msgstr "" #: src/exercises/day-3/safe-ffi-wrapper.md:22 msgid "" "Copy the code below to and fill in the " "missing\n" "functions and methods:" msgstr "" #: src/exercises/day-3/safe-ffi-wrapper.md:29 msgid "" "mod ffi {\n" " use std::os::raw::{c_char, c_int, c_long, c_ulong, c_ushort};" msgstr "" #: src/exercises/day-3/safe-ffi-wrapper.md:32 #: src/exercises/day-3/solutions-afternoon.md:26 msgid "" " // Opaque type. See https://doc.rust-lang.org/nomicon/ffi.html.\n" " #[repr(C)]\n" " pub struct DIR {\n" " _data: [u8; 0],\n" " _marker: core::marker::PhantomData<(*mut u8, core::marker::" "PhantomPinned)>,\n" " }" msgstr "" #: src/exercises/day-3/safe-ffi-wrapper.md:39 #: src/exercises/day-3/solutions-afternoon.md:33 msgid "" " // Layout as per readdir(3) and definitions in /usr/include/x86_64-linux-" "gnu.\n" " #[repr(C)]\n" " pub struct dirent {\n" " pub d_ino: c_long,\n" " pub d_off: c_ulong,\n" " pub d_reclen: c_ushort,\n" " pub d_type: c_char,\n" " pub d_name: [c_char; 256],\n" " }" msgstr "" #: src/exercises/day-3/safe-ffi-wrapper.md:49 #: src/exercises/day-3/solutions-afternoon.md:43 msgid "" " extern \"C\" {\n" " pub fn opendir(s: *const c_char) -> *mut DIR;\n" " pub fn readdir(s: *mut DIR) -> *const dirent;\n" " pub fn closedir(s: *mut DIR) -> c_int;\n" " }\n" "}" msgstr "" #: src/exercises/day-3/safe-ffi-wrapper.md:56 #: src/exercises/day-3/solutions-afternoon.md:50 msgid "" "use std::ffi::{CStr, CString, OsStr, OsString};\n" "use std::os::unix::ffi::OsStrExt;" msgstr "" #: src/exercises/day-3/safe-ffi-wrapper.md:59 msgid "" "#[derive(Debug)]\n" "struct DirectoryIterator {\n" " path: CString,\n" " dir: *mut ffi::DIR,\n" "}" msgstr "" #: src/exercises/day-3/safe-ffi-wrapper.md:65 msgid "" "impl DirectoryIterator {\n" " fn new(path: &str) -> Result {\n" " // Call opendir and return a Ok value if that worked,\n" " // otherwise return Err with a message.\n" " unimplemented!()\n" " }\n" "}" msgstr "" #: src/exercises/day-3/safe-ffi-wrapper.md:73 msgid "" "impl Iterator for DirectoryIterator {\n" " type Item = OsString;\n" " fn next(&mut self) -> Option {\n" " // Keep calling readdir until we get a NULL pointer back.\n" " unimplemented!()\n" " }\n" "}" msgstr "" #: src/exercises/day-3/safe-ffi-wrapper.md:81 msgid "" "impl Drop for DirectoryIterator {\n" " fn drop(&mut self) {\n" " // Call closedir as needed.\n" " unimplemented!()\n" " }\n" "}" msgstr "" #: src/exercises/day-3/safe-ffi-wrapper.md:88 msgid "" "fn main() -> Result<(), String> {\n" " let iter = DirectoryIterator::new(\".\")?;\n" " println!(\"files: {:#?}\", iter.collect::>());\n" " Ok(())\n" "}\n" "```" msgstr "" #: src/welcome-day-4.md:1 msgid "# Welcome to Day 4" msgstr "" #: src/welcome-day-4.md:3 msgid "Today we will look at two main topics:" msgstr "" #: src/welcome-day-4.md:5 msgid "* Concurrency: threads, channels, shared state, `Send` and `Sync`." msgstr "" #: src/welcome-day-4.md:7 msgid "" "* Android: building binaries and libraries, using AIDL, logging, and\n" " interoperability with C, C++, and Java." msgstr "" #: src/welcome-day-4.md:10 msgid "" "> We will attempt to call Rust from one of your own projects today. So try " "to\n" "> find a little corner of your code base where we can move some lines of " "code to\n" "> Rust. The fewer dependencies and \"exotic\" types the better. Something " "that\n" "> parses some raw bytes would be ideal." msgstr "" #: src/concurrency.md:1 msgid "# Fearless Concurrency" msgstr "" #: src/concurrency.md:3 msgid "" "Rust has full support for concurrency using OS threads with mutexes and\n" "channels." msgstr "" #: src/concurrency.md:6 msgid "" "The Rust type system plays an important role in making many concurrency " "bugs\n" "compile time bugs. This is often referred to as _fearless concurrency_ since " "you\n" "can rely on the compiler to ensure correctness at runtime." msgstr "" #: src/concurrency/threads.md:1 msgid "# Threads" msgstr "" #: src/concurrency/threads.md:3 msgid "Rust threads work similarly to threads in other languages:" msgstr "" #: src/concurrency/threads.md:5 msgid "" "```rust,editable\n" "use std::thread;\n" "use std::time::Duration;" msgstr "" #: src/concurrency/threads.md:9 msgid "" "fn main() {\n" " thread::spawn(|| {\n" " for i in 1..10 {\n" " println!(\"Count in thread: {i}!\");\n" " thread::sleep(Duration::from_millis(5));\n" " }\n" " });" msgstr "" #: src/concurrency/threads.md:17 msgid "" " for i in 1..5 {\n" " println!(\"Main thread: {i}\");\n" " thread::sleep(Duration::from_millis(5));\n" " }\n" "}\n" "```" msgstr "" #: src/concurrency/threads.md:24 msgid "" "* Threads are all daemon threads, the main thread does not wait for them.\n" "* Thread panics are independent of each other.\n" " * Panics can carry a payload, which can be unpacked with `downcast_ref`." msgstr "" #: src/concurrency/threads.md:32 msgid "" "* Notice that the thread is stopped before it reaches 10 — the main thread " "is\n" " not waiting." msgstr "" #: src/concurrency/threads.md:35 msgid "" "* Use `let handle = thread::spawn(...)` and later `handle.join()` to wait " "for\n" " the thread to finish." msgstr "" #: src/concurrency/threads.md:38 msgid "* Trigger a panic in the thread, notice how this doesn't affect `main`." msgstr "" #: src/concurrency/threads.md:40 msgid "" "* Use the `Result` return value from `handle.join()` to get access to the " "panic\n" " payload. This is a good time to talk about [`Any`]." msgstr "" #: src/concurrency/threads.md:43 msgid "[`Any`]: https://doc.rust-lang.org/std/any/index.html" msgstr "" #: src/concurrency/scoped-threads.md:1 msgid "# Scoped Threads" msgstr "" #: src/concurrency/scoped-threads.md:3 msgid "Normal threads cannot borrow from their environment:" msgstr "" #: src/concurrency/scoped-threads.md:5 msgid "" "```rust,editable,compile_fail\n" "use std::thread;" msgstr "" #: src/concurrency/scoped-threads.md:8 src/concurrency/scoped-threads.md:22 msgid "" "fn main() {\n" " let s = String::from(\"Hello\");" msgstr "" #: src/concurrency/scoped-threads.md:11 msgid "" " thread::spawn(|| {\n" " println!(\"Length: {}\", s.len());\n" " });\n" "}\n" "```" msgstr "" #: src/concurrency/scoped-threads.md:17 msgid "However, you can use a [scoped thread][1] for this:" msgstr "" #: src/concurrency/scoped-threads.md:19 msgid "" "```rust,editable\n" "use std::thread;" msgstr "" #: src/concurrency/scoped-threads.md:25 msgid "" " thread::scope(|scope| {\n" " scope.spawn(|| {\n" " println!(\"Length: {}\", s.len());\n" " });\n" " });\n" "}\n" "```" msgstr "" #: src/concurrency/scoped-threads.md:33 msgid "[1]: https://doc.rust-lang.org/std/thread/fn.scope.html" msgstr "" #: src/concurrency/channels.md:1 msgid "# Channels" msgstr "" #: src/concurrency/channels.md:3 msgid "" "Rust channels have two parts: a `Sender` and a `Receiver`. The two " "parts\n" "are connected via the channel, but you only see the end-points." msgstr "" #: src/concurrency/channels.md:6 msgid "" "```rust,editable\n" "use std::sync::mpsc;\n" "use std::thread;" msgstr "" #: src/concurrency/channels.md:10 src/concurrency/channels/unbounded.md:10 msgid "" "fn main() {\n" " let (tx, rx) = mpsc::channel();" msgstr "" #: src/concurrency/channels.md:13 msgid "" " tx.send(10).unwrap();\n" " tx.send(20).unwrap();" msgstr "" #: src/concurrency/channels.md:16 msgid "" " println!(\"Received: {:?}\", rx.recv());\n" " println!(\"Received: {:?}\", rx.recv());" msgstr "" #: src/concurrency/channels.md:19 msgid "" " let tx2 = tx.clone();\n" " tx2.send(30).unwrap();\n" " println!(\"Received: {:?}\", rx.recv());\n" "}\n" "```" msgstr "" #: src/concurrency/channels/unbounded.md:1 msgid "# Unbounded Channels" msgstr "" #: src/concurrency/channels/unbounded.md:3 msgid "You get an unbounded and asynchronous channel with `mpsc::channel()`:" msgstr "" #: src/concurrency/channels/unbounded.md:5 #: src/concurrency/channels/bounded.md:5 msgid "" "```rust,editable\n" "use std::sync::mpsc;\n" "use std::thread;\n" "use std::time::Duration;" msgstr "" #: src/concurrency/channels/unbounded.md:13 #: src/concurrency/channels/bounded.md:13 msgid "" " thread::spawn(move || {\n" " let thread_id = thread::current().id();\n" " for i in 1..10 {\n" " tx.send(format!(\"Message {i}\")).unwrap();\n" " println!(\"{thread_id:?}: sent Message {i}\");\n" " }\n" " println!(\"{thread_id:?}: done\");\n" " });\n" " thread::sleep(Duration::from_millis(100));" msgstr "" #: src/concurrency/channels/unbounded.md:23 #: src/concurrency/channels/bounded.md:23 msgid "" " for msg in rx.iter() {\n" " println!(\"Main: got {}\", msg);\n" " }\n" "}\n" "```" msgstr "" #: src/concurrency/channels/bounded.md:1 msgid "# Bounded Channels" msgstr "" #: src/concurrency/channels/bounded.md:3 msgid "Bounded and synchronous channels make `send` block the current thread:" msgstr "" #: src/concurrency/channels/bounded.md:10 msgid "" "fn main() {\n" " let (tx, rx) = mpsc::sync_channel(3);" msgstr "" #: src/concurrency/shared_state.md:1 msgid "# Shared State" msgstr "" #: src/concurrency/shared_state.md:3 msgid "" "Rust uses the type system to enforce synchronization of shared data. This " "is\n" "primarily done via two types:" msgstr "" #: src/concurrency/shared_state.md:6 msgid "" "* [`Arc`][1], atomic reference counted `T`: handled sharing between " "threads and\n" " takes care to deallocate `T` when the last thread exits,\n" "* [`Mutex`][2]: ensures mutual exclusion access to the `T` value." msgstr "" #: src/concurrency/shared_state.md:10 msgid "" "[1]: https://doc.rust-lang.org/std/sync/struct.Arc.html\n" "[2]: https://doc.rust-lang.org/std/sync/struct.Mutex.html" msgstr "" #: src/concurrency/shared_state/arc.md:1 msgid "# `Arc`" msgstr "" #: src/concurrency/shared_state/arc.md:3 msgid "[`Arc`][1] allows shared read-only access via its `clone` method:" msgstr "" #: src/concurrency/shared_state/arc.md:5 msgid "" "```rust,editable\n" "use std::thread;\n" "use std::sync::Arc;" msgstr "" #: src/concurrency/shared_state/arc.md:9 msgid "" "fn main() {\n" " let v = Arc::new(vec![10, 20, 30]);\n" " let mut handles = Vec::new();\n" " for _ in 1..5 {\n" " let v = v.clone();\n" " handles.push(thread::spawn(move || {\n" " let thread_id = thread::current().id();\n" " println!(\"{thread_id:?}: {v:?}\");\n" " }));\n" " }" msgstr "" #: src/concurrency/shared_state/arc.md:20 msgid "" " handles.into_iter().for_each(|h| h.join().unwrap());\n" " println!(\"v: {v:?}\");\n" "}\n" "```" msgstr "" #: src/concurrency/shared_state/arc.md:25 msgid "[1]: https://doc.rust-lang.org/std/sync/struct.Arc.html" msgstr "" #: src/concurrency/shared_state/mutex.md:1 msgid "# `Mutex`" msgstr "" #: src/concurrency/shared_state/mutex.md:3 msgid "" "[`Mutex`][1] ensures mutual exclusion _and_ allows mutable access to `T`\n" "behind a read-only interface:" msgstr "" #: src/concurrency/shared_state/mutex.md:6 msgid "" "```rust,editable\n" "use std::sync::Mutex;" msgstr "" #: src/concurrency/shared_state/mutex.md:9 msgid "" "fn main() {\n" " let v: Mutex> = Mutex::new(vec![10, 20, 30]);\n" " println!(\"v: {:?}\", v.lock().unwrap());" msgstr "" #: src/concurrency/shared_state/mutex.md:13 msgid "" " {\n" " let v: &Mutex> = &v;\n" " let mut guard = v.lock().unwrap();\n" " guard.push(40);\n" " }" msgstr "" #: src/concurrency/shared_state/mutex.md:19 msgid "" " println!(\"v: {:?}\", v.lock().unwrap());\n" "}\n" "```" msgstr "" #: src/concurrency/shared_state/mutex.md:23 msgid "" "Notice how we have a [`impl Sync for Mutex`][2] blanket\n" "implementation." msgstr "" #: src/concurrency/shared_state/mutex.md:26 msgid "" "[1]: https://doc.rust-lang.org/std/sync/struct.Mutex.html\n" "[2]: https://doc.rust-lang.org/std/sync/struct.Mutex.html#impl-Sync-for-" "Mutex%3CT%3E\n" "[3]: https://doc.rust-lang.org/std/sync/struct.Arc.html" msgstr "" #: src/concurrency/shared_state/example.md:3 msgid "Let us see `Arc` and `Mutex` in action:" msgstr "" #: src/concurrency/shared_state/example.md:5 msgid "" "```rust,editable,compile_fail\n" "use std::thread;\n" "// use std::sync::{Arc, Mutex};" msgstr "" #: src/concurrency/shared_state/example.md:9 msgid "" "fn main() {\n" " let mut v = vec![10, 20, 30];\n" " let handle = thread::spawn(|| {\n" " v.push(10);\n" " });\n" " v.push(1000);" msgstr "" #: src/concurrency/shared_state/example.md:16 msgid "" " handle.join().unwrap();\n" " println!(\"v: {v:?}\");\n" "}\n" "```" msgstr "" #: src/concurrency/send-sync.md:1 msgid "# `Send` and `Sync`" msgstr "" #: src/concurrency/send-sync.md:3 msgid "" "How does Rust know to forbid shared access across thread? The answer is in " "two traits:" msgstr "" #: src/concurrency/send-sync.md:5 msgid "" "* [`Send`][1]: a type `T` is `Send` if it is safe to move a `T` across a " "thread\n" " boundary.\n" "* [`Sync`][2]: a type `T` is `Sync` if it is safe to move a `&T` across a " "thread\n" " boundary." msgstr "" #: src/concurrency/send-sync.md:10 msgid "" "[1]: https://doc.rust-lang.org/std/marker/trait.Send.html\n" "[2]: https://doc.rust-lang.org/std/marker/trait.Sync.html" msgstr "" #: src/concurrency/send-sync/send.md:1 msgid "# `Send`" msgstr "" #: src/concurrency/send-sync/send.md:3 msgid "" "> A type `T` is [`Send`][1] if it is safe to move a `T` value to another " "thread." msgstr "" #: src/concurrency/send-sync/send.md:5 msgid "" "The effect of moving ownership to another thread is that _destructors_ will " "run\n" "in that thread. So the question is when you can allocate a value in one " "thread\n" "and deallocate it in another." msgstr "" #: src/concurrency/send-sync/send.md:9 msgid "[1]: https://doc.rust-lang.org/std/marker/trait.Send.html" msgstr "" #: src/concurrency/send-sync/sync.md:1 msgid "# `Sync`" msgstr "" #: src/concurrency/send-sync/sync.md:3 msgid "" "> A type `T` is [`Sync`][1] if it is safe to access a `T` value from " "multiple\n" "> threads at the same time." msgstr "" #: src/concurrency/send-sync/sync.md:6 msgid "More precisely, the definition is:" msgstr "" #: src/concurrency/send-sync/sync.md:8 msgid "> `T` is `Sync` if and only if `&T` is `Send`" msgstr "" #: src/concurrency/send-sync/sync.md:10 msgid "[1]: https://doc.rust-lang.org/std/marker/trait.Sync.html" msgstr "" #: src/concurrency/send-sync/examples.md:1 msgid "# Examples" msgstr "" #: src/concurrency/send-sync/examples.md:3 msgid "## `Send + Sync`" msgstr "" #: src/concurrency/send-sync/examples.md:5 msgid "Most types you come across are `Send + Sync`:" msgstr "" #: src/concurrency/send-sync/examples.md:7 msgid "" "* `i8`, `f32`, `bool`, `char`, `&str`, ...\n" "* `(T1, T2)`, `[T; N]`, `&[T]`, `struct { x: T }`, ...\n" "* `String`, `Option`, `Vec`, `Box`, ...\n" "* `Arc`: Explicitly thread-safe via atomic reference count.\n" "* `Mutex`: Explicitly thread-safe via internal locking.\n" "* `AtomicBool`, `AtomicU8`, ...: Uses special atomic instructions." msgstr "" #: src/concurrency/send-sync/examples.md:14 msgid "" "The generic types are typically `Send + Sync` when the type parameters are\n" "`Send + Sync`." msgstr "" #: src/concurrency/send-sync/examples.md:17 msgid "## `Send + !Sync`" msgstr "" #: src/concurrency/send-sync/examples.md:19 msgid "" "These types can be moved to other threads, but they're not thread-safe.\n" "Typically because of interior mutability:" msgstr "" #: src/concurrency/send-sync/examples.md:22 msgid "" "* `mpsc::Sender`\n" "* `mpsc::Receiver`\n" "* `Cell`\n" "* `RefCell`" msgstr "" #: src/concurrency/send-sync/examples.md:27 msgid "## `!Send + Sync`" msgstr "" #: src/concurrency/send-sync/examples.md:29 msgid "" "These types are thread-safe, but they cannot be moved to another thread:" msgstr "" #: src/concurrency/send-sync/examples.md:31 msgid "" "* `MutexGuard`: Uses OS level primitives which must be deallocated on " "the\n" " thread which created them." msgstr "" #: src/concurrency/send-sync/examples.md:34 msgid "## `!Send + !Sync`" msgstr "" #: src/concurrency/send-sync/examples.md:36 msgid "These types are not thread-safe and cannot be moved to other threads:" msgstr "" #: src/concurrency/send-sync/examples.md:38 msgid "" "* `Rc`: each `Rc` has a reference to an `RcBox`, which contains a\n" " non-atomic reference count.\n" "* `*const T`, `*mut T`: Rust assumes raw pointers may have special\n" " concurrency considerations." msgstr "" #: src/exercises/day-4/morning.md:1 src/exercises/day-4/afternoon.md:1 msgid "# Exercises" msgstr "" #: src/exercises/day-4/morning.md:3 msgid "Let us practice our new concurrency skills with" msgstr "" #: src/exercises/day-4/morning.md:5 msgid "* Dining philosophers: a classic problem in concurrency." msgstr "" #: src/exercises/day-4/morning.md:7 msgid "" "* Multi-threaded link checker: a larger project where you'll use Cargo to\n" " download dependencies and then check links in parallel." msgstr "" #: src/exercises/day-4/dining-philosophers.md:1 msgid "# Dining Philosophers" msgstr "" #: src/exercises/day-4/dining-philosophers.md:3 msgid "The dining philosophers problem is a classic problem in concurrency:" msgstr "" #: src/exercises/day-4/dining-philosophers.md:5 msgid "" "> Five philosophers dine together at the same table. Each philosopher has " "their\n" "> own place at the table. There is a fork between each plate. The dish " "served is\n" "> a kind of spaghetti which has to be eaten with two forks. Each philosopher " "can\n" "> only alternately think and eat. Moreover, a philosopher can only eat " "their\n" "> spaghetti when they have both a left and right fork. Thus two forks will " "only\n" "> be available when their two nearest neighbors are thinking, not eating. " "After\n" "> an individual philosopher finishes eating, they will put down both forks." msgstr "" #: src/exercises/day-4/dining-philosophers.md:13 msgid "" "You will need a local [Cargo installation](../../cargo/running-locally.md) " "for\n" "this exercise. Copy the code below to `src/main.rs` file, fill out the " "blanks,\n" "and test that `cargo run` does not deadlock:" msgstr "" #: src/exercises/day-4/dining-philosophers.md:17 msgid "" "```rust,compile_fail\n" "use std::sync::mpsc;\n" "use std::sync::{Arc, Mutex};\n" "use std::thread;\n" "use std::time::Duration;" msgstr "" #: src/exercises/day-4/dining-philosophers.md:23 #: src/exercises/day-4/solutions-morning.md:28 msgid "struct Fork;" msgstr "" #: src/exercises/day-4/dining-philosophers.md:25 msgid "" "struct Philosopher {\n" " name: String,\n" " // left_fork: ...\n" " // right_fork: ...\n" " // thoughts: ...\n" "}" msgstr "" #: src/exercises/day-4/dining-philosophers.md:32 msgid "" "impl Philosopher {\n" " fn think(&self) {\n" " self.thoughts\n" " .send(format!(\"Eureka! {} has a new idea!\", &self.name))\n" " .unwrap();\n" " }" msgstr "" #: src/exercises/day-4/dining-philosophers.md:39 msgid "" " fn eat(&self) {\n" " // Pick up forks...\n" " println!(\"{} is eating...\", &self.name);\n" " thread::sleep(Duration::from_millis(10));\n" " }\n" "}" msgstr "" #: src/exercises/day-4/dining-philosophers.md:46 #: src/exercises/day-4/solutions-morning.md:60 msgid "" "static PHILOSOPHERS: &[&str] =\n" " &[\"Socrates\", \"Plato\", \"Aristotle\", \"Thales\", \"Pythagoras\"];" msgstr "" #: src/exercises/day-4/dining-philosophers.md:49 msgid "" "fn main() {\n" " // Create forks" msgstr "" #: src/exercises/day-4/dining-philosophers.md:52 msgid " // Create philosophers" msgstr "" #: src/exercises/day-4/dining-philosophers.md:54 msgid " // Make them think and eat" msgstr "" #: src/exercises/day-4/dining-philosophers.md:56 msgid "" " // Output their thoughts\n" "}\n" "```" msgstr "" #: src/exercises/day-4/link-checker.md:1 msgid "# Multi-threaded Link Checker" msgstr "" #: src/exercises/day-4/link-checker.md:3 msgid "" "Let us use our new knowledge to create a multi-threaded link checker. It " "should\n" "start at a webpage and check that links on the page are valid. It should\n" "recursively check other pages on the same domain and keep doing this until " "all\n" "pages have been validated." msgstr "" #: src/exercises/day-4/link-checker.md:8 msgid "" "For this, you will need an HTTP client such as [`reqwest`][1]. Create a new\n" "Cargo project and `reqwest` it as a dependency with:" msgstr "" #: src/exercises/day-4/link-checker.md:11 msgid "" "```shell\n" "$ cargo new link-checker\n" "$ cd link-checker\n" "$ cargo add --features blocking,rustls-tls reqwest\n" "```" msgstr "" #: src/exercises/day-4/link-checker.md:17 msgid "" "> If `cargo add` fails with `error: no such subcommand`, then please edit " "the\n" "> `Cargo.toml` file by hand. Add the dependencies listed below." msgstr "" #: src/exercises/day-4/link-checker.md:20 msgid "" "You will also need a way to find links. We can use [`scraper`][2] for that:" msgstr "" #: src/exercises/day-4/link-checker.md:22 msgid "" "```shell\n" "$ cargo add scraper\n" "```" msgstr "" #: src/exercises/day-4/link-checker.md:26 msgid "" "Finally, we'll need some way of handling errors. We [`thiserror`][3] for " "that:" msgstr "" #: src/exercises/day-4/link-checker.md:28 msgid "" "```shell\n" "$ cargo add thiserror\n" "```" msgstr "" #: src/exercises/day-4/link-checker.md:32 msgid "" "The `cargo add` calls will update the `Cargo.toml` file to look like this:" msgstr "" #: src/exercises/day-4/link-checker.md:34 msgid "" "```toml\n" "[dependencies]\n" "reqwest = { version = \"0.11.12\", features = [\"blocking\", \"rustls-" "tls\"] }\n" "scraper = \"0.13.0\"\n" "thiserror = \"1.0.37\"\n" "```" msgstr "" #: src/exercises/day-4/link-checker.md:41 msgid "" "You can now download the start page. Try with a small site such as\n" "`https://www.google.org/`." msgstr "" #: src/exercises/day-4/link-checker.md:44 msgid "Your `src/main.rs` file should look something like this:" msgstr "" #: src/exercises/day-4/link-checker.md:46 msgid "" "```rust,compile_fail\n" "use reqwest::blocking::{get, Response};\n" "use reqwest::Url;\n" "use scraper::{Html, Selector};\n" "use thiserror::Error;" msgstr "" #: src/exercises/day-4/link-checker.md:52 msgid "" "#[derive(Error, Debug)]\n" "enum Error {\n" " #[error(\"request error: {0}\")]\n" " ReqwestError(#[from] reqwest::Error),\n" "}" msgstr "" #: src/exercises/day-4/link-checker.md:58 msgid "" "fn extract_links(response: Response) -> Result, Error> {\n" " let base_url = response.url().to_owned();\n" " let document = response.text()?;\n" " let html = Html::parse_document(&document);\n" " let selector = Selector::parse(\"a\").unwrap();" msgstr "" #: src/exercises/day-4/link-checker.md:64 msgid "" " let mut valid_urls = Vec::new();\n" " for element in html.select(&selector) {\n" " if let Some(href) = element.value().attr(\"href\") {\n" " match base_url.join(href) {\n" " Ok(url) => valid_urls.push(url),\n" " Err(err) => {\n" " println!(\"On {base_url}: could not parse {href:?}: " "{err} (ignored)\",);\n" " }\n" " }\n" " }\n" " }" msgstr "" #: src/exercises/day-4/link-checker.md:76 msgid "" " Ok(valid_urls)\n" "}" msgstr "" #: src/exercises/day-4/link-checker.md:79 msgid "" "fn main() {\n" " let start_url = Url::parse(\"https://www.google.org\").unwrap();\n" " let response = get(start_url).unwrap();\n" " match extract_links(response) {\n" " Ok(links) => println!(\"Links: {links:#?}\"),\n" " Err(err) => println!(\"Could not extract links: {err:#}\"),\n" " }\n" "}\n" "```" msgstr "" #: src/exercises/day-4/link-checker.md:89 msgid "Run the code in `src/main.rs` with" msgstr "" #: src/exercises/day-4/link-checker.md:91 msgid "" "```shell\n" "$ cargo run\n" "```" msgstr "" #: src/exercises/day-4/link-checker.md:95 msgid "## Tasks" msgstr "" #: src/exercises/day-4/link-checker.md:97 msgid "" "* Use threads to check the links in parallel: send the URLs to be checked to " "a\n" " channel and let a few threads check the URLs in parallel.\n" "* Extend this to recursively extract links from all pages on the\n" " `www.google.org` domain. Put an upper limit of 100 pages or so so that " "you\n" " don't end up being blocked by the site." msgstr "" #: src/exercises/day-4/link-checker.md:103 msgid "" "[1]: https://docs.rs/reqwest/\n" "[2]: https://docs.rs/scraper/\n" "[3]: https://docs.rs/thiserror/" msgstr "" #: src/android.md:1 msgid "# Android" msgstr "" #: src/android.md:3 msgid "" "Rust is supported for native platform development on Android. This means " "that\n" "you can write new operating system services in Rust, as well as extending\n" "existing services." msgstr "" #: src/android/setup.md:1 msgid "# Setup" msgstr "" #: src/android/setup.md:3 msgid "" "We will be using an Android Virtual Device to test our code. Make sure you " "have\n" "access to one or create a new one with:" msgstr "" #: src/android/setup.md:6 msgid "" "```shell\n" "$ source build/envsetup.sh\n" "$ lunch aosp_cf_x86_64_phone-userdebug\n" "$ acloud create\n" "```" msgstr "" #: src/android/setup.md:12 msgid "" "Please see the [Android Developer\n" "Codelab](https://source.android.com/docs/setup/start) for details." msgstr "" #: src/android/build-rules.md:1 msgid "# Build Rules" msgstr "" #: src/android/build-rules.md:3 msgid "The Android build system (Soong) supports Rust via a number of modules:" msgstr "" #: src/android/build-rules.md:5 msgid "" "| Module Type | " "Description " "|\n" "|-------------------|----------------------------------------------------------------------------------------------------|\n" "| `rust_binary` | Produces a Rust " "binary. " "|\n" "| `rust_library` | Produces a Rust library, and provides both `rlib` and " "`dylib` variants. |\n" "| `rust_ffi` | Produces a Rust C library usable by `cc` modules, and " "provides both static and shared variants. |\n" "| `rust_proc_macro` | Produces a `proc-macro` Rust library. These are " "analogous to compiler plugins. |\n" "| `rust_test` | Produces a Rust test binary that uses the standard " "Rust test harness. |\n" "| `rust_fuzz` | Produces a Rust fuzz binary leveraging " "`libfuzzer`. |\n" "| `rust_protobuf` | Generates source and produces a Rust library that " "provides an interface for a particular protobuf. |\n" "| `rust_bindgen` | Generates source and produces a Rust library " "containing Rust bindings to C libraries. |" msgstr "" #: src/android/build-rules.md:16 msgid "We will look at `rust_binary` and `rust_library` next." msgstr "" #: src/android/build-rules/binary.md:1 msgid "# Rust Binaries" msgstr "" #: src/android/build-rules/binary.md:3 msgid "" "Let us start with a simple application. At the root of an AOSP checkout, " "create\n" "the following files:" msgstr "" #: src/android/build-rules/binary.md:6 src/android/build-rules/library.md:13 msgid "_hello_rust/Android.bp_:" msgstr "" #: src/android/build-rules/binary.md:8 msgid "" "```javascript\n" "rust_binary {\n" " name: \"hello_rust\",\n" " crate_name: \"hello_rust\",\n" " srcs: [\"src/main.rs\"],\n" "}\n" "```" msgstr "" #: src/android/build-rules/binary.md:16 src/android/build-rules/library.md:34 msgid "_hello_rust/src/main.rs_:" msgstr "" #: src/android/build-rules/binary.md:18 msgid "" "```rust\n" "//! Rust demo." msgstr "" #: src/android/build-rules/binary.md:21 msgid "" "/// Prints a greeting to standard output.\n" "fn main() {\n" " println!(\"Hello from Rust!\");\n" "}\n" "```" msgstr "" #: src/android/build-rules/binary.md:27 msgid "You can now build, push, and run the binary:" msgstr "" #: src/android/build-rules/binary.md:29 msgid "" "```shell\n" "$ m hello_rust\n" "$ adb push $ANDROID_PRODUCT_OUT/system/bin/hello_rust /data/local/tmp\n" "$ adb shell /data/local/tmp/hello_rust\n" "Hello from Rust!\n" "```" msgstr "" #: src/android/build-rules/library.md:1 msgid "# Rust Libraries" msgstr "" #: src/android/build-rules/library.md:3 msgid "You use `rust_library` to create a new Rust library for Android." msgstr "" #: src/android/build-rules/library.md:5 msgid "Here we declare a dependency on two libraries:" msgstr "" #: src/android/build-rules/library.md:7 msgid "" "* `libgreeting`, which we define below,\n" "* `libtextwrap`, which is a crate already vendored in\n" " [`external/rust/crates/`][crates]." msgstr "" #: src/android/build-rules/library.md:11 msgid "" "[crates]: https://cs.android.com/android/platform/superproject/+/master:" "external/rust/crates/" msgstr "" #: src/android/build-rules/library.md:15 msgid "" "```javascript\n" "rust_binary {\n" " name: \"hello_rust_with_dep\",\n" " crate_name: \"hello_rust_with_dep\",\n" " srcs: [\"src/main.rs\"],\n" " rustlibs: [\n" " \"libgreetings\",\n" " \"libtextwrap\",\n" " ],\n" " prefer_rlib: true,\n" "}" msgstr "" #: src/android/build-rules/library.md:27 msgid "" "rust_library {\n" " name: \"libgreetings\",\n" " crate_name: \"greetings\",\n" " srcs: [\"src/lib.rs\"],\n" "}\n" "```" msgstr "" #: src/android/build-rules/library.md:36 msgid "" "```rust,ignore\n" "//! Rust demo." msgstr "" #: src/android/build-rules/library.md:39 msgid "" "use greetings::greeting;\n" "use textwrap::fill;" msgstr "" #: src/android/build-rules/library.md:42 msgid "" "/// Prints a greeting to standard output.\n" "fn main() {\n" " println!(\"{}\", fill(&greeting(\"Bob\"), 24));\n" "}\n" "```" msgstr "" #: src/android/build-rules/library.md:48 msgid "_hello_rust/src/lib.rs_:" msgstr "" #: src/android/build-rules/library.md:50 msgid "" "```rust,ignore\n" "//! Greeting library." msgstr "" #: src/android/build-rules/library.md:53 msgid "" "/// Greet `name`.\n" "pub fn greeting(name: &str) -> String {\n" " format!(\"Hello {name}, it is very nice to meet you!\")\n" "}\n" "```" msgstr "" #: src/android/build-rules/library.md:59 msgid "You build, push, and run the binary like before:" msgstr "" #: src/android/build-rules/library.md:61 msgid "" "```shell\n" "$ m hello_rust_with_dep\n" "$ adb push $ANDROID_PRODUCT_OUT/system/bin/hello_rust_with_dep /data/local/" "tmp\n" "$ adb shell /data/local/tmp/hello_rust_with_dep\n" "Hello Bob, it is very\n" "nice to meet you!\n" "```" msgstr "" #: src/android/aidl.md:1 msgid "# AIDL" msgstr "" #: src/android/aidl.md:3 msgid "" "The [Android Interface Definition Language\n" "(AIDL)](https://developer.android.com/guide/components/aidl) is supported in " "Rust:" msgstr "" #: src/android/aidl.md:6 msgid "" "* Rust code can call existing AIDL servers,\n" "* You can create new AIDL servers in Rust." msgstr "" #: src/android/aidl/interface.md:1 msgid "# AIDL Interfaces" msgstr "" #: src/android/aidl/interface.md:3 msgid "You declare the API of your service using an AIDL interface:" msgstr "" #: src/android/aidl/interface.md:5 msgid "" "*birthday_service/aidl/com/example/birthdayservice/IBirthdayService.aidl*:" msgstr "" #: src/android/aidl/interface.md:7 src/android/aidl/changing.md:6 msgid "" "```java\n" "package com.example.birthdayservice;" msgstr "" #: src/android/aidl/interface.md:10 msgid "" "/** Birthday service interface. */\n" "interface IBirthdayService {\n" " /** Generate a Happy Birthday message. */\n" " String wishHappyBirthday(String name, int years);\n" "}\n" "```" msgstr "" #: src/android/aidl/interface.md:17 msgid "*birthday_service/aidl/Android.bp*:" msgstr "" #: src/android/aidl/interface.md:19 msgid "" "```javascript\n" "aidl_interface {\n" " name: \"com.example.birthdayservice\",\n" " srcs: [\"com/example/birthdayservice/*.aidl\"],\n" " unstable: true,\n" " backend: {\n" " rust: { // Rust is not enabled by default\n" " enabled: true,\n" " },\n" " },\n" "}\n" "```" msgstr "" #: src/android/aidl/interface.md:32 msgid "" "Add `vendor_available: true` if your AIDL file is used by a binary in the " "vendor\n" "partition." msgstr "" #: src/android/aidl/implementation.md:1 msgid "# Service Implementation" msgstr "" #: src/android/aidl/implementation.md:3 msgid "We can now implement the AIDL service:" msgstr "" #: src/android/aidl/implementation.md:5 msgid "*birthday_service/src/lib.rs*:" msgstr "" #: src/android/aidl/implementation.md:7 msgid "" "```rust,ignore\n" "//! Implementation of the `IBirthdayService` AIDL interface.\n" "use com_example_birthdayservice::aidl::com::example::birthdayservice::" "IBirthdayService::IBirthdayService;\n" "use com_example_birthdayservice::binder;" msgstr "" #: src/android/aidl/implementation.md:12 msgid "" "/// The `IBirthdayService` implementation.\n" "pub struct BirthdayService;" msgstr "" #: src/android/aidl/implementation.md:15 msgid "impl binder::Interface for BirthdayService {}" msgstr "" #: src/android/aidl/implementation.md:17 msgid "" "impl IBirthdayService for BirthdayService {\n" " fn wishHappyBirthday(&self, name: &str, years: i32) -> binder::" "Result {\n" " Ok(format!(\n" " \"Happy Birthday {name}, congratulations with the {years} years!" "\"\n" " ))\n" " }\n" "}\n" "```" msgstr "" #: src/android/aidl/implementation.md:26 src/android/aidl/server.md:28 #: src/android/aidl/client.md:37 msgid "*birthday_service/Android.bp*:" msgstr "" #: src/android/aidl/implementation.md:28 msgid "" "```javascript\n" "rust_library {\n" " name: \"libbirthdayservice\",\n" " srcs: [\"src/lib.rs\"],\n" " crate_name: \"birthdayservice\",\n" " rustlibs: [\n" " \"com.example.birthdayservice-rust\",\n" " \"libbinder_rs\",\n" " ],\n" "}\n" "```" msgstr "" #: src/android/aidl/server.md:1 msgid "# AIDL Server" msgstr "" #: src/android/aidl/server.md:3 msgid "Finally, we can create a server which exposes the service:" msgstr "" #: src/android/aidl/server.md:5 msgid "*birthday_service/src/server.rs*:" msgstr "" #: src/android/aidl/server.md:7 msgid "" "```rust,ignore\n" "//! Birthday service.\n" "use birthdayservice::BirthdayService;\n" "use com_example_birthdayservice::aidl::com::example::birthdayservice::" "IBirthdayService::BnBirthdayService;\n" "use com_example_birthdayservice::binder;" msgstr "" #: src/android/aidl/server.md:13 src/android/aidl/client.md:12 msgid "const SERVICE_IDENTIFIER: &str = \"birthdayservice\";" msgstr "" #: src/android/aidl/server.md:15 msgid "" "/// Entry point for birthday service.\n" "fn main() {\n" " let birthday_service = BirthdayService;\n" " let birthday_service_binder = BnBirthdayService::new_binder(\n" " birthday_service,\n" " binder::BinderFeatures::default(),\n" " );\n" " binder::add_service(SERVICE_IDENTIFIER, birthday_service_binder." "as_binder())\n" " .expect(\"Failed to register service\");\n" " binder::ProcessState::join_thread_pool()\n" "}\n" "```" msgstr "" #: src/android/aidl/server.md:30 msgid "" "```javascript\n" "rust_binary {\n" " name: \"birthday_server\",\n" " crate_name: \"birthday_server\",\n" " srcs: [\"src/server.rs\"],\n" " rustlibs: [\n" " \"com.example.birthdayservice-rust\",\n" " \"libbinder_rs\",\n" " \"libbirthdayservice\",\n" " ],\n" " prefer_rlib: true,\n" "}\n" "```" msgstr "" #: src/android/aidl/deploy.md:1 msgid "# Deploy" msgstr "" #: src/android/aidl/deploy.md:3 msgid "We can now build, push, and start the service:" msgstr "" #: src/android/aidl/deploy.md:5 msgid "" "```shell\n" "$ m birthday_server\n" "$ adb push $ANDROID_PRODUCT_OUT/system/bin/birthday_server /data/local/tmp\n" "$ adb shell /data/local/tmp/birthday_server\n" "```" msgstr "" #: src/android/aidl/deploy.md:11 msgid "In another terminal, check that the service runs:" msgstr "" #: src/android/aidl/deploy.md:13 msgid "" "```shell\n" "$ adb shell service check birthdayservice\n" "Service birthdayservice: found\n" "```" msgstr "" #: src/android/aidl/deploy.md:18 msgid "You can also call the service with `service call`:" msgstr "" #: src/android/aidl/deploy.md:20 msgid "" "```shell\n" "$ $ adb shell service call birthdayservice 1 s16 Bob i32 24\n" "Result: Parcel(\n" " 0x00000000: 00000000 00000036 00610048 00700070 '....6...H.a.p.p.'\n" " 0x00000010: 00200079 00690042 00740072 00640068 'y. .B.i.r.t.h.d.'\n" " 0x00000020: 00790061 00420020 0062006f 0020002c 'a.y. .B.o.b.,. .'\n" " 0x00000030: 006f0063 0067006e 00610072 00750074 'c.o.n.g.r.a.t.u.'\n" " 0x00000040: 0061006c 00690074 006e006f 00200073 'l.a.t.i.o.n.s. .'\n" " 0x00000050: 00690077 00680074 00740020 00650068 'w.i.t.h. .t.h.e.'\n" " 0x00000060: 00320020 00200034 00650079 00720061 ' .2.4. .y.e.a.r.'\n" " 0x00000070: 00210073 00000000 's.!..... ')\n" "```" msgstr "" #: src/android/aidl/client.md:1 msgid "# AIDL Client" msgstr "" #: src/android/aidl/client.md:3 msgid "Finally, we can create a Rust client for our new service." msgstr "" #: src/android/aidl/client.md:5 msgid "*birthday_service/src/client.rs*:" msgstr "" #: src/android/aidl/client.md:7 msgid "" "```rust,ignore\n" "//! Birthday service.\n" "use com_example_birthdayservice::aidl::com::example::birthdayservice::" "IBirthdayService::IBirthdayService;\n" "use com_example_birthdayservice::binder;" msgstr "" #: src/android/aidl/client.md:14 msgid "" "/// Connect to the BirthdayService.\n" "pub fn connect() -> Result, binder::" "StatusCode> {\n" " binder::get_interface(SERVICE_IDENTIFIER)\n" "}" msgstr "" #: src/android/aidl/client.md:19 msgid "" "/// Call the birthday service.\n" "fn main() -> Result<(), binder::Status> {\n" " let name = std::env::args()\n" " .nth(1)\n" " .unwrap_or_else(|| String::from(\"Bob\"));\n" " let years = std::env::args()\n" " .nth(2)\n" " .and_then(|arg| arg.parse::().ok())\n" " .unwrap_or(42);" msgstr "" #: src/android/aidl/client.md:29 msgid "" " binder::ProcessState::start_thread_pool();\n" " let service = connect().expect(\"Failed to connect to " "BirthdayService\");\n" " let msg = service.wishHappyBirthday(&name, years)?;\n" " println!(\"{msg}\");\n" " Ok(())\n" "}\n" "```" msgstr "" #: src/android/aidl/client.md:39 msgid "" "```javascript\n" "rust_binary {\n" " name: \"birthday_client\",\n" " crate_name: \"birthday_client\",\n" " srcs: [\"src/client.rs\"],\n" " rustlibs: [\n" " \"com.example.birthdayservice-rust\",\n" " \"libbinder_rs\",\n" " ],\n" " prefer_rlib: true,\n" "}\n" "```" msgstr "" #: src/android/aidl/client.md:52 msgid "Notice that the client does not depend on `libbirthdayservice`." msgstr "" #: src/android/aidl/client.md:54 msgid "Build, push, and run the client on your device:" msgstr "" #: src/android/aidl/client.md:56 msgid "" "```shell\n" "$ m birthday_client\n" "$ adb push $ANDROID_PRODUCT_OUT/system/bin/birthday_client /data/local/tmp\n" "$ adb shell /data/local/tmp/birthday_client Charlie 60\n" "Happy Birthday Charlie, congratulations with the 60 years!\n" "```" msgstr "" #: src/android/aidl/changing.md:1 msgid "# Changing API" msgstr "" #: src/android/aidl/changing.md:3 msgid "" "Let us extend the API with more functionality: we want to let clients " "specify a\n" "list of lines for the birthday card:" msgstr "" #: src/android/aidl/changing.md:9 msgid "" "/** Birthday service interface. */\n" "interface IBirthdayService {\n" " /** Generate a Happy Birthday message. */\n" " String wishHappyBirthday(String name, int years, in String[] text);\n" "}\n" "```" msgstr "" #: src/android/logging.md:1 msgid "# Logging" msgstr "" #: src/android/logging.md:3 msgid "" "You should use the `log` crate to automatically log to `logcat` (on-device) " "or\n" "`stdout` (on-host):" msgstr "" #: src/android/logging.md:6 msgid "_hello_rust_logs/Android.bp_:" msgstr "" #: src/android/logging.md:8 msgid "" "```javascript\n" "rust_binary {\n" " name: \"hello_rust_logs\",\n" " crate_name: \"hello_rust_logs\",\n" " srcs: [\"src/main.rs\"],\n" " rustlibs: [\n" " \"liblog_rust\",\n" " \"liblogger\",\n" " ],\n" " prefer_rlib: true,\n" " host_supported: true,\n" "}\n" "```" msgstr "" #: src/android/logging.md:22 msgid "_hello_rust_logs/src/main.rs_:" msgstr "" #: src/android/logging.md:24 msgid "" "```rust,ignore\n" "//! Rust logging demo." msgstr "" #: src/android/logging.md:27 msgid "use log::{debug, error};" msgstr "" #: src/android/logging.md:29 msgid "" "/// Logs a greeting.\n" "fn main() {\n" " logger::init(\n" " logger::Config::default()\n" " .with_tag_on_device(\"rust\")\n" " .with_min_level(log::Level::Trace),\n" " );\n" " debug!(\"Starting program.\");\n" " error!(\"Something went wrong!\");\n" "}\n" "```" msgstr "" #: src/android/logging.md:41 src/android/interoperability/with-c/bindgen.md:98 #: src/android/interoperability/with-c/rust.md:73 msgid "Build, push, and run the binary on your device:" msgstr "" #: src/android/logging.md:43 msgid "" "```shell\n" "$ m hello_rust_logs\n" "$ adb push $ANDROID_PRODUCT_OUT/system/bin/hello_rust_logs /data/local/tmp\n" "$ adb shell /data/local/tmp/hello_rust_logs\n" "```" msgstr "" #: src/android/logging.md:49 msgid "The logs show up in `adb logcat`:" msgstr "" #: src/android/logging.md:51 msgid "" "```shell\n" "$ adb logcat -s rust\n" "09-08 08:38:32.454 2420 2420 D rust: hello_rust_logs: Starting program.\n" "09-08 08:38:32.454 2420 2420 I rust: hello_rust_logs: Things are going " "fine.\n" "09-08 08:38:32.454 2420 2420 E rust: hello_rust_logs: Something went " "wrong!\n" "```" msgstr "" #: src/android/interoperability.md:1 msgid "# Interoperability" msgstr "" #: src/android/interoperability.md:3 msgid "" "Rust has excellent support for interoperability with other languages. This " "means\n" "that you can:" msgstr "" #: src/android/interoperability.md:6 msgid "" "* Call Rust functions from other languages.\n" "* Call functions written in other languages from Rust." msgstr "" #: src/android/interoperability.md:9 msgid "" "When you call functions in a foreign language we say that you're using a\n" "_foreign function interface_, also known as FFI." msgstr "" #: src/android/interoperability/with-c.md:1 msgid "# Interoperability with C" msgstr "" #: src/android/interoperability/with-c.md:3 msgid "" "Rust has full support for linking object files with a C calling convention.\n" "Similarly, you can export Rust functions and call them from C." msgstr "" #: src/android/interoperability/with-c.md:6 msgid "You can do it by hand if you want:" msgstr "" #: src/android/interoperability/with-c.md:8 msgid "" "```rust\n" "extern \"C\" {\n" " fn abs(x: i32) -> i32;\n" "}" msgstr "" #: src/android/interoperability/with-c.md:13 msgid "" "fn main() {\n" " let x = -42;\n" " let abs_x = unsafe { abs(x) };\n" " println!(\"{x}, {abs_x}\");\n" "}\n" "```" msgstr "" #: src/android/interoperability/with-c.md:20 msgid "" "We already saw this in the [Safe FFI Wrapper\n" "exercise](../../exercises/day-3/safe-ffi-wrapper.md)." msgstr "" #: src/android/interoperability/with-c.md:23 msgid "" "> This assumes full knowledge of the target platform. Not recommended for\n" "> production." msgstr "" #: src/android/interoperability/with-c.md:26 msgid "We will look at better options next." msgstr "" #: src/android/interoperability/with-c/bindgen.md:1 msgid "# Using Bindgen" msgstr "" #: src/android/interoperability/with-c/bindgen.md:3 msgid "" "The [bindgen](https://rust-lang.github.io/rust-bindgen/introduction.html) " "tool\n" "can auto-generate bindings from a C header file." msgstr "" #: src/android/interoperability/with-c/bindgen.md:6 msgid "First create a small C library:" msgstr "" #: src/android/interoperability/with-c/bindgen.md:8 msgid "_interoperability/bindgen/libbirthday.h_:" msgstr "" #: src/android/interoperability/with-c/bindgen.md:10 msgid "" "```c\n" "typedef struct card {\n" " const char* name;\n" " int years;\n" "} card;" msgstr "" #: src/android/interoperability/with-c/bindgen.md:16 msgid "" "void print_card(const card* card);\n" "```" msgstr "" #: src/android/interoperability/with-c/bindgen.md:19 msgid "_interoperability/bindgen/libbirthday.c_:" msgstr "" #: src/android/interoperability/with-c/bindgen.md:21 msgid "" "```c\n" "#include \n" "#include \"libbirthday.h\"" msgstr "" #: src/android/interoperability/with-c/bindgen.md:25 msgid "" "void print_card(const card* card) {\n" " printf(\"+--------------\\n\");\n" " printf(\"| Happy Birthday %s!\\n\", card->name);\n" " printf(\"| Congratulations with the %i years!\\n\", card->years);\n" " printf(\"+--------------\\n\");\n" "}\n" "```" msgstr "" #: src/android/interoperability/with-c/bindgen.md:33 msgid "Add this to your `Android.bp` file:" msgstr "" #: src/android/interoperability/with-c/bindgen.md:35 #: src/android/interoperability/with-c/bindgen.md:55 #: src/android/interoperability/with-c/bindgen.md:69 #: src/android/interoperability/with-c/bindgen.md:108 msgid "_interoperability/bindgen/Android.bp_:" msgstr "" #: src/android/interoperability/with-c/bindgen.md:37 msgid "" "```javascript\n" "cc_library {\n" " name: \"libbirthday\",\n" " srcs: [\"libbirthday.c\"],\n" "}\n" "```" msgstr "" #: src/android/interoperability/with-c/bindgen.md:44 msgid "" "Create a wrapper header file for the library (not strictly needed in this\n" "example):" msgstr "" #: src/android/interoperability/with-c/bindgen.md:47 msgid "_interoperability/bindgen/libbirthday_wrapper.h_:" msgstr "" #: src/android/interoperability/with-c/bindgen.md:49 msgid "" "```c\n" "#include \"libbirthday.h\"\n" "```" msgstr "" #: src/android/interoperability/with-c/bindgen.md:53 msgid "You can now auto-generate the bindings:" msgstr "" #: src/android/interoperability/with-c/bindgen.md:57 msgid "" "```javascript\n" "rust_bindgen {\n" " name: \"libbirthday_bindgen\",\n" " crate_name: \"birthday_bindgen\",\n" " wrapper_src: \"libbirthday_wrapper.h\",\n" " source_stem: \"bindings\",\n" " static_libs: [\"libbirthday\"],\n" "}\n" "```" msgstr "" #: src/android/interoperability/with-c/bindgen.md:67 msgid "Finally, we can use the bindings in our Rust program:" msgstr "" #: src/android/interoperability/with-c/bindgen.md:71 msgid "" "```javascript\n" "rust_binary {\n" " name: \"print_birthday_card\",\n" " srcs: [\"main.rs\"],\n" " rustlibs: [\"libbirthday_bindgen\"],\n" "}\n" "```" msgstr "" #: src/android/interoperability/with-c/bindgen.md:79 msgid "_interoperability/bindgen/main.rs_:" msgstr "" #: src/android/interoperability/with-c/bindgen.md:81 msgid "" "```rust,compile_fail\n" "//! Bindgen demo." msgstr "" #: src/android/interoperability/with-c/bindgen.md:84 msgid "use birthday_bindgen::{card, print_card};" msgstr "" #: src/android/interoperability/with-c/bindgen.md:86 msgid "" "fn main() {\n" " let name = std::ffi::CString::new(\"Peter\").unwrap();\n" " let card = card {\n" " name: name.as_ptr(),\n" " years: 42,\n" " };\n" " unsafe {\n" " print_card(&card as *const card);\n" " }\n" "}\n" "```" msgstr "" #: src/android/interoperability/with-c/bindgen.md:100 msgid "" "```shell\n" "$ m print_birthday_card\n" "$ adb push $ANDROID_PRODUCT_OUT/system/bin/print_birthday_card /data/local/" "tmp\n" "$ adb shell /data/local/tmp/print_birthday_card\n" "```" msgstr "" #: src/android/interoperability/with-c/bindgen.md:106 msgid "Finally, we can run auto-generated tests to ensure the bindings work:" msgstr "" #: src/android/interoperability/with-c/bindgen.md:110 msgid "" "```javascript\n" "rust_test {\n" " name: \"libbirthday_bindgen_test\",\n" " srcs: [\":libbirthday_bindgen\"],\n" " crate_name: \"libbirthday_bindgen_test\",\n" " test_suites: [\"general-tests\"],\n" " auto_gen_config: true,\n" " clippy_lints: \"none\", // Generated file, skip linting\n" " lints: \"none\",\n" "}\n" "```" msgstr "" #: src/android/interoperability/with-c/bindgen.md:122 msgid "" "```shell\n" "$ atest libbirthday_bindgen_test\n" "```" msgstr "" #: src/android/interoperability/with-c/rust.md:1 msgid "# Calling Rust" msgstr "" #: src/android/interoperability/with-c/rust.md:3 msgid "Exporting Rust functions and types to C is easy:" msgstr "" #: src/android/interoperability/with-c/rust.md:5 msgid "_interoperability/rust/libanalyze/analyze.rs_" msgstr "" #: src/android/interoperability/with-c/rust.md:7 msgid "" "```rust,editable\n" "//! Rust FFI demo.\n" "#![deny(improper_ctypes_definitions)]" msgstr "" #: src/android/interoperability/with-c/rust.md:11 msgid "use std::os::raw::c_int;" msgstr "" #: src/android/interoperability/with-c/rust.md:13 msgid "" "/// Analyze the numbers.\n" "#[no_mangle]\n" "pub extern \"C\" fn analyze_numbers(x: c_int, y: c_int) {\n" " if x < y {\n" " println!(\"x ({x}) is smallest!\");\n" " } else {\n" " println!(\"y ({y}) is probably larger than x ({x})\");\n" " }\n" "}\n" "```" msgstr "" #: src/android/interoperability/with-c/rust.md:24 msgid "_interoperability/rust/libanalyze/analyze.h_" msgstr "" #: src/android/interoperability/with-c/rust.md:26 msgid "" "```c\n" "#ifndef ANALYSE_H\n" "#define ANALYSE_H" msgstr "" #: src/android/interoperability/with-c/rust.md:30 msgid "" "extern \"C\" {\n" "void analyze_numbers(int x, int y);\n" "}" msgstr "" #: src/android/interoperability/with-c/rust.md:34 msgid "" "#endif\n" "```" msgstr "" #: src/android/interoperability/with-c/rust.md:37 msgid "_interoperability/rust/libanalyze/Android.bp_" msgstr "" #: src/android/interoperability/with-c/rust.md:39 msgid "" "```javascript\n" "rust_ffi {\n" " name: \"libanalyze_ffi\",\n" " crate_name: \"analyze_ffi\",\n" " srcs: [\"analyze.rs\"],\n" " include_dirs: [\".\"],\n" "}\n" "```" msgstr "" #: src/android/interoperability/with-c/rust.md:48 msgid "We can now call this from a C binary:" msgstr "" #: src/android/interoperability/with-c/rust.md:50 msgid "_interoperability/rust/analyze/main.c_" msgstr "" #: src/android/interoperability/with-c/rust.md:52 msgid "" "```c\n" "#include \"analyze.h\"" msgstr "" #: src/android/interoperability/with-c/rust.md:55 msgid "" "int main() {\n" " analyze_numbers(10, 20);\n" " analyze_numbers(123, 123);\n" " return 0;\n" "}\n" "```" msgstr "" #: src/android/interoperability/with-c/rust.md:62 msgid "_interoperability/rust/analyze/Android.bp_" msgstr "" #: src/android/interoperability/with-c/rust.md:64 msgid "" "```javascript\n" "cc_binary {\n" " name: \"analyze_numbers\",\n" " srcs: [\"main.c\"],\n" " static_libs: [\"libanalyze_ffi\"],\n" "}\n" "```" msgstr "" #: src/android/interoperability/with-c/rust.md:75 msgid "" "```shell\n" "$ m analyze_numbers\n" "$ adb push $ANDROID_PRODUCT_OUT/system/bin/analyze_numbers /data/local/tmp\n" "$ adb shell /data/local/tmp/analyze_numbers\n" "```" msgstr "" #: src/android/interoperability/cpp.md:1 msgid "# With C++" msgstr "" #: src/android/interoperability/cpp.md:3 msgid "" "The [CXX crate][1] makes it possible to do safe interoperability between " "Rust\n" "and C++." msgstr "" #: src/android/interoperability/cpp.md:6 msgid "The overall approach looks like this:" msgstr "" #: src/android/interoperability/cpp.md:8 msgid "" msgstr "" #: src/android/interoperability/cpp.md:10 msgid "See the [CXX tutorial][2] for an full example of using this." msgstr "" #: src/android/interoperability/cpp.md:12 msgid "" "[1]: https://cxx.rs/\n" "[2]: https://cxx.rs/tutorial.html" msgstr "" #: src/android/interoperability/java.md:1 msgid "# Interoperability with Java" msgstr "" #: src/android/interoperability/java.md:3 msgid "" "Java can load shared objects via [Java Native Interface\n" "(JNI)](https://en.wikipedia.org/wiki/Java_Native_Interface). The [`jni`\n" "crate](https://docs.rs/jni/) allows you to create a compatible library." msgstr "" #: src/android/interoperability/java.md:7 msgid "First, we create a Rust function to export to Java:" msgstr "" #: src/android/interoperability/java.md:9 msgid "_interoperability/java/src/lib.rs_:" msgstr "" #: src/android/interoperability/java.md:11 msgid "" "```rust,compile_fail\n" "//! Rust <-> Java FFI demo." msgstr "" #: src/android/interoperability/java.md:14 msgid "" "use jni::objects::{JClass, JString};\n" "use jni::sys::jstring;\n" "use jni::JNIEnv;" msgstr "" #: src/android/interoperability/java.md:18 msgid "" "/// HelloWorld::hello method implementation.\n" "#[no_mangle]\n" "pub extern \"system\" fn Java_HelloWorld_hello(\n" " env: JNIEnv,\n" " _class: JClass,\n" " name: JString,\n" ") -> jstring {\n" " let input: String = env.get_string(name).unwrap().into();\n" " let greeting = format!(\"Hello, {input}!\");\n" " let output = env.new_string(greeting).unwrap();\n" " output.into_inner()\n" "}\n" "```" msgstr "" #: src/android/interoperability/java.md:32 #: src/android/interoperability/java.md:62 msgid "_interoperability/java/Android.bp_:" msgstr "" #: src/android/interoperability/java.md:34 msgid "" "```javascript\n" "rust_ffi_shared {\n" " name: \"libhello_jni\",\n" " crate_name: \"hello_jni\",\n" " srcs: [\"src/lib.rs\"],\n" " rustlibs: [\"libjni\"],\n" "}\n" "```" msgstr "" #: src/android/interoperability/java.md:43 msgid "Finally, we can call this function from Java:" msgstr "" #: src/android/interoperability/java.md:45 msgid "_interoperability/java/HelloWorld.java_:" msgstr "" #: src/android/interoperability/java.md:47 msgid "" "```java\n" "class HelloWorld {\n" " private static native String hello(String name);" msgstr "" #: src/android/interoperability/java.md:51 msgid "" " static {\n" " System.loadLibrary(\"hello_jni\");\n" " }" msgstr "" #: src/android/interoperability/java.md:55 msgid "" " public static void main(String[] args) {\n" " String output = HelloWorld.hello(\"Alice\");\n" " System.out.println(output);\n" " }\n" "}\n" "```" msgstr "" #: src/android/interoperability/java.md:64 msgid "" "```javascript\n" "java_binary {\n" " name: \"helloworld_jni\",\n" " srcs: [\"HelloWorld.java\"],\n" " main_class: \"HelloWorld\",\n" " required: [\"libhello_jni\"],\n" "}\n" "```" msgstr "" #: src/android/interoperability/java.md:73 msgid "Finally, you can build, sync, and run the binary:" msgstr "" #: src/android/interoperability/java.md:75 msgid "" "```shell\n" "$ m helloworld_jni\n" "$ adb sync # requires adb root && adb remount\n" "$ adb shell /system/bin/helloworld_jni\n" "```" msgstr "" #: src/exercises/day-4/afternoon.md:3 msgid "" "For the last exercise, we will look at one of the projects you work with. " "Let us\n" "group up and do this together. Some suggestions:" msgstr "" #: src/exercises/day-4/afternoon.md:6 msgid "* Call your AIDL service with a client written in Rust." msgstr "" #: src/exercises/day-4/afternoon.md:8 msgid "* Move a function from your project to Rust and call it." msgstr "" #: src/exercises/day-4/afternoon.md:12 msgid "" "No solution is provided here since this is open-ended: it relies on someone " "in\n" "the class having a piece of code which you can turn in to Rust on the fly." msgstr "" #: src/thanks.md:1 msgid "# Thanks!" msgstr "" #: src/thanks.md:3 msgid "" "_Thank you for taking Comprehensive Rust 🦀!_ We hope you enjoyed it and " "that it\n" "was useful." msgstr "" #: src/thanks.md:6 msgid "" "We've had a lot of fun putting the course together. The course is not " "perfect,\n" "so if you spotted any mistakes or have ideas for improvements, please get " "in\n" "[contact with us on\n" "GitHub](https://github.com/google/comprehensive-rust/discussions). We would " "love\n" "to hear from you." msgstr "" #: src/other-resources.md:1 msgid "# Other Rust Resources" msgstr "" #: src/other-resources.md:3 msgid "" "The Rust community has created a wealth of high-quality and free resources\n" "online." msgstr "" #: src/other-resources.md:6 msgid "## Official Documentation" msgstr "" #: src/other-resources.md:8 msgid "The Rust project hosts many resources. These cover Rust in general:" msgstr "" #: src/other-resources.md:10 msgid "" "* [The Rust Programming Language](https://doc.rust-lang.org/book/): the\n" " canonical free book about Rust. Covers the language in detail and includes " "a\n" " few projects for people to build.\n" "* [Rust By Example](https://doc.rust-lang.org/rust-by-example/): covers the " "Rust\n" " syntax via a series of examples which showcase different constructs. " "Sometimes\n" " includes small exercises where you are asked to expand on the code in the\n" " examples.\n" "* [Rust Standard Library](https://doc.rust-lang.org/std/): full " "documentation of\n" " the standard library for Rust.\n" "* [The Rust Reference](https://doc.rust-lang.org/reference/): an incomplete " "book\n" " which describes the Rust grammar and memory model." msgstr "" #: src/other-resources.md:22 msgid "More specialized guides hosted on the official Rust site:" msgstr "" #: src/other-resources.md:24 msgid "" "* [The Rustonomicon](https://doc.rust-lang.org/nomicon/): covers unsafe " "Rust,\n" " including working with raw pointers and interfacing with other languages\n" " (FFI).\n" "* [Asynchronous Programming in Rust](https://rust-lang.github.io/async-" "book/):\n" " covers the new asynchronous programming model which was introduced after " "the\n" " Rust Book was written.\n" "* [The Embedded Rust Book](https://doc.rust-lang.org/stable/embedded-book/): " "an\n" " introduction to using Rust on embedded devices without an operating system." msgstr "" #: src/other-resources.md:33 msgid "## Unofficial Learning Material" msgstr "" #: src/other-resources.md:35 msgid "A small selection of other guides and tutorial for Rust:" msgstr "" #: src/other-resources.md:37 msgid "" "* [Learn Rust the Dangerous Way](http://cliffle.com/p/dangerust/): covers " "Rust\n" " from the perspective of low-level C programmers.\n" "* [Rust for Embedded C\n" " Programmers](https://docs.opentitan.org/doc/ug/rust_for_c/): covers Rust " "from\n" " the perspective of developers who write firmware in C.\n" "* [Rust for professionals](https://overexact.com/rust-for-professionals/):\n" " covers the syntax of Rust using side-by-side comparisons with other " "languages\n" " such as C, C++, Java, JavaScript, and Python.\n" "* [Rust on Exercism](https://exercism.org/tracks/rust): 100+ exercises to " "help\n" " you learn Rust.\n" "* [Ferrous Teaching\n" " Material](https://ferrous-systems.github.io/teaching-material/index.html): " "a\n" " series of small presentations covering both basic and advanced part of " "the\n" " Rust language. Other topics such as WebAssembly, and async/await are also\n" " covered.\n" "* [Beginner's Series to\n" " Rust](https://docs.microsoft.com/en-us/shows/beginners-series-to-rust/) " "and\n" " [Take your first steps with\n" " Rust](https://docs.microsoft.com/en-us/learn/paths/rust-first-steps/): " "two\n" " Rust guides aimed at new developers. The first is a set of 35 videos and " "the\n" " second is a set of 11 modules which covers Rust syntax and basic " "constructs." msgstr "" #: src/other-resources.md:59 msgid "" "Please see the [Little Book of Rust Books](https://lborb.github.io/book/) " "for\n" "even more Rust books." msgstr "" #: src/credits.md:1 msgid "# Credits" msgstr "" #: src/credits.md:3 msgid "" "The material here builds on top of the many great sources of Rust " "documentation.\n" "See the page on [other resources](other-resources.md) for a full list of " "useful\n" "resources." msgstr "" #: src/credits.md:7 msgid "" "The material of Comprehensive Rust is licensed under the terms of the Apache " "2.0\n" "license, please see [`LICENSE.txt`](../LICENSE.txt) for details." msgstr "" #: src/credits.md:10 msgid "## Rust by Example" msgstr "" #: src/credits.md:12 msgid "" "Some examples and exercises have been copied and adapted from [Rust by\n" "Example](https://doc.rust-lang.org/rust-by-example/). Please see the\n" "`third_party/rust-by-example/` directory for details, including the license\n" "terms." msgstr "" #: src/credits.md:17 msgid "## Rust on Exercism" msgstr "" #: src/credits.md:19 msgid "" "Some exercises have been copied and adapted from [Rust on\n" "Exercism](https://exercism.org/tracks/rust). Please see the\n" "`third_party/rust-on-exercism/` directory for details, including the " "license\n" "terms." msgstr "" #: src/credits.md:24 msgid "## CXX" msgstr "" #: src/credits.md:26 msgid "" "The [Interoperability with C++](android/interoperability/cpp.md) section " "uses an\n" "image from [CXX](https://cxx.rs/). Please see the `third_party/cxx/` " "directory\n" "for details, including the license terms." msgstr "" #: src/exercises/solutions.md:1 msgid "# Solutions" msgstr "" #: src/exercises/solutions.md:3 msgid "You will find solutions to the exercises on the following pages." msgstr "" #: src/exercises/solutions.md:5 msgid "" "Feel free to ask questions about the solutions [on\n" "GitHub](https://github.com/google/comprehensive-rust/discussions). Let us " "know\n" "if you have a different or better solution than what is presented here." msgstr "" #: src/exercises/solutions.md:10 msgid "" "> **Note:** Please ignore the `// ANCHOR: label` and `// ANCHOR_END: label`\n" "> comments you see in the solutions. They are there to make it possible to\n" "> re-use parts of the solutions as the exercises." msgstr "" #: src/exercises/day-1/solutions-morning.md:1 msgid "# Day 1 Morning Exercises" msgstr "" #: src/exercises/day-1/solutions-morning.md:3 msgid "## Arrays and `for` Loops" msgstr "" #: src/exercises/day-1/solutions-morning.md:5 msgid "([back to exercise](for-loops.md))" msgstr "" #: src/exercises/day-1/solutions-morning.md:7 #: src/exercises/day-1/solutions-afternoon.md:7 #: src/exercises/day-2/solutions-morning.md:7 #: src/exercises/day-2/solutions-afternoon.md:7 #: src/exercises/day-2/solutions-afternoon.md:102 #: src/exercises/day-3/solutions-morning.md:7 #: src/exercises/day-3/solutions-afternoon.md:7 #: src/exercises/day-4/solutions-morning.md:7 msgid "" "```rust\n" "// Copyright 2022 Google LLC\n" "//\n" "// Licensed under the Apache License, Version 2.0 (the \"License\");\n" "// you may not use this file except in compliance with the License.\n" "// You may obtain a copy of the License at\n" "//\n" "// http://www.apache.org/licenses/LICENSE-2.0\n" "//\n" "// Unless required by applicable law or agreed to in writing, software\n" "// distributed under the License is distributed on an \"AS IS\" BASIS,\n" "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n" "// See the License for the specific language governing permissions and\n" "// limitations under the License." msgstr "" "```rust\n" "// Copyright 2022 Google LLC\n" "//\n" "// Licensed under the Apache License, Version 2.0 (the \"License\");\n" "// you may not use this file except in compliance with the License.\n" "// You may obtain a copy of the License at\n" "//\n" "// http://www.apache.org/licenses/LICENSE-2.0\n" "//\n" "// Unless required by applicable law or agreed to in writing, software\n" "// distributed under the License is distributed on an \"AS IS\" BASIS,\n" "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n" "// See the License for the specific language governing permissions and\n" "// limitations under the License." #: src/exercises/day-1/solutions-morning.md:22 msgid "" "// ANCHOR: transpose\n" "fn transpose(matrix: [[i32; 3]; 3]) -> [[i32; 3]; 3] {\n" " // ANCHOR_END: transpose\n" " let mut result = [[0; 3]; 3];\n" " for i in 0..3 {\n" " for j in 0..3 {\n" " result[j][i] = matrix[i][j];\n" " }\n" " }\n" " return result;\n" "}" msgstr "" #: src/exercises/day-1/solutions-morning.md:34 msgid "" "// ANCHOR: pretty_print\n" "fn pretty_print(matrix: &[[i32; 3]; 3]) {\n" " // ANCHOR_END: pretty_print\n" " for row in matrix {\n" " println!(\"{row:?}\");\n" " }\n" "}" msgstr "" #: src/exercises/day-1/solutions-morning.md:42 msgid "" "// ANCHOR: tests\n" "#[test]\n" "fn test_transpose() {\n" " let matrix = [\n" " [101, 102, 103], //\n" " [201, 202, 203],\n" " [301, 302, 303],\n" " ];\n" " let transposed = transpose(matrix);\n" " assert_eq!(\n" " transposed,\n" " [\n" " [101, 201, 301], //\n" " [102, 202, 302],\n" " [103, 203, 303],\n" " ]\n" " );\n" "}\n" "// ANCHOR_END: tests" msgstr "" #: src/exercises/day-1/solutions-morning.md:62 msgid "" "// ANCHOR: main\n" "fn main() {\n" " let matrix = [\n" " [101, 102, 103], // <-- the comment makes rustfmt add a newline\n" " [201, 202, 203],\n" " [301, 302, 303],\n" " ];" msgstr "" #: src/exercises/day-1/solutions-morning.md:73 msgid "" " let transposed = transpose(matrix);\n" " println!(\"transposed:\");\n" " pretty_print(&transposed);\n" "}\n" "```\n" "### Bonus question" msgstr "" #: src/exercises/day-1/solutions-morning.md:80 msgid "" "It honestly doesn't work so well. It might seem that we could use a slice-of-" "slices (`&[&[i32]]`) as the input type to transpose and thus make our " "function handle any size of matrix. However, this quickly breaks down: the " "return type cannot be `&[&[i32]]` since it needs to own the data you return." msgstr "" #: src/exercises/day-1/solutions-morning.md:82 msgid "" "You can attempt to use something like `Vec>`, but this doesn't work " "very well either: it's hard to convert from `Vec>` to `&[&[i32]]` " "so now you cannot easily use `pretty_print` either." msgstr "" #: src/exercises/day-1/solutions-afternoon.md:1 msgid "# Day 1 Afternoon Exercises" msgstr "" #: src/exercises/day-1/solutions-afternoon.md:3 msgid "## Designing a Library" msgstr "" #: src/exercises/day-1/solutions-afternoon.md:5 msgid "([back to exercise](book-library.md))" msgstr "" #: src/exercises/day-1/solutions-afternoon.md:22 msgid "" "// ANCHOR: setup\n" "struct Library {\n" " books: Vec,\n" "}" msgstr "" #: src/exercises/day-1/solutions-afternoon.md:42 msgid "" "// This makes it possible to print Book values with {}.\n" "impl std::fmt::Display for Book {\n" " fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {\n" " write!(f, \"{} ({})\", self.title, self.year)\n" " }\n" "}\n" "// ANCHOR_END: setup" msgstr "" #: src/exercises/day-1/solutions-afternoon.md:50 msgid "" "// ANCHOR: Library_new\n" "impl Library {\n" " fn new() -> Library {\n" " // ANCHOR_END: Library_new\n" " Library { books: Vec::new() }\n" " }" msgstr "" #: src/exercises/day-1/solutions-afternoon.md:57 msgid "" " // ANCHOR: Library_len\n" " //fn len(self) -> usize {\n" " // unimplemented!()\n" " //}\n" " // ANCHOR_END: Library_len\n" " fn len(&self) -> usize {\n" " self.books.len()\n" " }" msgstr "" #: src/exercises/day-1/solutions-afternoon.md:66 msgid "" " // ANCHOR: Library_is_empty\n" " //fn is_empty(self) -> bool {\n" " // unimplemented!()\n" " //}\n" " // ANCHOR_END: Library_is_empty\n" " fn is_empty(&self) -> bool {\n" " self.books.is_empty()\n" " }" msgstr "" #: src/exercises/day-1/solutions-afternoon.md:75 msgid "" " // ANCHOR: Library_add_book\n" " //fn add_book(self, book: Book) {\n" " // unimplemented!()\n" " //}\n" " // ANCHOR_END: Library_add_book\n" " fn add_book(&mut self, book: Book) {\n" " self.books.push(book)\n" " }" msgstr "" #: src/exercises/day-1/solutions-afternoon.md:84 msgid "" " // ANCHOR: Library_print_books\n" " //fn print_books(self) {\n" " // unimplemented!()\n" " //}\n" " // ANCHOR_END: Library_print_books\n" " fn print_books(&self) {\n" " for book in &self.books {\n" " println!(\"{}\", book);\n" " }\n" " }" msgstr "" #: src/exercises/day-1/solutions-afternoon.md:95 msgid "" " // ANCHOR: Library_oldest_book\n" " //fn oldest_book(self) -> Option<&Book> {\n" " // unimplemented!()\n" " //}\n" " // ANCHOR_END: Library_oldest_book\n" " fn oldest_book(&self) -> Option<&Book> {\n" " self.books.iter().min_by_key(|book| book.year)\n" " }\n" "}" msgstr "" #: src/exercises/day-1/solutions-afternoon.md:105 msgid "" "// ANCHOR: main\n" "// This shows the desired behavior. Uncomment the code below and\n" "// implement the missing methods. You will need to update the\n" "// method signatures, including the \"self\" parameter! You may\n" "// also need to update the variable bindings within main.\n" "fn main() {\n" " let library = Library::new();" msgstr "" #: src/exercises/day-1/solutions-afternoon.md:113 msgid "" " //println!(\"Our library is empty: {}\", library.is_empty());\n" " //\n" " //library.add_book(Book::new(\"Lord of the Rings\", 1954));\n" " //library.add_book(Book::new(\"Alice's Adventures in Wonderland\", " "1865));\n" " //\n" " //library.print_books();\n" " //\n" " //match library.oldest_book() {\n" " // Some(book) => println!(\"My oldest book is {book}\"),\n" " // None => println!(\"My library is empty!\"),\n" " //}\n" " //\n" " //println!(\"Our library has {} books\", library.len());\n" "}\n" "// ANCHOR_END: main" msgstr "" #: src/exercises/day-1/solutions-afternoon.md:129 msgid "" "#[test]\n" "fn test_library_len() {\n" " let mut library = Library::new();\n" " assert_eq!(library.len(), 0);\n" " assert!(library.is_empty());" msgstr "" #: src/exercises/day-1/solutions-afternoon.md:135 msgid "" " library.add_book(Book::new(\"Lord of the Rings\", 1954));\n" " library.add_book(Book::new(\"Alice's Adventures in Wonderland\", " "1865));\n" " assert_eq!(library.len(), 2);\n" " assert!(!library.is_empty());\n" "}" msgstr "" #: src/exercises/day-1/solutions-afternoon.md:141 msgid "" "#[test]\n" "fn test_library_is_empty() {\n" " let mut library = Library::new();\n" " assert!(library.is_empty());" msgstr "" #: src/exercises/day-1/solutions-afternoon.md:146 msgid "" " library.add_book(Book::new(\"Lord of the Rings\", 1954));\n" " assert!(!library.is_empty());\n" "}" msgstr "" #: src/exercises/day-1/solutions-afternoon.md:150 msgid "" "#[test]\n" "fn test_library_print_books() {\n" " let mut library = Library::new();\n" " library.add_book(Book::new(\"Lord of the Rings\", 1954));\n" " library.add_book(Book::new(\"Alice's Adventures in Wonderland\", " "1865));\n" " // We could try and capture stdout, but let us just call the\n" " // method to start with.\n" " library.print_books();\n" "}" msgstr "" #: src/exercises/day-1/solutions-afternoon.md:160 msgid "" "#[test]\n" "fn test_library_oldest_book() {\n" " let mut library = Library::new();\n" " assert!(library.oldest_book().is_none());" msgstr "" #: src/exercises/day-1/solutions-afternoon.md:165 msgid "" " library.add_book(Book::new(\"Lord of the Rings\", 1954));\n" " assert_eq!(\n" " library.oldest_book().map(|b| b.title.as_str()),\n" " Some(\"Lord of the Rings\")\n" " );" msgstr "" #: src/exercises/day-1/solutions-afternoon.md:171 msgid "" " library.add_book(Book::new(\"Alice's Adventures in Wonderland\", " "1865));\n" " assert_eq!(\n" " library.oldest_book().map(|b| b.title.as_str()),\n" " Some(\"Alice's Adventures in Wonderland\")\n" " );\n" "}\n" "```" msgstr "" #: src/exercises/day-2/solutions-morning.md:1 msgid "# Day 2 Morning Exercises" msgstr "" #: src/exercises/day-2/solutions-morning.md:3 msgid "## Points and Polygons" msgstr "" #: src/exercises/day-2/solutions-morning.md:5 msgid "([back to exercise](points-polygons.md))" msgstr "" #: src/exercises/day-2/solutions-morning.md:22 msgid "" "#[derive(Debug, Copy, Clone, PartialEq, Eq)]\n" "// ANCHOR: Point\n" "pub struct Point {\n" " // ANCHOR_END: Point\n" " x: i32,\n" " y: i32,\n" "}" msgstr "" #: src/exercises/day-2/solutions-morning.md:30 msgid "" "// ANCHOR: Point-impl\n" "impl Point {\n" " // ANCHOR_END: Point-impl\n" " pub fn new(x: i32, y: i32) -> Point {\n" " Point { x, y }\n" " }" msgstr "" #: src/exercises/day-2/solutions-morning.md:37 msgid "" " pub fn magnitude(self) -> f64 {\n" " f64::from(self.x.pow(2) + self.y.pow(2)).sqrt()\n" " }" msgstr "" #: src/exercises/day-2/solutions-morning.md:41 msgid "" " pub fn dist(self, other: Point) -> f64 {\n" " (self - other).magnitude()\n" " }\n" "}" msgstr "" #: src/exercises/day-2/solutions-morning.md:49 msgid "" " fn add(self, other: Self) -> Self::Output {\n" " Self {\n" " x: self.x + other.x,\n" " y: self.y + other.y,\n" " }\n" " }\n" "}" msgstr "" #: src/exercises/day-2/solutions-morning.md:57 msgid "" "impl std::ops::Sub for Point {\n" " type Output = Self;" msgstr "" #: src/exercises/day-2/solutions-morning.md:60 msgid "" " fn sub(self, other: Self) -> Self::Output {\n" " Self {\n" " x: self.x - other.x,\n" " y: self.y - other.y,\n" " }\n" " }\n" "}" msgstr "" #: src/exercises/day-2/solutions-morning.md:68 msgid "" "// ANCHOR: Polygon\n" "pub struct Polygon {\n" " // ANCHOR_END: Polygon\n" " points: Vec,\n" "}" msgstr "" #: src/exercises/day-2/solutions-morning.md:74 msgid "" "// ANCHOR: Polygon-impl\n" "impl Polygon {\n" " // ANCHOR_END: Polygon-impl\n" " pub fn new() -> Polygon {\n" " Polygon { points: Vec::new() }\n" " }" msgstr "" #: src/exercises/day-2/solutions-morning.md:81 msgid "" " pub fn add_point(&mut self, point: Point) {\n" " self.points.push(point);\n" " }" msgstr "" #: src/exercises/day-2/solutions-morning.md:85 msgid "" " pub fn left_most_point(&self) -> Option {\n" " self.points.iter().min_by_key(|p| p.x).copied()\n" " }" msgstr "" #: src/exercises/day-2/solutions-morning.md:89 msgid "" " pub fn iter(&self) -> impl Iterator {\n" " self.points.iter()\n" " }" msgstr "" #: src/exercises/day-2/solutions-morning.md:93 msgid "" " pub fn length(&self) -> f64 {\n" " if self.points.is_empty() {\n" " return 0.0;\n" " }" msgstr "" #: src/exercises/day-2/solutions-morning.md:98 msgid "" " let mut result = 0.0;\n" " let mut last_point = self.points[0];\n" " for point in &self.points[1..] {\n" " result += last_point.dist(*point);\n" " last_point = *point;\n" " }\n" " result += last_point.dist(self.points[0]);\n" " result\n" " }\n" "}" msgstr "" #: src/exercises/day-2/solutions-morning.md:109 msgid "" "// ANCHOR: Circle\n" "pub struct Circle {\n" " // ANCHOR_END: Circle\n" " center: Point,\n" " radius: i32,\n" "}" msgstr "" #: src/exercises/day-2/solutions-morning.md:116 msgid "" "// ANCHOR: Circle-impl\n" "impl Circle {\n" " // ANCHOR_END: Circle-impl\n" " pub fn new(center: Point, radius: i32) -> Circle {\n" " Circle { center, radius }\n" " }" msgstr "" #: src/exercises/day-2/solutions-morning.md:123 msgid "" " pub fn circumference(&self) -> f64 {\n" " 2.0 * std::f64::consts::PI * f64::from(self.radius)\n" " }" msgstr "" #: src/exercises/day-2/solutions-morning.md:127 msgid "" " pub fn dist(&self, other: &Self) -> f64 {\n" " self.center.dist(other.center)\n" " }\n" "}" msgstr "" #: src/exercises/day-2/solutions-morning.md:132 msgid "" "// ANCHOR: Shape\n" "pub enum Shape {\n" " Polygon(Polygon),\n" " Circle(Circle),\n" "}\n" "// ANCHOR_END: Shape" msgstr "" #: src/exercises/day-2/solutions-morning.md:139 msgid "" "impl From for Shape {\n" " fn from(poly: Polygon) -> Self {\n" " Shape::Polygon(poly)\n" " }\n" "}" msgstr "" #: src/exercises/day-2/solutions-morning.md:145 msgid "" "impl From for Shape {\n" " fn from(circle: Circle) -> Self {\n" " Shape::Circle(circle)\n" " }\n" "}" msgstr "" #: src/exercises/day-2/solutions-morning.md:151 msgid "" "impl Shape {\n" " pub fn circumference(&self) -> f64 {\n" " match self {\n" " Shape::Polygon(poly) => poly.length(),\n" " Shape::Circle(circle) => circle.circumference(),\n" " }\n" " }\n" "}" msgstr "" #: src/exercises/day-2/solutions-morning.md:160 msgid "" "// ANCHOR: unit-tests\n" "#[cfg(test)]\n" "mod tests {\n" " use super::*;" msgstr "" #: src/exercises/day-2/solutions-morning.md:213 msgid "" " #[test]\n" " fn test_shape_circumferences() {\n" " let mut poly = Polygon::new();\n" " poly.add_point(Point::new(12, 13));\n" " poly.add_point(Point::new(17, 11));\n" " poly.add_point(Point::new(16, 16));\n" " let shapes = vec![\n" " Shape::from(poly),\n" " Shape::from(Circle::new(Point::new(10, 20), 5)),\n" " ];\n" " let circumferences = shapes\n" " .iter()\n" " .map(Shape::circumference)\n" " .map(round_two_digits)\n" " .collect::>();\n" " assert_eq!(circumferences, vec![15.48, 31.42]);\n" " }\n" "}\n" "// ANCHOR_END: unit-tests" msgstr "" #: src/exercises/day-2/solutions-afternoon.md:1 msgid "# Day 2 Afternoon Exercises" msgstr "" #: src/exercises/day-2/solutions-afternoon.md:3 msgid "## Luhn Algorithm" msgstr "" #: src/exercises/day-2/solutions-afternoon.md:5 msgid "([back to exercise](luhn.md))" msgstr "" #: src/exercises/day-2/solutions-afternoon.md:22 msgid "" "// ANCHOR: luhn\n" "pub fn luhn(cc_number: &str) -> bool {\n" " // ANCHOR_END: luhn\n" " let mut digits_seen = 0;\n" " let mut sum = 0;\n" " for (i, ch) in cc_number.chars().rev().filter(|&ch| ch != ' ')." "enumerate() {\n" " match ch.to_digit(10) {\n" " Some(d) => {\n" " sum += if i % 2 == 1 {\n" " let dd = d * 2;\n" " dd / 10 + dd % 10\n" " } else {\n" " d\n" " };\n" " digits_seen += 1;\n" " }\n" " None => return false,\n" " }\n" " }" msgstr "" #: src/exercises/day-2/solutions-afternoon.md:42 msgid "" " if digits_seen < 2 {\n" " return false;\n" " }" msgstr "" #: src/exercises/day-2/solutions-afternoon.md:46 msgid "" " sum % 10 == 0\n" "}" msgstr "" #: src/exercises/day-2/solutions-afternoon.md:49 msgid "" "fn main() {\n" " let cc_number = \"1234 5678 1234 5670\";\n" " println!(\n" " \"Is {} a valid credit card number? {}\",\n" " cc_number,\n" " if luhn(cc_number) { \"yes\" } else { \"no\" }\n" " );\n" "}" msgstr "" #: src/exercises/day-2/solutions-afternoon.md:58 msgid "" "// ANCHOR: unit-tests\n" "#[test]\n" "fn test_non_digit_cc_number() {\n" " assert!(!luhn(\"foo\"));\n" "}" msgstr "" #: src/exercises/day-2/solutions-afternoon.md:89 msgid "" "#[test]\n" "fn test_invalid_cc_number() {\n" " assert!(!luhn(\"4223 9826 4026 9299\"));\n" " assert!(!luhn(\"4539 3195 0343 6476\"));\n" " assert!(!luhn(\"8273 1232 7352 0569\"));\n" "}\n" "// ANCHOR_END: unit-tests\n" "```" msgstr "" #: src/exercises/day-2/solutions-afternoon.md:98 msgid "## Strings and Iterators" msgstr "" #: src/exercises/day-2/solutions-afternoon.md:100 msgid "([back to exercise](strings-iterators.md))" msgstr "" #: src/exercises/day-2/solutions-afternoon.md:117 msgid "" "// ANCHOR: prefix_matches\n" "pub fn prefix_matches(prefix: &str, request_path: &str) -> bool {\n" " // ANCHOR_END: prefix_matches\n" " let prefixes = prefix.split('/');\n" " let request_paths = request_path\n" " .split('/')\n" " .map(|p| Some(p))\n" " .chain(std::iter::once(None));" msgstr "" #: src/exercises/day-2/solutions-afternoon.md:126 msgid "" " for (prefix, request_path) in prefixes.zip(request_paths) {\n" " match request_path {\n" " Some(request_path) => {\n" " if (prefix != \"*\") && (prefix != request_path) {\n" " return false;\n" " }\n" " }\n" " None => return false,\n" " }\n" " }\n" " true\n" "}" msgstr "" #: src/exercises/day-2/solutions-afternoon.md:139 msgid "" "// ANCHOR: unit-tests\n" "#[test]\n" "fn test_matches_without_wildcard() {\n" " assert!(prefix_matches(\"/v1/publishers\", \"/v1/publishers\"));\n" " assert!(prefix_matches(\"/v1/publishers\", \"/v1/publishers/" "abc-123\"));\n" " assert!(prefix_matches(\"/v1/publishers\", \"/v1/publishers/abc/" "books\"));" msgstr "" #: src/exercises/day-2/solutions-afternoon.md:166 msgid "" " assert!(!prefix_matches(\"/v1/publishers/*/books\", \"/v1/" "publishers\"));\n" " assert!(!prefix_matches(\n" " \"/v1/publishers/*/books\",\n" " \"/v1/publishers/foo/booksByAuthor\"\n" " ));\n" "}\n" "// ANCHOR_END: unit-tests\n" "```" msgstr "" #: src/exercises/day-3/solutions-morning.md:1 msgid "# Day 3 Morning Exercise" msgstr "" #: src/exercises/day-3/solutions-morning.md:3 msgid "## A Simple GUI Library" msgstr "" #: src/exercises/day-3/solutions-morning.md:5 msgid "([back to exercise](simple-gui.md))" msgstr "" #: src/exercises/day-3/solutions-morning.md:22 msgid "" "// ANCHOR: setup\n" "pub trait Widget {\n" " /// Natural width of `self`.\n" " fn width(&self) -> usize;" msgstr "" #: src/exercises/day-3/solutions-morning.md:82 msgid "// ANCHOR_END: setup" msgstr "" #: src/exercises/day-3/solutions-morning.md:84 msgid "" "// ANCHOR: Window-width\n" "impl Widget for Window {\n" " fn width(&self) -> usize {\n" " // ANCHOR_END: Window-width\n" " std::cmp::max(\n" " self.title.chars().count(),\n" " self.widgets.iter().map(|w| w.width()).max().unwrap_or(0),\n" " )\n" " }" msgstr "" #: src/exercises/day-3/solutions-morning.md:94 msgid "" " // ANCHOR: Window-draw_into\n" " fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {\n" " // ANCHOR_END: Window-draw_into\n" " let mut inner = String::new();\n" " for widget in &self.widgets {\n" " widget.draw_into(&mut inner);\n" " }" msgstr "" #: src/exercises/day-3/solutions-morning.md:102 msgid " let window_width = self.width();" msgstr "" #: src/exercises/day-3/solutions-morning.md:104 msgid "" " // TODO: after learning about error handling, you can change\n" " // draw_into to return Result<(), std::fmt::Error>. Then use\n" " // the ?-operator here instead of .unwrap().\n" " writeln!(buffer, \"+-{:- usize {\n" " // ANCHOR_END: Button-width\n" " self.label.width() + 8 // add a bit of padding\n" " }" msgstr "" #: src/exercises/day-3/solutions-morning.md:124 msgid "" " // ANCHOR: Button-draw_into\n" " fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {\n" " // ANCHOR_END: Button-draw_into\n" " let width = self.width();\n" " let mut label = String::new();\n" " self.label.draw_into(&mut label);" msgstr "" #: src/exercises/day-3/solutions-morning.md:131 msgid "" " writeln!(buffer, \"+{:- usize {\n" " // ANCHOR_END: Label-width\n" " self.label\n" " .lines()\n" " .map(|line| line.chars().count())\n" " .max()\n" " .unwrap_or(0)\n" " }" msgstr "" #: src/exercises/day-3/solutions-morning.md:150 msgid "" " // ANCHOR: Label-draw_into\n" " fn draw_into(&self, buffer: &mut dyn std::fmt::Write) {\n" " // ANCHOR_END: Label-draw_into\n" " writeln!(buffer, \"{}\", &self.label).unwrap();\n" " }\n" "}" msgstr "" #: src/exercises/day-3/solutions-morning.md:157 msgid "" "// ANCHOR: main\n" "fn main() {\n" " let mut window = Window::new(\"Rust GUI Demo 1.23\");\n" " window.add_widget(Box::new(Label::new(\"This is a small text GUI demo." "\")));\n" " window.add_widget(Box::new(Button::new(\n" " \"Click me!\",\n" " Box::new(|| println!(\"You clicked the button!\")),\n" " )));\n" " window.draw();\n" "}\n" "// ANCHOR_END: main\n" "```" msgstr "" #: src/exercises/day-3/solutions-afternoon.md:1 msgid "# Day 3 Afternoon Exercises" msgstr "" #: src/exercises/day-3/solutions-afternoon.md:3 msgid "## Safe FFI Wrapper" msgstr "" #: src/exercises/day-3/solutions-afternoon.md:5 msgid "([back to exercise](safe-ffi-wrapper.md))" msgstr "" #: src/exercises/day-3/solutions-afternoon.md:22 msgid "" "// ANCHOR: ffi\n" "mod ffi {\n" " use std::os::raw::{c_char, c_int, c_long, c_ulong, c_ushort};" msgstr "" #: src/exercises/day-3/solutions-afternoon.md:53 msgid "" "#[derive(Debug)]\n" "struct DirectoryIterator {\n" " path: CString,\n" " dir: *mut ffi::DIR,\n" "}\n" "// ANCHOR_END: ffi" msgstr "" #: src/exercises/day-3/solutions-afternoon.md:60 msgid "" "// ANCHOR: DirectoryIterator\n" "impl DirectoryIterator {\n" " fn new(path: &str) -> Result {\n" " // Call opendir and return a Ok value if that worked,\n" " // otherwise return Err with a message.\n" " // ANCHOR_END: DirectoryIterator\n" " let path = CString::new(path).map_err(|err| format!(\"Invalid path: " "{err}\"))?;\n" " // SAFETY: path.as_ptr() cannot be NULL.\n" " let dir = unsafe { ffi::opendir(path.as_ptr()) };\n" " if dir.is_null() {\n" " Err(format!(\"Could not open {:?}\", path))\n" " } else {\n" " Ok(DirectoryIterator { path, dir })\n" " }\n" " }\n" "}" msgstr "" #: src/exercises/day-3/solutions-afternoon.md:77 msgid "" "// ANCHOR: Iterator\n" "impl Iterator for DirectoryIterator {\n" " type Item = OsString;\n" " fn next(&mut self) -> Option {\n" " // Keep calling readdir until we get a NULL pointer back.\n" " // ANCHOR_END: Iterator\n" " // SAFETY: self.dir is never NULL.\n" " let dirent = unsafe { ffi::readdir(self.dir) };\n" " if dirent.is_null() {\n" " // We have reached the end of the directory.\n" " return None;\n" " }\n" " // SAFETY: dirent is not NULL and dirent.d_name is NUL\n" " // terminated.\n" " let d_name = unsafe { CStr::from_ptr((*dirent).d_name.as_ptr()) };\n" " let os_str = OsStr::from_bytes(d_name.to_bytes());\n" " Some(os_str.to_owned())\n" " }\n" "}" msgstr "" #: src/exercises/day-3/solutions-afternoon.md:97 msgid "" "// ANCHOR: Drop\n" "impl Drop for DirectoryIterator {\n" " fn drop(&mut self) {\n" " // Call closedir as needed.\n" " // ANCHOR_END: Drop\n" " if !self.dir.is_null() {\n" " // SAFETY: self.dir is not NULL.\n" " if unsafe { ffi::closedir(self.dir) } != 0 {\n" " panic!(\"Could not close {:?}\", self.path);\n" " }\n" " }\n" " }\n" "}" msgstr "" #: src/exercises/day-3/solutions-afternoon.md:111 msgid "" "// ANCHOR: main\n" "fn main() -> Result<(), String> {\n" " let iter = DirectoryIterator::new(\".\")?;\n" " println!(\"files: {:#?}\", iter.collect::>());\n" " Ok(())\n" "}\n" "// ANCHOR_END: main\n" "```" msgstr "" #: src/exercises/day-4/solutions-morning.md:1 msgid "# Day 4 Morning Exercise" msgstr "" #: src/exercises/day-4/solutions-morning.md:3 msgid "## Dining Philosophers" msgstr "" #: src/exercises/day-4/solutions-morning.md:5 msgid "([back to exercise](dining-philosophers.md))" msgstr "" #: src/exercises/day-4/solutions-morning.md:22 msgid "" "// ANCHOR: Philosopher\n" "use std::sync::mpsc;\n" "use std::sync::{Arc, Mutex};\n" "use std::thread;\n" "use std::time::Duration;" msgstr "" #: src/exercises/day-4/solutions-morning.md:30 msgid "" "struct Philosopher {\n" " name: String,\n" " // ANCHOR_END: Philosopher\n" " left_fork: Arc>,\n" " right_fork: Arc>,\n" " thoughts: mpsc::SyncSender,\n" "}" msgstr "" #: src/exercises/day-4/solutions-morning.md:38 msgid "" "// ANCHOR: Philosopher-think\n" "impl Philosopher {\n" " fn think(&self) {\n" " self.thoughts\n" " .send(format!(\"Eureka! {} has a new idea!\", &self.name))\n" " .unwrap();\n" " }\n" " // ANCHOR_END: Philosopher-think" msgstr "" #: src/exercises/day-4/solutions-morning.md:47 msgid "" " // ANCHOR: Philosopher-eat\n" " fn eat(&self) {\n" " // ANCHOR_END: Philosopher-eat\n" " println!(\"{} is trying to eat\", &self.name);\n" " let left = self.left_fork.lock().unwrap();\n" " let right = self.right_fork.lock().unwrap();" msgstr "" #: src/exercises/day-4/solutions-morning.md:54 msgid "" " // ANCHOR: Philosopher-eat-end\n" " println!(\"{} is eating...\", &self.name);\n" " thread::sleep(Duration::from_millis(10));\n" " }\n" "}" msgstr "" #: src/exercises/day-4/solutions-morning.md:63 msgid "" "fn main() {\n" " // ANCHOR_END: Philosopher-eat-end\n" " let (tx, rx) = mpsc::sync_channel(10);" msgstr "" #: src/exercises/day-4/solutions-morning.md:67 msgid "" " let forks = (0..PHILOSOPHERS.len())\n" " .map(|_| Arc::new(Mutex::new(Fork)))\n" " .collect::>();" msgstr "" #: src/exercises/day-4/solutions-morning.md:71 msgid "" " for i in 0..forks.len() {\n" " let tx = tx.clone();\n" " let mut left_fork = forks[i].clone();\n" " let mut right_fork = forks[(i + 1) % forks.len()].clone();" msgstr "" #: src/exercises/day-4/solutions-morning.md:76 msgid "" " // To avoid a deadlock, we have to break the symmetry\n" " // somewhere. This will swap the forks without deinitializing\n" " // either of them.\n" " if i == forks.len() - 1 {\n" " std::mem::swap(&mut left_fork, &mut right_fork);\n" " }" msgstr "" #: src/exercises/day-4/solutions-morning.md:83 msgid "" " let philosopher = Philosopher {\n" " name: PHILOSOPHERS[i].to_string(),\n" " thoughts: tx,\n" " left_fork,\n" " right_fork,\n" " };" msgstr "" #: src/exercises/day-4/solutions-morning.md:90 msgid "" " thread::spawn(move || {\n" " for _ in 0..100 {\n" " philosopher.eat();\n" " philosopher.think();\n" " }\n" " });\n" " }" msgstr "" #: src/exercises/day-4/solutions-morning.md:98 msgid "" " drop(tx);\n" " for thought in rx {\n" " println!(\"{}\", thought);\n" " }\n" "}\n" "```" msgstr ""