Merge pull request #343 from damoasda/update-2023-07

Änderungen im Originalbuch bis zum 29.06.2023 nachziehen

README.md

@@ -34,6 +34,6 @@ Vorschläge und Korrekturen oder gar Übersetzungen sind natürlich gerne gewün
 Falls du helfen möchtest, dann am besten via Pull Request oder Issue.
 
 Das Buch wurde mittlerweile komplett übersetzt und enthält alle Änderungen des
-englischen Originals bis einschließlich zum **23.01.2023**.
+englischen Originals bis einschließlich zum **29.06.2023**.
 
 Bitte beachte auch die [Übersetzungskonventionen](https://github.com/rust-lang-de/rustbook-de/wiki/%C3%9Cbersetzungskonventionen).

src/appendix-07-nightly-rust.md

@@ -145,12 +145,14 @@ ermöglicht, neue Funktionen praktisch zu nutzen, bevor wir sie für immer für
 stabil erklären. Diejenigen, die sich für das Allerneueste entscheiden wollen,
 können dies tun, und diejenigen, die eine felsenfeste Erfahrung machen wollen,
 können bei der stabilen Version bleiben und wissen, dass ihr Code nicht brechen
-wird. Stabilität ohne Stillstand. Dieses Buch enthält nur Informationen über
-stabile Funktionalitäten, da sich in Entwicklung befindliche Funktionalitäten
-noch ändern, und sicherlich werden sie sich zwischen dem Zeitpunkt, an dem
-dieses Buch geschrieben wurde, und dem Zeitpunkt, an dem sie in stabilen
-Versionen aktiviert werden, unterscheiden. Die Dokumentation für die nur
-nächtlich verfügbaren Funktionalitäten findest du online.
+wird. Stabilität ohne Stillstand.
+
+Dieses Buch enthält nur Informationen über stabile Funktionalitäten, da sich in
+Entwicklung befindliche Funktionalitäten noch ändern, und sicherlich werden sie
+sich zwischen dem Zeitpunkt, an dem dieses Buch geschrieben wurde, und dem
+Zeitpunkt, an dem sie in stabilen Versionen aktiviert werden, unterscheiden.
+Die Dokumentation für die nur nächtlich verfügbaren Funktionalitäten findest du
+online.
 
 ### Rustup und die Rolle des nächtlichen Rust
 

src/ch00-00-introduction.md

@@ -203,4 +203,4 @@ Codeversion, wenn er sich nicht kompilieren lässt.
 Die Quelldateien, aus denen dieses Buch generiert wird, findest du unter
 [GitHub][book-de].
 
-[book-de]: https://github.com/rust-lang-de/rustbook-de/tree/master/src
+[book-de]: https://github.com/rust-lang-de/rustbook-de/

src/ch01-01-installation.md

@@ -10,19 +10,18 @@ benötigen.
 > nach anderen Möglichkeiten.
 
 Die folgenden Schritte installieren die neueste stabile Version des
-Rust-Compilers. Rust garantiert Stabilität und stellt somit sicher,
-dass alle kompilierbaren Beispiele in diesem Buch auch mit neueren
-Rust-Versionen kompilierbar bleiben werden. Die Konsolenausgabe
-der Beispiele kann sich zwischen Versionen leicht unterscheiden,
-weil Rust oft Fehlermeldungen und Warnungen verbessert.
-Anders ausgedrückt, jede neuere stabile Version von Rust, die du
-mithilfe dieser Schritte installierst, sollte wie erwartet mit dem
-Inhalt dieses Buches funktionieren.
+Rust-Compilers. Rust garantiert Stabilität und stellt somit sicher, dass alle
+kompilierbaren Beispiele in diesem Buch auch mit neueren Rust-Versionen
+kompilierbar bleiben werden. Die Ausgabe der Beispiele kann sich zwischen
+Versionen leicht unterscheiden, weil Rust oft Fehlermeldungen und Warnungen
+verbessert. Anders ausgedrückt, jede neuere stabile Version von Rust, die du
+mithilfe dieser Schritte installierst, sollte wie erwartet mit dem Inhalt
+dieses Buchs funktionieren.
 
 > ### Kommandozeilen-Schreibweise
 >
-> In diesem Kapitel und im ganzen Buch werden wir einige Befehle auf der
-> Konsole zeigen. Alle Zeilen, die du in die Konsole eingeben sollst,
+> In diesem Kapitel und im ganzen Buch werden wir einige Befehle auf dem
+> Terminal zeigen. Alle Zeilen, die du in das Terminal eingeben sollst,
 > beginnen mit `$`. Du brauchst das `$`-Zeichen nicht einzugeben;
 > es weist nur auf den Beginn jedes Befehls hin. Zeilen, die nicht mit
 > `$` beginnen, zeigen normalerweise die Ausgabe eines vorherigen Befehls.
@@ -31,7 +30,7 @@ Inhalt dieses Buches funktionieren.
 
 ### Die Installation von `rustup` in Linux und macOS
 
-Falls du Linux oder macOS verwendest, öffne ein Konsolenfenster und gib den
+Falls du Linux oder macOS verwendest, öffne ein Terminalfenster und gib den
 folgenden Befehl ein:
 
 ```console
@@ -86,8 +85,8 @@ werden wir diese erläutern.
 
 ### Fehlersuche
 
-Um zu überprüfen, ob du Rust korrekt installiert hast, öffne eine
-Kommandozeile und gib folgende Zeile ein:
+Um zu überprüfen, ob du Rust korrekt installiert hast, öffne ein
+Terminal und gib folgende Zeile ein:
 
 ```console
 $ rustc --version
@@ -129,9 +128,8 @@ Rust-Entwicklern in Kontakt treten kannst, erfährst du auf der
 
 ### Aktualisieren und Deinstallieren
 
-Nachdem du Rust mithilfe von `rustup` installiert hast, ist es einfach,
-auf die neueste Version zu aktualisieren. Führe folgenden Befehl auf der
-Kommandozeile aus:
+Nachdem du Rust mithilfe von `rustup` installiert hast, ist es einfach, auf die
+neueste Version zu aktualisieren. Führe folgenden Befehl im Terminal aus:
 
 ```console
 $ rustup update

src/ch01-02-hello-world.md

@@ -22,7 +22,7 @@ erstellen. Es ist Rust egal, wo dein Code lebt, aber für die Übungen und
 Projekte in diesem Buch schlagen wir vor, ein Verzeichnis *projects* in deinem
 Hauptverzeichnis anzulegen und all deine Projekte dort abzulegen.
 
-Öffne eine Kommandozeile und gib die folgenden Befehle ein, um ein Verzeichnis
+Öffne ein Terminal und gib die folgenden Befehle ein, um ein Verzeichnis
 *projects* und ein Verzeichnis für das Projekt „Hallo Welt!“ innerhalb des
 Verzeichnisses *projects* zu erstellen.
 
@@ -65,8 +65,9 @@ fn main() {
 <span class="caption">Codeblock 1-1: Ein Programm, das `Hallo Welt!`
 ausgibt</span>
 
-Speichere die Datei und gehe zurück zu deinem Konsolenfenster. Gib unter Linux
-oder MacOS die folgenden Befehle ein, um die Datei zu kompilieren und auszuführen:
+Speichere die Datei und gehe zurück zu deinem Terminalfenster im Verzeichnis
+*~/projects/hello_world*. Gib unter Linux oder MacOS die folgenden Befehle ein,
+um die Datei zu kompilieren und auszuführen:
 
 ```console
 $ rustc main.rs
@@ -82,9 +83,9 @@ Unter Windows gib den Befehl `.\main.exe` anstelle von `./main` ein:
 Hallo Welt!
 ```
 
-Unabhängig von deinem Betriebssystem sollte die Zeichenfolge `Hallo Welt!` auf
-der Kommandozeile ausgegeben werden. Wenn du diese Ausgabe nicht siehst, lies
-im Abschnitt [„Fehlersuche“][troubleshooting] des Installationsabschnitts nach,
+Unabhängig von deinem Betriebssystem sollte die Zeichenfolge `Hallo Welt!` im
+Terminal ausgegeben werden. Wenn du diese Ausgabe nicht siehst, lies im
+Abschnitt [„Fehlersuche“][troubleshooting] des Installationsabschnitts nach,
 wie du Hilfe erhalten kannst.
 
 Wenn `Hallo Welt!` ausgegeben wurde, herzlichen Glückwunsch! Du hast offiziell
@@ -166,7 +167,7 @@ Wenn du einen C- oder C++-Hintergrund hast, wirst du feststellen, dass dies
 eine ausführbare Binärdatei aus.
 
 Unter Linux, MacOS und PowerShell unter Windows kannst du die ausführbare Datei
-sehen, indem du den Befehl `ls` in deiner Konsole eingibst:
+sehen, indem du den Befehl `ls` in deinem Terminal eingibst:
 
 ```console
 $ ls
@@ -195,7 +196,7 @@ $ ./main # oder .\main.exe unter Windows
 ```
 
 Wenn *main.rs* dein „Hallo Welt!“-Programm wäre, würde diese Zeile „Hallo
-Welt!“ in deiner Konsole ausgeben.
+Welt!“ in deinem Terminal ausgeben.
 
 Wenn du mit einer dynamischen Sprache wie Ruby, Python oder JavaScript besser
 vertraut bist, bist du es möglicherweise nicht gewohnt, ein Programm in

src/ch02-00-guessing-game-tutorial.md

@@ -823,19 +823,26 @@ versuchen:
 
 ```console
 $ cargo build
-   Compiling libc v0.2.51
-   Compiling rand_core v0.4.0
-   Compiling rand_core v0.3.1
-   Compiling rand v0.5.6
+   Compiling libc v0.2.86
+   Compiling getrandom v0.2.2
+   Compiling cfg-if v1.0.0
+   Compiling ppv-lite86 v0.2.10
+   Compiling rand_core v0.6.2
+   Compiling rand_chacha v0.3.0
+   Compiling rand v0.8.5
    Compiling guessing_game v0.1.0 (file:///projects/guessing_game)
 error[E0308]: mismatched types
   --> src/main.rs:22:21
    |
 22 |     match guess.cmp(&secret_number) {
-   |                     ^^^^^^^^^^^^^^ expected struct `String`, found integer
+   |                 --- ^^^^^^^^^^^^^^ expected struct `String`, found integer
+   |                 |
+   |                 arguments to this function are incorrect
    |
    = note: expected reference `&String`
               found reference `&{integer}`
+note: associated function defined here
+  --> /rustc/d5a82bbd26e1ad8b7401f6a718a9c57c96905483/library/core/src/cmp.rs:783:8
 
 For more information about this error, try `rustc --explain E0308`.
 error: could not compile `guessing_game` due to previous error

src/ch03-02-data-types.md

@@ -29,7 +29,12 @@ error[E0282]: type annotations needed
  --> src/main.rs:2:9
   |
 2 |     let guess = "42".parse().expect("Keine Zahl!");
-  |         ^^^^^ consider giving `guess` a type
+  |         ^^^^^
+  |
+help: consider giving `guess` an explicit type
+  |
+2 |     let guess: _ = "42".parse().expect("Keine Zahl!");
+  |              +++
 
 For more information about this error, try `rustc --explain E0282`.
 error: could not compile `no_type_annotations` due to previous error
@@ -194,7 +199,7 @@ fn main() {
 
     // Division
     let quotient = 56.7 / 32.2;
-    let floored = 2 / 3; // Ergibt 0
+    let truncated = -5 / 3; // Ergibt -1
 
     // Restberechnung
     let remainder = 43 % 5;

src/ch03-03-how-functions-work.md

@@ -188,15 +188,12 @@ Wenn du dieses Programm ausführst, wirst du in etwa folgenden Fehler erhalten:
 
 ```console
 $ cargo run
-   Compiling playground v0.0.1 (/playground)
-error[E0658]: `let` expressions in this position are experimental
+   Compiling functions v0.1.0 (file:///projects/functions)
+error: expected expression, found `let` statement
  --> src/main.rs:2:14
   |
 2 |     let x = (let y = 6);
-  |              ^^^^^^^^^
-  |
-  = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information
-  = help: you can write `matches!(<expr>, <pattern>)` instead of `let <pattern> = <expr>`
+  |              ^^^
 
 error: expected expression, found statement (`let`)
  --> src/main.rs:2:14
@@ -206,20 +203,30 @@ error: expected expression, found statement (`let`)
   |
   = note: variable declaration using `let` is a statement
 
+error[E0658]: `let` expressions in this position are unstable
+ --> src/main.rs:2:14
+  |
+2 |     let x = (let y = 6);
+  |              ^^^^^^^^^
+  |
+  = note: see issue #53667 <https://github.com/rust-lang/rust/issues/53667> for more information
+
 warning: unnecessary parentheses around assigned value
  --> src/main.rs:2:13
   |
 2 |     let x = (let y = 6);
-  |             ^^^^^^^^^^^ help: remove these parentheses
+  |             ^         ^
   |
   = note: `#[warn(unused_parens)]` on by default
-
-error: aborting due to 2 previous errors; 1 warning emitted
+help: remove these parentheses
+  |
+2 -     let x = (let y = 6);
+2 +     let x = let y = 6;
+  |
 
 For more information about this error, try `rustc --explain E0658`.
-error: could not compile `playground`
-
-To learn more, run the command again with --verbose.
+warning: `functions` (bin "functions") generated 1 warning
+error: could not compile `functions` due to 3 previous errors; 1 warning emitted
 ```
 
 Die Anweisung `let y = 6` gibt keinen Wert zurück, also gibt es für `x` nichts,

src/ch04-01-what-is-ownership.md

@@ -1,18 +1,16 @@
 ## Was ist Eigentümerschaft (ownership)?
 
 *Eigentümerschaft* ist eine Reihe von Regeln, die bestimmen, wie ein
-Rust-Programm den Speicher verwaltet.
-
-Alle Programme müssen den Arbeitsspeicher eines Rechners verwalten, während sie
-ausgeführt werden. Einige Sprachen verfügen über eine automatische
-Speicherbereinigung, die während der Programmausführung ständig nach nicht mehr
-genutztem Speicher sucht. Bei anderen Sprachen muss der Programmierer selbst
-den Speicher explizit reservieren und freigeben. Rust verwendet einen dritten
-Ansatz: Der Speicher wird durch ein System aus Eigentümerschaft und einer Reihe
-von Regeln verwaltet, die der Compiler überprüft. Wenn eine der Regeln verletzt
-wird, lässt sich das Programm nicht kompilieren. Keine der
-Eigentümerschaftsfunktionalitäten verlangsamt dein Programm, während es
-läuft.
+Rust-Programm den Speicher verwaltet. Alle Programme müssen den Arbeitsspeicher
+eines Rechners verwalten, während sie ausgeführt werden. Einige Sprachen
+verfügen über eine automatische Speicherbereinigung, die während der
+Programmausführung ständig nach nicht mehr genutztem Speicher sucht. Bei
+anderen Sprachen muss der Programmierer selbst den Speicher explizit
+reservieren und freigeben. Rust verwendet einen dritten Ansatz: Der Speicher
+wird durch ein System aus Eigentümerschaft und einer Reihe von Regeln
+verwaltet, die der Compiler überprüft. Wenn eine der Regeln verletzt wird,
+lässt sich das Programm nicht kompilieren. Keine der
+Eigentümerschaftsfunktionalitäten verlangsamt dein Programm, während es läuft.
 
 Da die Eigentümerschaft für viele Programmierer ein neues Konzept ist, braucht
 es etwas Zeit, sich daran zu gewöhnen. Die gute Nachricht ist, je mehr
@@ -112,8 +110,7 @@ Lass uns zunächst einen Blick auf die Eigentumsregeln (ownership rules) werfen.
 Behalte diese Regeln im Hinterkopf, während wir veranschaulichende Beispiele
 durcharbeiten:
 
-* Jeder Wert in Rust hat eine Variable, die als sein *Eigentümer* bezeichnet
-  wird.
+* Jeder Wert in Rust hat einen *Eigentümer* (owner).
 * Es kann immer nur einen Eigentümer zur gleichen Zeit geben.
 * Wenn der Eigentümer den Gültigkeitsbereich verlässt, wird der Wert
   aufgeräumt.
@@ -407,9 +404,15 @@ error[E0382]: borrow of moved value: `s1`
   |         -- move occurs because `s1` has type `String`, which does not implement the `Copy` trait
 3 |     let s2 = s1;
   |              -- value moved here
-4 | 
+4 |
 5 |     println!("{} Welt!", s1);
   |                          ^^ value borrowed here after move
+  |
+  = note: this error originates in the macro `$crate::format_args_nl` which comes from the expansion of the macro `println` (in Nightly builds, run with -Z macro-backtrace for more info)
+help: consider cloning the value if the performance cost is acceptable
+  |
+3 |     let s2 = s1.clone();
+  |                ++++++++
 
 For more information about this error, try `rustc --explain E0382`.
 error: could not compile `ownership` due to previous error

src/ch04-02-references-and-borrowing.md

@@ -133,7 +133,7 @@ error[E0596]: cannot borrow `*some_string` as mutable, as it is behind a `&` ref
 7 | fn change(some_string: &String) {
   |                        ------- help: consider changing this to be a mutable reference: `&mut String`
 8 |     some_string.push_str(" Welt");
-  |     ^^^^^^^^^^^ `some_string` is a `&` reference, so the data it refers to cannot be borrowed as mutable
+  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `some_string` is a `&` reference, so the data it refers to cannot be borrowed as mutable
 
 For more information about this error, try `rustc --explain E0596`.
 error: could not compile `ownership` due to previous error
@@ -361,7 +361,7 @@ error[E0106]: missing lifetime specifier
 help: consider using the `'static` lifetime
   |
 5 | fn dangle() -> &'static String {
-  |                ~~~~~~~~
+  |                 +++++++
 
 For more information about this error, try `rustc --explain E0106`.
 error: could not compile `ownership` due to previous error