diff --git a/po/de.po b/po/de.po
index ed3dd854..48f21a6a 100644
--- a/po/de.po
+++ b/po/de.po
@@ -425,81 +425,82 @@ msgid "Day 3: Morning"
msgstr "Tag 3: Morgens"
#: src/SUMMARY.md:130
+msgid "Generics"
+msgstr "Generische Datentypen und Methoden"
+
+#: src/SUMMARY.md:131
+msgid "Generic Data Types"
+msgstr "Generische Datentypen"
+
+#: src/SUMMARY.md:132
+msgid "Generic Methods"
+msgstr "Generische Methoden"
+
+#: src/SUMMARY.md:133
+msgid "Monomorphization"
+msgstr "Monomorphisierung"
+
+#: src/SUMMARY.md:134
msgid "Traits"
msgstr "Merkmale"
-#: src/SUMMARY.md:131
+#: src/SUMMARY.md:135
+msgid "Trait Objects"
+msgstr "Merkmalsobjekte"
+
+#: src/SUMMARY.md:136
msgid "Deriving Traits"
msgstr "Ableitung von Merkmalen"
-#: src/SUMMARY.md:132
+#: src/SUMMARY.md:137
msgid "Default Methods"
msgstr "Standardmethoden"
-#: src/SUMMARY.md:133
+#: src/SUMMARY.md:138
+msgid "Trait Bounds"
+msgstr "Merkmalsgrenzen"
+
+#: src/SUMMARY.md:139
+msgid "impl Trait"
+msgstr "impl Merkmal"
+
+#: src/SUMMARY.md:140
msgid "Important Traits"
msgstr "Wichtige Merkmale"
-#: src/SUMMARY.md:134
+#: src/SUMMARY.md:141
msgid "Iterator"
msgstr "Iterator"
-#: src/SUMMARY.md:135
+#: src/SUMMARY.md:142
msgid "FromIterator"
msgstr "FromIterator"
-#: src/SUMMARY.md:136
+#: src/SUMMARY.md:143
msgid "From and Into"
msgstr "From und Into"
-#: src/SUMMARY.md:137
+#: src/SUMMARY.md:144
msgid "Read and Write"
msgstr "Read und Write"
-#: src/SUMMARY.md:138
-msgid "Add, Mul, ..."
-msgstr "Add, Mul, ..."
-
-#: src/SUMMARY.md:139
+#: src/SUMMARY.md:145
msgid "Drop"
msgstr "Drop"
-#: src/SUMMARY.md:140
+#: src/SUMMARY.md:146
#, fuzzy
msgid "Default"
msgstr "Standardmethoden"
-#: src/SUMMARY.md:141
-msgid "Generics"
-msgstr "Generische Datentypen und Methoden"
-
-#: src/SUMMARY.md:142
-msgid "Generic Data Types"
-msgstr "Generische Datentypen"
-
-#: src/SUMMARY.md:143
-msgid "Generic Methods"
-msgstr "Generische Methoden"
-
-#: src/SUMMARY.md:144
-msgid "Trait Bounds"
-msgstr "Merkmalsgrenzen"
-
-#: src/SUMMARY.md:145
-msgid "impl Trait"
-msgstr "impl Merkmal"
-
-#: src/SUMMARY.md:146
-msgid "Closures"
-msgstr "Funktionsabschlüsse"
-
#: src/SUMMARY.md:147
-msgid "Monomorphization"
-msgstr "Monomorphisierung"
+#, fuzzy
+msgid "Operators: Add, Mul, ..."
+msgstr "Add, Mul, ..."
#: src/SUMMARY.md:148
-msgid "Trait Objects"
-msgstr "Merkmalsobjekte"
+msgid "Closures"
+msgstr "Funktionsabschlüsse"
#: src/SUMMARY.md:150
msgid "A Simple GUI Library"
@@ -1158,11 +1159,12 @@ msgstr ""
#: src/std/hashmap.md:36 src/std/box.md:32 src/std/box-recursive.md:31
#: src/std/rc.md:29 src/modules.md:26 src/modules/visibility.md:37
#: src/modules/filesystem.md:38 src/exercises/day-2/afternoon.md:5
-#: src/traits.md:41 src/traits/iterator.md:30 src/traits/from-iterator.md:15
-#: src/traits/from-into.md:27 src/traits/operators.md:24 src/traits/drop.md:32
-#: src/traits/default.md:38 src/generics/methods.md:23
-#: src/generics/trait-bounds.md:33 src/generics/impl-trait.md:21
-#: src/generics/closures.md:23 src/generics/trait-objects.md:88
+#: src/generics/data-types.md:19 src/generics/methods.md:23
+#: src/traits/trait-objects.md:70 src/traits/default-methods.md:30
+#: src/traits/trait-bounds.md:33 src/traits/impl-trait.md:21
+#: src/traits/iterator.md:30 src/traits/from-iterator.md:15
+#: src/traits/from-into.md:27 src/traits/drop.md:32 src/traits/default.md:38
+#: src/traits/operators.md:24 src/traits/closures.md:23
#: src/exercises/day-3/morning.md:5 src/error-handling/result.md:25
#: src/error-handling/try-operator.md:48
#: src/error-handling/converting-error-types-example.md:48
@@ -1260,11 +1262,12 @@ msgstr ""
#: src/std/hashmap.md:66 src/std/box.md:39 src/std/box-recursive.md:41
#: src/std/rc.md:69 src/modules.md:32 src/modules/visibility.md:48
#: src/modules/filesystem.md:67 src/exercises/day-2/afternoon.md:11
-#: src/traits.md:47 src/traits/iterator.md:42 src/traits/from-iterator.md:26
-#: src/traits/from-into.md:33 src/traits/operators.md:38 src/traits/drop.md:42
-#: src/traits/default.md:47 src/generics/methods.md:31
-#: src/generics/trait-bounds.md:50 src/generics/impl-trait.md:44
-#: src/generics/closures.md:38 src/generics/trait-objects.md:102
+#: src/generics/data-types.md:25 src/generics/methods.md:31
+#: src/traits/trait-objects.md:83 src/traits/default-methods.md:41
+#: src/traits/trait-bounds.md:50 src/traits/impl-trait.md:44
+#: src/traits/iterator.md:42 src/traits/from-iterator.md:26
+#: src/traits/from-into.md:33 src/traits/drop.md:42 src/traits/default.md:47
+#: src/traits/operators.md:38 src/traits/closures.md:38
#: src/exercises/day-3/morning.md:11 src/error-handling/result.md:33
#: src/error-handling/try-operator.md:55
#: src/error-handling/converting-error-types-example.md:60
@@ -8565,6 +8568,167 @@ msgid ""
" functions."
msgstr ""
+#: src/generics.md:1
+#, fuzzy
+msgid "# Generics"
+msgstr "# Generika"
+
+#: src/generics.md:3
+#, fuzzy
+msgid ""
+"Rust support generics, which lets you abstract an algorithm (such as "
+"sorting)\n"
+"over the types used in the algorithm."
+msgstr ""
+"Rust unterstützt Generika, mit denen Sie einen Algorithmus abstrahieren "
+"können (z. B. Sortieren)\n"
+"über die im Algorithmus verwendeten Typen."
+
+#: src/generics/data-types.md:1
+#, fuzzy
+msgid "# Generic Data Types"
+msgstr "# Generische Datentypen"
+
+#: src/generics/data-types.md:3
+#, fuzzy
+msgid "You can use generics to abstract over the concrete field type:"
+msgstr "Mit Generika können Sie über den konkreten Feldtyp abstrahieren:"
+
+#: src/generics/data-types.md:5
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Point<T> {\n"
+" x: T,\n"
+" y: T,\n"
+"}\n"
+"\n"
+"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/data-types.md:21
+msgid ""
+"* Try declaring a new variable `let p = Point { x: 5, y: 10.0 };`.\n"
+"\n"
+"* Fix the code to allow points that have elements of different types."
+msgstr ""
+
+#: src/generics/methods.md:1
+#, fuzzy
+msgid "# Generic Methods"
+msgstr "# Generische Methoden"
+
+#: src/generics/methods.md:3
+#, fuzzy
+msgid "You can declare a generic type on your `impl` block:"
+msgstr "Sie können einen generischen Typ in Ihrem `impl`-Block deklarieren:"
+
+#: src/generics/methods.md:5
+msgid ""
+"```rust,editable\n"
+"#[derive(Debug)]\n"
+"struct Point<T>(T, T);\n"
+"\n"
+"impl<T> Point<T> {\n"
+" fn x(&self) -> &T {\n"
+" &self.0 // + 10\n"
+" }\n"
+"\n"
+" // fn set_x(&mut self, x: T)\n"
+"}\n"
+"\n"
+"fn main() {\n"
+" let p = Point(5, 10);\n"
+" println!(\"p.x = {}\", p.x());\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/generics/methods.md:25
+#, fuzzy
+msgid ""
+"* *Q:* Why `T` is specified twice in `impl<T> Point<T> {}`? Isn't that "
+"redundant?\n"
+" * This is because it is a generic implementation section for generic "
+"type. They are independently generic.\n"
+" * It means these methods are defined for any `T`.\n"
+" * It is possible to write `impl Point<u32> { .. }`. \n"
+" * `Point` is still generic and you can use `Point<f64>`, but methods "
+"in this block will only be available for `Point<u32>`."
+msgstr ""
+"* *F:* Warum wird `T` zweimal in `impl<T> Point<T> {}` angegeben? Ist das "
+"nicht überflüssig?\n"
+" * Dies liegt daran, dass es sich um einen generischen "
+"Implementierungsabschnitt für einen generischen Typ handelt. Sie sind "
+"unabhängig generisch.\n"
+" * Dies bedeutet, dass diese Methoden für jedes `T` definiert sind.\n"
+" * Es ist möglich `impl Point<u32> { .. }` zu schreiben.\n"
+" * „Point“ ist immer noch generisch und Sie können „Point<f64>“ "
+"verwenden, aber Methoden in diesem Block sind nur für „Point<u32>“ verfügbar."
+
+#: src/generics/monomorphization.md:1
+#, fuzzy
+msgid "# Monomorphization"
+msgstr "# Monomorphisierung"
+
+#: src/generics/monomorphization.md:3
+#, fuzzy
+msgid "Generic code is turned into non-generic code based on the call sites:"
+msgstr ""
+"Basierend auf den Aufrufseiten wird generischer Code in nicht generischen "
+"Code umgewandelt:"
+
+#: 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
+#, fuzzy
+msgid "behaves as if you wrote"
+msgstr "verhält sich so, als hättest du geschrieben"
+
+#: src/generics/monomorphization.md:14
+msgid ""
+"```rust,editable\n"
+"enum Option_i32 {\n"
+" Some(i32),\n"
+" None,\n"
+"}\n"
+"\n"
+"enum Option_f64 {\n"
+" Some(f64),\n"
+" None,\n"
+"}\n"
+"\n"
+"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
+#, fuzzy
+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 ""
+"Dies ist eine Null-Kosten-Abstraktion: Sie erhalten genau das gleiche "
+"Ergebnis, als ob Sie es hätten\n"
+"die Datenstrukturen ohne die Abstraktion von Hand codiert."
+
#: src/traits.md:1
#, fuzzy
msgid "# Traits"
@@ -8604,7 +8768,7 @@ msgid ""
" }\n"
"}\n"
"\n"
-"fn greet(pet: &impl Pet) {\n"
+"fn greet<P: Pet>(pet: &P) {\n"
" println!(\"Who's a cutie? {} is!\", pet.name());\n"
"}\n"
"\n"
@@ -8618,15 +8782,146 @@ msgid ""
"```"
msgstr ""
-#: src/traits.md:43
+#: src/traits/trait-objects.md:1
+#, fuzzy
+msgid "# Trait Objects"
+msgstr "# Eigenschaftsobjekte"
+
+#: src/traits/trait-objects.md:3
msgid ""
-"* Later sections will get into more detail on generic functions like "
-"`greet`.\n"
-" For now, students only need to know that `greet` will operate on a "
-"reference\n"
-" to anything that implements `Pet`."
+"Trait objects allow for values of different types, for instance in a "
+"collection:"
msgstr ""
+#: src/traits/trait-objects.md:5
+msgid ""
+"```rust\n"
+"trait Pet {\n"
+" fn name(&self) -> String;\n"
+"}\n"
+"\n"
+"struct Dog {\n"
+" name: String,\n"
+"}\n"
+"\n"
+"struct Cat;\n"
+"\n"
+"impl Pet for Dog {\n"
+" fn name(&self) -> String {\n"
+" self.name.clone()\n"
+" }\n"
+"}\n"
+"\n"
+"impl Pet for Cat {\n"
+" fn name(&self) -> String {\n"
+" String::from(\"The cat\") // No name, cats won't respond to it "
+"anyway.\n"
+" }\n"
+"}\n"
+"\n"
+"fn main() {\n"
+" let pets: Vec<Box<dyn Pet>> = vec![\n"
+" Box::new(Dog { name: String::from(\"Fido\") }),\n"
+" Box::new(Cat),\n"
+" ];\n"
+" for pet in pets {\n"
+" println!(\"Hello {}!\", pet.name());\n"
+" }\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/trait-objects.md:40
+#, fuzzy
+msgid "Memory layout after allocating `pets`:"
+msgstr "Speicherlayout nach Zuweisung von `xs`:"
+
+#: src/traits/trait-objects.md:42
+msgid ""
+"```bob\n"
+" Stack Heap\n"
+".- - - - - - - - - - - - - -. .- - - - - - - - - - - - - - - - - - - - - "
+"- -.\n"
+": : : :\n"
+": "
+"pets : : :\n"
+": +-----------+-------+ : : +-----+-----"
+"+ :\n"
+": | ptr | o---+---+-----+-->| o o | o o "
+"| :\n"
+": | len | 2 | : : +-|-|-+-|-|-"
+"+ :\n"
+": | capacity | 2 | : : | | | | +---------------"
+"+ :\n"
+": +-----------+-------+ : : | | | '-->| name: \"Fido\" "
+"| :\n"
+": : : | | | +---------------"
+"+ :\n"
+"`- - - - - - - - - - - - - -' : | | "
+"| :\n"
+" : | | | +----------------------"
+"+ : \n"
+" : | | '---->| \"<Dog as Pet>::name\" "
+"| :\n"
+" : | | +----------------------"
+"+ : \n"
+" : | "
+"| : \n"
+" : | | +-"
+"+ : \n"
+" : | '-->|"
+"\\| : \n"
+" : | +-"
+"+ : \n"
+" : "
+"| : \n"
+" : | +----------------------"
+"+ : \n"
+" : '---->| \"<Cat as Pet>::name\" "
+"| : \n"
+" : +----------------------"
+"+ :\n"
+" : :\n"
+" '- - - - - - - - - - - - - - - - - - - - - "
+"- -'\n"
+"\n"
+"```"
+msgstr ""
+
+#: src/traits/trait-objects.md:72
+#, fuzzy
+msgid ""
+"* Types that implement a given trait may be of different sizes. This makes "
+"it impossible to have things like `Vec<Pet>` in the example above.\n"
+"* `dyn Pet` is a way to tell the compiler about a dynamically sized type "
+"that implements `Pet`.\n"
+"* In the example, `pets` holds *fat pointers* to objects that implement "
+"`Pet`. The fat pointer consists of two components, a pointer to the actual "
+"object and a pointer to the virtual method table for the `Pet` "
+"implementation of that particular object.\n"
+"* Compare these outputs in the above example:\n"
+" ```rust,ignore\n"
+" println!(\"{} {}\", std::mem::size_of::<Dog>(), std::mem::size_of::"
+"<Cat>());\n"
+" println!(\"{} {}\", std::mem::size_of::<&Dog>(), std::mem::size_of::"
+"<&Cat>());\n"
+" println!(\"{}\", std::mem::size_of::<&dyn Pet>());\n"
+" println!(\"{}\", std::mem::size_of::<Box<dyn Pet>>());\n"
+" ```"
+msgstr ""
+"* Merkmale können vorimplementierte (Standard-)Methoden und Methoden "
+"spezifizieren, die Benutzer selbst implementieren müssen. Methoden mit "
+"Standardimplementierungen können sich auf erforderliche Methoden stützen.\n"
+"* Typen, die ein bestimmtes Merkmal implementieren, können unterschiedlich "
+"groß sein. Das macht es unmöglich Dinge wie `Vec<Greet>` im obigen Beispiel "
+"zu haben.\n"
+"* „dyn Greet“ ist eine Möglichkeit, dem Compiler einen Typ mit dynamischer "
+"Größe mitzuteilen, der „Greet“ implementiert.\n"
+"* Im Beispiel enthält `pets` Fat Pointer auf Objekte, die `Greet` "
+"implementieren. Der Fat Pointer besteht aus zwei Komponenten, einem Zeiger "
+"auf das tatsächliche Objekt und einem Zeiger auf die virtuelle "
+"Methodentabelle für die \"Greet\"-Implementierung dieses bestimmten Objekts."
+
#: src/traits/deriving-traits.md:1
#, fuzzy
msgid "# Deriving Traits"
@@ -8695,6 +8990,207 @@ msgid ""
"```"
msgstr ""
+#: src/traits/default-methods.md:32
+msgid ""
+"* Traits may specify pre-implemented (default) methods and methods that "
+"users are required to\n"
+" implement themselves. Methods with default implementations can rely on "
+"required methods.\n"
+"\n"
+"* Move method `not_equal` to a new trait `NotEqual`.\n"
+"\n"
+"* Make `NotEqual` a super trait for `Equal`.\n"
+"\n"
+"* Provide a blanket implementation of `NotEqual` for `Equal`.\n"
+" * With the blanket implementation, you no longer need `NotEqual` as a "
+"super trait for `Equal`."
+msgstr ""
+
+#: src/traits/trait-bounds.md:1
+#, fuzzy
+msgid "# Trait Bounds"
+msgstr "# Eigenschaftsgrenzen"
+
+#: src/traits/trait-bounds.md:3
+#, fuzzy
+msgid ""
+"When working with generics, you often want to require the types to "
+"implement\n"
+"some trait, so that you can call this trait's methods."
+msgstr ""
+"Wenn Sie mit Generika arbeiten, möchten Sie häufig die Typen einschränken. "
+"Du kannst das\n"
+"mit `T:Trait` oder `impl Trait`:"
+
+#: src/traits/trait-bounds.md:6
+msgid "You can do this with `T: Trait` or `impl Trait`:"
+msgstr ""
+
+#: src/traits/trait-bounds.md:8
+msgid ""
+"```rust,editable\n"
+"fn duplicate<T: Clone>(a: T) -> (T, T) {\n"
+" (a.clone(), a.clone())\n"
+"}\n"
+"\n"
+"// Syntactic sugar for:\n"
+"// fn add_42_millions<T: Into<i32>>(x: T) -> i32 {\n"
+"fn add_42_millions(x: impl Into<i32>) -> i32 {\n"
+" x.into() + 42_000_000\n"
+"}\n"
+"\n"
+"// struct NotClonable;\n"
+"\n"
+"fn main() {\n"
+" let foo = String::from(\"foo\");\n"
+" let pair = duplicate(foo);\n"
+" println!(\"{pair:?}\");\n"
+"\n"
+" let many = add_42_millions(42_i8);\n"
+" println!(\"{many}\");\n"
+" let many_more = add_42_millions(10_000_000);\n"
+" println!(\"{many_more}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/trait-bounds.md:35
+msgid "Show a `where` clause, students will encounter it when reading code."
+msgstr ""
+
+#: src/traits/trait-bounds.md:37
+msgid ""
+"```rust,ignore\n"
+"fn duplicate<T>(a: T) -> (T, T)\n"
+"where\n"
+" T: Clone,\n"
+"{\n"
+" (a.clone(), a.clone())\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/trait-bounds.md:46
+#, fuzzy
+msgid ""
+"* It declutters the function signature if you have many parameters.\n"
+"* It has additional features making it more powerful.\n"
+" * If someone asks, the extra feature is that the type on the left of \":"
+"\" can be arbitrary, like `Option<T>`.\n"
+" "
+msgstr ""
+"* Es entrümpelt die Funktionssignatur, wenn Sie viele Parameter haben.\n"
+"* Es hat zusätzliche Funktionen, die es leistungsfähiger machen.\n"
+" * Wenn jemand fragt, das zusätzliche Feature ist, dass der Typ links von "
+"\":\" beliebig sein kann, wie `Option<T>`.\n"
+" \n"
+"</Details>"
+
+#: src/traits/impl-trait.md:1
+#, fuzzy
+msgid "# `impl Trait`"
+msgstr "# `imple Merkmal`"
+
+#: src/traits/impl-trait.md:3
+#, fuzzy
+msgid ""
+"Similar to trait bounds, an `impl Trait` syntax can be used in function\n"
+"arguments and return values:"
+msgstr ""
+"Ähnlich wie Merkmalsgrenzen kann eine \"impl Trait\"-Syntax in Funktion "
+"verwendet werden\n"
+"Argumente und Rückgabewerte:"
+
+#: src/traits/impl-trait.md:6
+msgid ""
+"```rust,editable\n"
+"use std::fmt::Display;\n"
+"\n"
+"fn get_x(name: impl Display) -> impl Display {\n"
+" format!(\"Hello {name}\")\n"
+"}\n"
+"\n"
+"fn main() {\n"
+" let x = get_x(\"foo\");\n"
+" println!(\"{x}\");\n"
+"}\n"
+"```"
+msgstr ""
+
+#: src/traits/impl-trait.md:19
+#, fuzzy
+msgid "* `impl Trait` allows you to work with types which you cannot name."
+msgstr ""
+"* `impl Trait` kann nicht mit der `::<>` Turbofish-Syntax verwendet werden.\n"
+"* `impl Trait` ermöglicht es Ihnen, mit Typen zu arbeiten, die Sie nicht "
+"benennen können."
+
+#: src/traits/impl-trait.md:23
+#, fuzzy
+msgid ""
+"The meaning of `impl Trait` is a bit different in the different positions."
+msgstr ""
+"Die Bedeutung von „impl Trait“ ist in den verschiedenen Positionen etwas "
+"unterschiedlich."
+
+#: src/traits/impl-trait.md:25
+#, fuzzy
+msgid ""
+"* For a parameter, `impl Trait` is like an anonymous generic parameter with "
+"a trait bound.\n"
+"\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.\n"
+"\n"
+" Inference is hard in return position. A function returning `impl Foo` "
+"picks\n"
+" the concrete type it returns, without writing it out in the source. A "
+"function\n"
+" returning a generic type like `collect<B>() -> B` can return any type\n"
+" satisfying `B`, and the caller may need to choose one, such as with `let "
+"x:\n"
+" Vec<_> = foo.collect()` or with the turbofish, `foo.collect::<Vec<_>>()`."
+msgstr ""
+"* Für einen Parameter ist `impl Trait` wie ein anonymer generischer "
+"Parameter mit einer Eigenschaftsbindung.\n"
+"* Für einen Rückgabetyp bedeutet dies, dass der Rückgabetyp ein konkreter "
+"Typ ist, der die Eigenschaft implementiert,\n"
+" ohne den Typ zu nennen. Dies kann nützlich sein, wenn Sie den konkreten "
+"Typ in a nicht verfügbar machen möchten\n"
+" öffentliche API."
+
+#: src/traits/impl-trait.md:37
+#, fuzzy
+msgid ""
+"This example is great, because it uses `impl Display` twice. It helps to "
+"explain that\n"
+"nothing here enforces that it is _the same_ `impl Display` type. If we used "
+"a single \n"
+"`T: Display`, it would enforce the constraint that input `T` and return `T` "
+"type are the same type.\n"
+"It would not work for this particular function, as the type we expect as "
+"input is likely not\n"
+"what `format!` returns. If we wanted to do the same via `: Display` syntax, "
+"we'd need two\n"
+"independent generic parameters."
+msgstr ""
+"Dieses Beispiel ist großartig, weil es `impl Display` zweimal verwendet. Es "
+"hilft, das zu erklären\n"
+"nichts hier erzwingt, dass es _derselbe_ `impl Display`-Typ ist. Wenn wir "
+"eine Single benutzten\n"
+"`T: Display`, es würde die Einschränkung erzwingen, dass der Eingabe-`T`- "
+"und der Rückgabe-`T-Typ derselbe Typ sind.\n"
+"Es würde für diese spezielle Funktion nicht funktionieren, da der Typ, den "
+"wir als Eingabe erwarten, wahrscheinlich nicht der Fall ist\n"
+"welches `format!` zurückgibt. Wenn wir dasselbe über die `: Display`-Syntax "
+"machen wollten, bräuchten wir zwei\n"
+"unabhängige generische Parameter.\n"
+" \n"
+"</details>"
+
#: src/traits/important-traits.md:1
#, fuzzy
msgid "# Important Traits"
@@ -8954,76 +9450,6 @@ msgid ""
"```"
msgstr ""
-#: src/traits/operators.md:1
-#, fuzzy
-msgid "# `Add`, `Mul`, ..."
-msgstr "# `Hinzufügen`, `Mul`, ..."
-
-#: src/traits/operators.md:3
-#, fuzzy
-msgid "Operator overloading is implemented via traits in [`std::ops`][1]:"
-msgstr ""
-"Das Überladen von Operatoren wird über Traits in `std::ops` implementiert:"
-
-#: src/traits/operators.md:5
-msgid ""
-"```rust,editable\n"
-"#[derive(Debug, Copy, Clone)]\n"
-"struct Point { x: i32, y: i32 }\n"
-"\n"
-"impl std::ops::Add for Point {\n"
-" type Output = Self;\n"
-"\n"
-" fn add(self, other: Self) -> Self {\n"
-" Self {x: self.x + other.x, y: self.y + other.y}\n"
-" }\n"
-"}\n"
-"\n"
-"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/operators.md:26 src/traits/drop.md:34
-#, fuzzy
-msgid "Discussion points:"
-msgstr "Diskussionspunkte:"
-
-#: src/traits/operators.md:28
-#, fuzzy
-msgid ""
-"* You could implement `Add` for `&Point`. In which situations is that "
-"useful? \n"
-" * Answer: `Add:add` consumes `self`. If type `T` for which you are\n"
-" overloading the operator is not `Copy`, you should consider "
-"overloading\n"
-" the operator for `&T` as well. This avoids unnecessary cloning on "
-"the\n"
-" call site.\n"
-"* Why is `Output` an associated type? Could it be made a type parameter?\n"
-" * Short answer: Type parameters are controlled by the caller, but\n"
-" associated types (like `Output`) are controlled by the implementor "
-"of a\n"
-" trait."
-msgstr ""
-"* Sie könnten `Add` für `&Point` implementieren. In welchen Situationen ist "
-"das sinnvoll?\n"
-" * Antwort: `Add:add` verbraucht `self`. Geben Sie \"T\" ein, für das Sie "
-"sind\n"
-" Das Überladen des Operators ist nicht \"Kopieren\", Sie sollten das "
-"Überladen in Betracht ziehen\n"
-" auch der Operator für `&T`. Dies vermeidet unnötiges Klonen auf der\n"
-" Website aufrufen.\n"
-"* Warum ist `Output` ein assoziierter Typ? Könnte es ein Typparameter "
-"gemacht werden?\n"
-" * Kurze Antwort: Typparameter werden vom Aufrufer gesteuert, aber\n"
-" Zugehörige Typen (wie `Output`) werden vom Implementierer von a "
-"gesteuert\n"
-" Merkmal."
-
#: src/traits/drop.md:1
#, fuzzy
msgid "# The `Drop` Trait"
@@ -9068,6 +9494,11 @@ msgid ""
"```"
msgstr ""
+#: src/traits/drop.md:34 src/traits/operators.md:26
+#, fuzzy
+msgid "Discussion points:"
+msgstr "Diskussionspunkte:"
+
#: src/traits/drop.md:36
#, fuzzy
msgid ""
@@ -9145,293 +9576,77 @@ msgid ""
"provides convenience methods that use it."
msgstr ""
-#: src/generics.md:1
+#: src/traits/operators.md:1
#, fuzzy
-msgid "# Generics"
-msgstr "# Generika"
+msgid "# `Add`, `Mul`, ..."
+msgstr "# `Hinzufügen`, `Mul`, ..."
-#: src/generics.md:3
+#: src/traits/operators.md:3
#, fuzzy
-msgid ""
-"Rust support generics, which lets you abstract an algorithm (such as "
-"sorting)\n"
-"over the types used in the algorithm."
+msgid "Operator overloading is implemented via traits in [`std::ops`][1]:"
msgstr ""
-"Rust unterstützt Generika, mit denen Sie einen Algorithmus abstrahieren "
-"können (z. B. Sortieren)\n"
-"über die im Algorithmus verwendeten Typen."
+"Das Überladen von Operatoren wird über Traits in `std::ops` implementiert:"
-#: src/generics/data-types.md:1
-#, fuzzy
-msgid "# Generic Data Types"
-msgstr "# Generische Datentypen"
-
-#: src/generics/data-types.md:3
-#, fuzzy
-msgid "You can use generics to abstract over the concrete field type:"
-msgstr "Mit Generika können Sie über den konkreten Feldtyp abstrahieren:"
-
-#: src/generics/data-types.md:5
+#: src/traits/operators.md:5
msgid ""
"```rust,editable\n"
-"#[derive(Debug)]\n"
-"struct Point<T> {\n"
-" x: T,\n"
-" y: T,\n"
-"}\n"
+"#[derive(Debug, Copy, Clone)]\n"
+"struct Point { x: i32, y: i32 }\n"
"\n"
-"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
-#, fuzzy
-msgid "# Generic Methods"
-msgstr "# Generische Methoden"
-
-#: src/generics/methods.md:3
-#, fuzzy
-msgid "You can declare a generic type on your `impl` block:"
-msgstr "Sie können einen generischen Typ in Ihrem `impl`-Block deklarieren:"
-
-#: src/generics/methods.md:5
-msgid ""
-"```rust,editable\n"
-"#[derive(Debug)]\n"
-"struct Point<T>(T, T);\n"
+"impl std::ops::Add for Point {\n"
+" type Output = Self;\n"
"\n"
-"impl<T> Point<T> {\n"
-" fn x(&self) -> &T {\n"
-" &self.0 // + 10\n"
+" fn add(self, other: Self) -> Self {\n"
+" Self {x: self.x + other.x, y: self.y + other.y}\n"
" }\n"
-"\n"
-" // fn set_x(&mut self, x: T)\n"
"}\n"
"\n"
"fn main() {\n"
-" let p = Point(5, 10);\n"
-" println!(\"p.x = {}\", p.x());\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/generics/methods.md:25
+#: src/traits/operators.md:28
#, fuzzy
msgid ""
-"* *Q:* Why `T` is specified twice in `impl<T> Point<T> {}`? Isn't that "
-"redundant?\n"
-" * This is because it is a generic implementation section for generic "
-"type. They are independently generic.\n"
-" * It means these methods are defined for any `T`.\n"
-" * It is possible to write `impl Point<u32> { .. }`. \n"
-" * `Point` is still generic and you can use `Point<f64>`, but methods "
-"in this block will only be available for `Point<u32>`."
+"* You could implement `Add` for `&Point`. In which situations is that "
+"useful? \n"
+" * Answer: `Add:add` consumes `self`. If type `T` for which you are\n"
+" overloading the operator is not `Copy`, you should consider "
+"overloading\n"
+" the operator for `&T` as well. This avoids unnecessary cloning on "
+"the\n"
+" call site.\n"
+"* Why is `Output` an associated type? Could it be made a type parameter?\n"
+" * Short answer: Type parameters are controlled by the caller, but\n"
+" associated types (like `Output`) are controlled by the implementor "
+"of a\n"
+" trait."
msgstr ""
-"* *F:* Warum wird `T` zweimal in `impl<T> Point<T> {}` angegeben? Ist das "
-"nicht überflüssig?\n"
-" * Dies liegt daran, dass es sich um einen generischen "
-"Implementierungsabschnitt für einen generischen Typ handelt. Sie sind "
-"unabhängig generisch.\n"
-" * Dies bedeutet, dass diese Methoden für jedes `T` definiert sind.\n"
-" * Es ist möglich `impl Point<u32> { .. }` zu schreiben.\n"
-" * „Point“ ist immer noch generisch und Sie können „Point<f64>“ "
-"verwenden, aber Methoden in diesem Block sind nur für „Point<u32>“ verfügbar."
+"* Sie könnten `Add` für `&Point` implementieren. In welchen Situationen ist "
+"das sinnvoll?\n"
+" * Antwort: `Add:add` verbraucht `self`. Geben Sie \"T\" ein, für das Sie "
+"sind\n"
+" Das Überladen des Operators ist nicht \"Kopieren\", Sie sollten das "
+"Überladen in Betracht ziehen\n"
+" auch der Operator für `&T`. Dies vermeidet unnötiges Klonen auf der\n"
+" Website aufrufen.\n"
+"* Warum ist `Output` ein assoziierter Typ? Könnte es ein Typparameter "
+"gemacht werden?\n"
+" * Kurze Antwort: Typparameter werden vom Aufrufer gesteuert, aber\n"
+" Zugehörige Typen (wie `Output`) werden vom Implementierer von a "
+"gesteuert\n"
+" Merkmal."
-#: src/generics/trait-bounds.md:1
-#, fuzzy
-msgid "# Trait Bounds"
-msgstr "# Eigenschaftsgrenzen"
-
-#: src/generics/trait-bounds.md:3
-#, fuzzy
-msgid ""
-"When working with generics, you often want to require the types to "
-"implement\n"
-"some trait, so that you can call this trait's methods."
-msgstr ""
-"Wenn Sie mit Generika arbeiten, möchten Sie häufig die Typen einschränken. "
-"Du kannst das\n"
-"mit `T:Trait` oder `impl Trait`:"
-
-#: src/generics/trait-bounds.md:6
-msgid "You can do this with `T: Trait` or `impl Trait`:"
-msgstr ""
-
-#: src/generics/trait-bounds.md:8
-msgid ""
-"```rust,editable\n"
-"fn duplicate<T: Clone>(a: T) -> (T, T) {\n"
-" (a.clone(), a.clone())\n"
-"}\n"
-"\n"
-"// Syntactic sugar for:\n"
-"// fn add_42_millions<T: Into<i32>>(x: T) -> i32 {\n"
-"fn add_42_millions(x: impl Into<i32>) -> i32 {\n"
-" x.into() + 42_000_000\n"
-"}\n"
-"\n"
-"// struct NotClonable;\n"
-"\n"
-"fn main() {\n"
-" let foo = String::from(\"foo\");\n"
-" let pair = duplicate(foo);\n"
-" println!(\"{pair:?}\");\n"
-"\n"
-" let many = add_42_millions(42_i8);\n"
-" println!(\"{many}\");\n"
-" let many_more = add_42_millions(10_000_000);\n"
-" println!(\"{many_more}\");\n"
-"}\n"
-"```"
-msgstr ""
-
-#: src/generics/trait-bounds.md:35
-msgid "Show a `where` clause, students will encounter it when reading code."
-msgstr ""
-
-#: src/generics/trait-bounds.md:37
-msgid ""
-"```rust,ignore\n"
-"fn duplicate<T>(a: T) -> (T, T)\n"
-"where\n"
-" T: Clone,\n"
-"{\n"
-" (a.clone(), a.clone())\n"
-"}\n"
-"```"
-msgstr ""
-
-#: src/generics/trait-bounds.md:46
-#, fuzzy
-msgid ""
-"* It declutters the function signature if you have many parameters.\n"
-"* It has additional features making it more powerful.\n"
-" * If someone asks, the extra feature is that the type on the left of \":"
-"\" can be arbitrary, like `Option<T>`.\n"
-" "
-msgstr ""
-"* Es entrümpelt die Funktionssignatur, wenn Sie viele Parameter haben.\n"
-"* Es hat zusätzliche Funktionen, die es leistungsfähiger machen.\n"
-" * Wenn jemand fragt, das zusätzliche Feature ist, dass der Typ links von "
-"\":\" beliebig sein kann, wie `Option<T>`.\n"
-" \n"
-"</Details>"
-
-#: src/generics/impl-trait.md:1
-#, fuzzy
-msgid "# `impl Trait`"
-msgstr "# `imple Merkmal`"
-
-#: src/generics/impl-trait.md:3
-#, fuzzy
-msgid ""
-"Similar to trait bounds, an `impl Trait` syntax can be used in function\n"
-"arguments and return values:"
-msgstr ""
-"Ähnlich wie Merkmalsgrenzen kann eine \"impl Trait\"-Syntax in Funktion "
-"verwendet werden\n"
-"Argumente und Rückgabewerte:"
-
-#: src/generics/impl-trait.md:6
-msgid ""
-"```rust,editable\n"
-"use std::fmt::Display;\n"
-"\n"
-"fn get_x(name: impl Display) -> impl Display {\n"
-" format!(\"Hello {name}\")\n"
-"}\n"
-"\n"
-"fn main() {\n"
-" let x = get_x(\"foo\");\n"
-" println!(\"{x}\");\n"
-"}\n"
-"```"
-msgstr ""
-
-#: src/generics/impl-trait.md:19
-#, fuzzy
-msgid "* `impl Trait` allows you to work with types which you cannot name."
-msgstr ""
-"* `impl Trait` kann nicht mit der `::<>` Turbofish-Syntax verwendet werden.\n"
-"* `impl Trait` ermöglicht es Ihnen, mit Typen zu arbeiten, die Sie nicht "
-"benennen können."
-
-#: src/generics/impl-trait.md:23
-#, fuzzy
-msgid ""
-"The meaning of `impl Trait` is a bit different in the different positions."
-msgstr ""
-"Die Bedeutung von „impl Trait“ ist in den verschiedenen Positionen etwas "
-"unterschiedlich."
-
-#: src/generics/impl-trait.md:25
-#, fuzzy
-msgid ""
-"* For a parameter, `impl Trait` is like an anonymous generic parameter with "
-"a trait bound.\n"
-"\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.\n"
-"\n"
-" Inference is hard in return position. A function returning `impl Foo` "
-"picks\n"
-" the concrete type it returns, without writing it out in the source. A "
-"function\n"
-" returning a generic type like `collect<B>() -> B` can return any type\n"
-" satisfying `B`, and the caller may need to choose one, such as with `let "
-"x:\n"
-" Vec<_> = foo.collect()` or with the turbofish, `foo.collect::<Vec<_>>()`."
-msgstr ""
-"* Für einen Parameter ist `impl Trait` wie ein anonymer generischer "
-"Parameter mit einer Eigenschaftsbindung.\n"
-"* Für einen Rückgabetyp bedeutet dies, dass der Rückgabetyp ein konkreter "
-"Typ ist, der die Eigenschaft implementiert,\n"
-" ohne den Typ zu nennen. Dies kann nützlich sein, wenn Sie den konkreten "
-"Typ in a nicht verfügbar machen möchten\n"
-" öffentliche API."
-
-#: src/generics/impl-trait.md:37
-#, fuzzy
-msgid ""
-"This example is great, because it uses `impl Display` twice. It helps to "
-"explain that\n"
-"nothing here enforces that it is _the same_ `impl Display` type. If we used "
-"a single \n"
-"`T: Display`, it would enforce the constraint that input `T` and return `T` "
-"type are the same type.\n"
-"It would not work for this particular function, as the type we expect as "
-"input is likely not\n"
-"what `format!` returns. If we wanted to do the same via `: Display` syntax, "
-"we'd need two\n"
-"independent generic parameters."
-msgstr ""
-"Dieses Beispiel ist großartig, weil es `impl Display` zweimal verwendet. Es "
-"hilft, das zu erklären\n"
-"nichts hier erzwingt, dass es _derselbe_ `impl Display`-Typ ist. Wenn wir "
-"eine Single benutzten\n"
-"`T: Display`, es würde die Einschränkung erzwingen, dass der Eingabe-`T`- "
-"und der Rückgabe-`T-Typ derselbe Typ sind.\n"
-"Es würde für diese spezielle Funktion nicht funktionieren, da der Typ, den "
-"wir als Eingabe erwarten, wahrscheinlich nicht der Fall ist\n"
-"welches `format!` zurückgibt. Wenn wir dasselbe über die `: Display`-Syntax "
-"machen wollten, bräuchten wir zwei\n"
-"unabhängige generische Parameter.\n"
-" \n"
-"</details>"
-
-#: src/generics/closures.md:1
+#: src/traits/closures.md:1
#, fuzzy
msgid "# Closures"
msgstr "# Schließungen"
-#: src/generics/closures.md:3
+#: src/traits/closures.md:3
#, fuzzy
msgid ""
"Closures or lambda expressions have types which cannot be named. However, "
@@ -9448,7 +9663,7 @@ msgstr ""
"[`FnOnce`](https://doc.rust-lang.org/std/ops/trait.FnOnce.html) "
"Eigenschaften:"
-#: src/generics/closures.md:8
+#: src/traits/closures.md:8
msgid ""
"```rust,editable\n"
"fn apply_with_log(func: impl FnOnce(i32) -> i32, input: i32) -> i32 {\n"
@@ -9466,7 +9681,7 @@ msgid ""
"```"
msgstr ""
-#: src/generics/closures.md:25
+#: src/traits/closures.md:25
#, fuzzy
msgid ""
"If you have an `FnOnce`, you may only call it once. It might consume "
@@ -9475,7 +9690,7 @@ msgstr ""
"Wenn Sie ein `FnOnce` haben, können Sie es nur einmal aufrufen. Es kann "
"erfasste Werte verbrauchen."
-#: src/generics/closures.md:27
+#: src/traits/closures.md:27
#, fuzzy
msgid ""
"An `FnMut` might mutate captured values, so you can call it multiple times "
@@ -9484,7 +9699,7 @@ msgstr ""
"Ein `FnMut` kann erfasste Werte mutieren, sodass Sie es mehrmals, aber nicht "
"gleichzeitig aufrufen können."
-#: src/generics/closures.md:29
+#: src/traits/closures.md:29
#, fuzzy
msgid ""
"An `Fn` neither consumes nor mutates captured values, or perhaps captures "
@@ -9495,7 +9710,7 @@ msgstr ""
"vielleicht gar nichts, also kann es das\n"
"mehrmals gleichzeitig aufgerufen werden."
-#: src/generics/closures.md:32
+#: src/traits/closures.md:32
#, fuzzy
msgid ""
"`FnMut` is a subtype of `FnOnce`. `Fn` is a subtype of `FnMut` and `FnOnce`. "
@@ -9510,254 +9725,11 @@ msgstr ""
"überall dort verwenden, wo ein „FnMut“ oder „FnOnce“ steht\n"
"ist angesagt."
-#: src/generics/closures.md:36
+#: src/traits/closures.md:36
#, fuzzy
msgid "`move` closures only implement `FnOnce`."
msgstr "`move`-Closures implementieren nur `FnOnce`."
-#: src/generics/monomorphization.md:1
-#, fuzzy
-msgid "# Monomorphization"
-msgstr "# Monomorphisierung"
-
-#: src/generics/monomorphization.md:3
-#, fuzzy
-msgid "Generic code is turned into non-generic code based on the call sites:"
-msgstr ""
-"Basierend auf den Aufrufseiten wird generischer Code in nicht generischen "
-"Code umgewandelt:"
-
-#: 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
-#, fuzzy
-msgid "behaves as if you wrote"
-msgstr "verhält sich so, als hättest du geschrieben"
-
-#: src/generics/monomorphization.md:14
-msgid ""
-"```rust,editable\n"
-"enum Option_i32 {\n"
-" Some(i32),\n"
-" None,\n"
-"}\n"
-"\n"
-"enum Option_f64 {\n"
-" Some(f64),\n"
-" None,\n"
-"}\n"
-"\n"
-"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
-#, fuzzy
-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 ""
-"Dies ist eine Null-Kosten-Abstraktion: Sie erhalten genau das gleiche "
-"Ergebnis, als ob Sie es hätten\n"
-"die Datenstrukturen ohne die Abstraktion von Hand codiert."
-
-#: src/generics/trait-objects.md:1
-#, fuzzy
-msgid "# Trait Objects"
-msgstr "# Eigenschaftsobjekte"
-
-#: src/generics/trait-objects.md:3
-#, fuzzy
-msgid "We've seen how a function can take arguments which implement a trait:"
-msgstr ""
-"Wir haben gesehen, wie eine Funktion Argumente annehmen kann, die ein "
-"Merkmal implementieren:"
-
-#: src/generics/trait-objects.md:5
-msgid ""
-"```rust,editable\n"
-"use std::fmt::Display;\n"
-"\n"
-"fn print<T: Display>(x: T) {\n"
-" println!(\"Your value: {x}\");\n"
-"}\n"
-"\n"
-"fn main() {\n"
-" print(123);\n"
-" print(\"Hello\");\n"
-"}\n"
-"```"
-msgstr ""
-
-#: src/generics/trait-objects.md:18
-#, fuzzy
-msgid ""
-"However, how can we store a collection of mixed types which implement "
-"`Display`?"
-msgstr ""
-"Wie können wir jedoch eine Sammlung gemischter Typen speichern, die "
-"\"Display\" implementieren?"
-
-#: src/generics/trait-objects.md:20
-msgid ""
-"```rust,editable,compile_fail\n"
-"fn main() {\n"
-" let displayables = vec![123, \"Hello\"];\n"
-"}\n"
-"```"
-msgstr ""
-
-#: src/generics/trait-objects.md:26
-#, fuzzy
-msgid "For this, we need _trait objects_:"
-msgstr "Dafür brauchen wir _trait objects_:"
-
-#: src/generics/trait-objects.md:28
-msgid ""
-"```rust,editable\n"
-"use std::fmt::Display;\n"
-"\n"
-"fn main() {\n"
-" let displayables: Vec<Box<dyn Display>> = vec![Box::new(123), Box::"
-"new(\"Hello\")];\n"
-" for x in displayables {\n"
-" println!(\"x: {x}\");\n"
-" }\n"
-"}\n"
-"```"
-msgstr ""
-
-#: src/generics/trait-objects.md:39
-#, fuzzy
-msgid "Memory layout after allocating `displayables`:"
-msgstr "Speicherlayout nach Zuweisung von `xs`:"
-
-#: src/generics/trait-objects.md:41
-msgid ""
-"```bob\n"
-" Stack Heap\n"
-".- - - - - - - - - - - - - -. .- - - - - - - - - - - - - - - - - - - - - "
-"- - -.\n"
-": : : :\n"
-": "
-"displayables : : :\n"
-": +-----------+-------+ : : +-----+-----"
-"+ :\n"
-": | ptr | o---+---+-----+-->| o o | o o "
-"| :\n"
-": | len | 2 | : : +-|-|-+-|-|-"
-"+ :\n"
-": | capacity | 2 | : : | | | | +----+----+----+----+----"
-"+ :\n"
-": +-----------+-------+ : : | | | '-->| H | e | l | l | o "
-"| :\n"
-": : : | | | +----+----+----+----+----"
-"+ :\n"
-"`- - - - - - - - - - - - - -' : | | "
-"| :\n"
-" : | | | "
-"+-------------------------+ :\n"
-" : | | '---->| \"<str as Display>::"
-"fmt\" | :\n"
-" : | | "
-"+-------------------------+ :\n"
-" : | "
-"| :\n"
-" : | | +----+----+----+----"
-"+ :\n"
-" : | '-->| 7b | 00 | 00 | 00 "
-"| :\n"
-" : | +----+----+----+----"
-"+ :\n"
-" : "
-"| :\n"
-" : | +-------------------------"
-"+ :\n"
-" : '---->| \"<i32 as Display>::fmt\" "
-"| :\n"
-" : +-------------------------"
-"+ :\n"
-" : :\n"
-" : :\n"
-" '- - - - - - - - - - - - - - - - - - - - - "
-"- - -'\n"
-"```"
-msgstr ""
-
-#: src/generics/trait-objects.md:69
-#, fuzzy
-msgid ""
-"Similarly, you need a trait object if you want to return different types\n"
-"implementing a trait:"
-msgstr ""
-"Ebenso benötigen Sie ein Trait-Objekt, wenn Sie andere Werte zurückgeben "
-"möchten\n"
-"Implementieren eines Merkmals:"
-
-#: src/generics/trait-objects.md:72
-msgid ""
-"```rust,editable\n"
-"fn numbers(n: i32) -> Box<dyn Iterator<Item=i32>> {\n"
-" if n > 0 {\n"
-" Box::new(0..n)\n"
-" } else {\n"
-" Box::new((n..0).rev())\n"
-" }\n"
-"}\n"
-"\n"
-"fn main() {\n"
-" println!(\"{:?}\", numbers(-5).collect::<Vec<_>>());\n"
-" println!(\"{:?}\", numbers(5).collect::<Vec<_>>());\n"
-"}\n"
-"\n"
-"```"
-msgstr ""
-
-#: src/generics/trait-objects.md:90
-#, fuzzy
-msgid ""
-"* Types that implement a given trait may be of different sizes. This makes "
-"it impossible to have things like `Vec<Display>` in the example above.\n"
-"* `dyn Display` is a way to tell the compiler about a dynamically sized type "
-"that implements `Display`.\n"
-"* In the example, `displayables` holds *fat pointers* to objects that "
-"implement `Display`. The fat pointer consists of two components, a pointer "
-"to the actual object and a pointer to the virtual method table for the "
-"`Display` implementation of that particular object.\n"
-"* Compare these outputs in the above example:\n"
-" ```rust,ignore\n"
-"\t\t use std::fmt::Display;\n"
-" println!(\"{}\", std::mem::size_of::<u32>());\n"
-" println!(\"{}\", std::mem::size_of::<&u32>());\n"
-" println!(\"{}\", std::mem::size_of::<&dyn Display>());\n"
-" println!(\"{}\", std::mem::size_of::<Box<dyn Display>>());\n"
-" ```"
-msgstr ""
-"* Merkmale können vorimplementierte (Standard-)Methoden und Methoden "
-"spezifizieren, die Benutzer selbst implementieren müssen. Methoden mit "
-"Standardimplementierungen können sich auf erforderliche Methoden stützen.\n"
-"* Typen, die ein bestimmtes Merkmal implementieren, können unterschiedlich "
-"groß sein. Das macht es unmöglich Dinge wie `Vec<Greet>` im obigen Beispiel "
-"zu haben.\n"
-"* „dyn Greet“ ist eine Möglichkeit, dem Compiler einen Typ mit dynamischer "
-"Größe mitzuteilen, der „Greet“ implementiert.\n"
-"* Im Beispiel enthält `pets` Fat Pointer auf Objekte, die `Greet` "
-"implementieren. Der Fat Pointer besteht aus zwei Komponenten, einem Zeiger "
-"auf das tatsächliche Objekt und einem Zeiger auf die virtuelle "
-"Methodentabelle für die \"Greet\"-Implementierung dieses bestimmten Objekts."
-
#: src/exercises/day-3/morning.md:1
#, fuzzy
msgid "# Day 3: Morning Exercises"
@@ -19020,6 +18992,34 @@ msgid ""
"```"
msgstr ""
+#, fuzzy
+#~ msgid ""
+#~ "We've seen how a function can take arguments which implement a trait:"
+#~ msgstr ""
+#~ "Wir haben gesehen, wie eine Funktion Argumente annehmen kann, die ein "
+#~ "Merkmal implementieren:"
+
+#, fuzzy
+#~ msgid ""
+#~ "However, how can we store a collection of mixed types which implement "
+#~ "`Display`?"
+#~ msgstr ""
+#~ "Wie können wir jedoch eine Sammlung gemischter Typen speichern, die "
+#~ "\"Display\" implementieren?"
+
+#, fuzzy
+#~ msgid "For this, we need _trait objects_:"
+#~ msgstr "Dafür brauchen wir _trait objects_:"
+
+#, fuzzy
+#~ msgid ""
+#~ "Similarly, you need a trait object if you want to return different types\n"
+#~ "implementing a trait:"
+#~ msgstr ""
+#~ "Ebenso benötigen Sie ein Trait-Objekt, wenn Sie andere Werte zurückgeben "
+#~ "möchten\n"
+#~ "Implementieren eines Merkmals:"
+
#~ msgid ""
#~ "1. Make yourself familiar with the course material. We've included "
#~ "speaker notes\n"