Merge pull request #393 from damoasda/master

Korrekturen

Author: damoasda

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

@@ -783,7 +783,7 @@ bringt. Der Typ `Ordering` ist eine weitere Aufzählung und hat die Varianten
 wenn man zwei Werte vergleicht.
 
 Dann fügen wir unten fünf neue Zeilen hinzu, die den Typ `Ordering` verwenden.
-Die `cmp`-Methode vergleicht zwei Werte und kann auf alles, was verglichen
+Die Methode `cmp` vergleicht zwei Werte und kann auf alles, was verglichen
 werden kann, angewendet werden. Sie braucht eine Referenz auf das, was du
 vergleichen willst: Hier wird `guess` mit `secret_number` verglichen. Dann gibt
 sie eine Variante der `Ordering`-Aufzählung zurück, die wir mit der
@@ -806,7 +806,7 @@ Gehen wir ein Beispiel dafür durch, was mit dem hier verwendeten
 `match`-Ausdruck geschehen würde. Angenommen, der Benutzer hat 50 geschätzt und
 die zufällig generierte Geheimzahl ist diesmal 38.
 
-Wenn der Code 50 mit 38 vergleicht, gibt die `cmp`-Methode `Ordering::Greater`
+Wenn der Code 50 mit 38 vergleicht, gibt die Methode `cmp` `Ordering::Greater`
 zurück, weil 50 größer als 38 ist. Der `match`-Ausdruck erhält den Wert
 `Ordering::Greater` und beginnt mit der Überprüfung des Musters jedes Zweigs.
 Er schaut auf das Muster `Ordering::Less` des ersten Zweigs und sieht, dass der
@@ -920,7 +920,7 @@ willst.
 
 Wir binden `guess` an den Ausdruck `guess.trim().parse()`. Das `guess` im
 Ausdruck bezieht sich auf das ursprüngliche `guess`, das ein `String` mit der
-Eingabe darin war. Die `trim`-Methode der `String`-Instanz wird alle
+Eingabe darin war. Die Methode `trim` der `String`-Instanz wird alle
 Leerzeichen am Anfang und am Ende entfernen. Obwohl `u32` nur numerische
 Zeichen enthalten kann, muss der Benutzer die <span
 class="keystroke">Eingabetaste</span> drücken, um `read_line`
@@ -932,10 +932,10 @@ class="keystroke">Eingabetaste</span> drückt, sieht `guess` wie folgt aus:
 `5\n`. Das `\n` steht für „Zeilenumbruch“ (newline), das Ergebnis des Drückens
 der <span class="keystroke">Eingabetaste</span>. (Unter Windows ergibt das
 Drücken der <span class="keystroke">Eingabetaste</span> einen Wagenrücklauf
-(carriage return) und einen Zeilenumbruch (newline): `\r\n`) Die `trim`-Methode
+(carriage return) und einen Zeilenumbruch (newline): `\r\n`) Die Methode `trim`
 entfernt `\n` und `\r\n`, was nur `5` ergibt.
 
-Die [`parse`-Methode für Zeichenketten][parse] konvertiert eine Zeichenkette in
+Die [Methode `parse` für Zeichenketten][parse] konvertiert eine Zeichenkette in
 einen anderen Typ. Hier verwenden wir sie, um eine Zeichenkette in eine Zahl
 umzuwandeln. Wir müssen Rust den genauen Zahlentyp mitteilen, den wir wollen,
 indem wir `let guess: u32` verwenden. Der Doppelpunkt (`:`) nach `guess` sagt
@@ -952,8 +952,8 @@ zwischen zwei Werten desselben Typs durchgeführt!
 Die Methode `parse` funktioniert nur bei Zeichen, die logisch in Zahlen
 umgewandelt werden können und kann daher leicht Fehler verursachen. Wenn die
 Zeichenkette zum Beispiel `A👍%` enthielte, gäbe es keine Möglichkeit, dies in
-eine Zahl umzuwandeln. Da dies fehlschlagen könnte, gibt die `parse`-Methode
-einen `Result`-Typ zurück, ähnlich wie die `read_line`-Methode (weiter oben in
+eine Zahl umzuwandeln. Da dies fehlschlagen könnte, gibt die Methode `parse`
+einen `Result`-Typ zurück, ähnlich wie die Methode `read_line` (weiter oben in
 [„Behandeln potentieller Fehler mit
 `Result`“](#behandeln-potentieller-fehler-mit-result)). Wir werden dieses
 `Result` auf die gleiche Weise behandeln, indem wir erneut `expect` verwenden.
@@ -1194,8 +1194,8 @@ Das Umstellen von einem `expect`-Aufruf zu einem `match`-Ausdruck ist eine
 Möglichkeit für den Übergang vom Absturz bei einem Fehler zur Behandlung des
 Fehlers. Denke daran, dass `parse` einen `Result`-Typ zurückgibt und `Result`
 eine Aufzählung ist, die die Varianten `Ok` und `Err` hat. Wir benutzen hier
-einen `match`-Ausdruck, wie wir es mit dem `Ordering`-Ergebnis der
-`cmp`-Methode getan haben.
+einen `match`-Ausdruck, wie wir es mit dem `Ordering`-Ergebnis der Methode
+`cmp` getan haben.
 
 Wenn `parse` in der Lage ist, die Zeichenkette erfolgreich in eine Zahl
 umzuwandeln, gibt es einen `Ok`-Wert zurück, der die resultierende Zahl

src/ch03-02-data-types.md

@@ -146,12 +146,12 @@ Typen sind standardmäßig `i32`. Die primäre Situation, in der du `isize` oder
 > 
 > - Umbrechen (wrap) aller Fälle mit den Methoden `wrapping_*`, z.B.
 >   `wrapping_add`
-> - Zurückgeben des Wertes `None`, wenn es einen Überlauf mit einer
->   `checked_*`-Methode gibt.
+> - Zurückgeben des Wertes `None`, wenn es einen Überlauf mit einer Methode
+>   `checked_*` gibt.
 > - Zurückgeben des Wertes und eines booleschen Wertes, der angibt, ob ein
->   Überlauf mit einer `overflowing_*`-Methode stattgefunden hat.
-> - Gewährleisten der Minimal- oder Maximalwerte des Wertes mit den
->   `saturating_*`-Methoden.
+>   Überlauf mit einer Methode `overflowing_*` stattgefunden hat.
+> - Gewährleisten der Minimal- oder Maximalwerte des Wertes mit den Methoden
+>   `saturating_*`.
 
 #### Fließkomma-Typen
 

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

@@ -30,8 +30,8 @@ dem Compiler mit, wo der Funktionsrumpf beginnt und endet.
 
 Wir können jede Funktion, die wir definiert haben, aufrufen, indem wir ihren
 Namen gefolgt von einem Satz Klammern eingeben. Da `another_function` im
-Programm definiert ist, kann sie von innerhalb der `main`-Funktion aufgerufen
-werden. Beachte, dass wir `another_function` _nach_ der `main`-Funktion im
+Programm definiert ist, kann sie von innerhalb der Funktion `main` aufgerufen
+werden. Beachte, dass wir `another_function` _nach_ der Funktion `main` im
 Quellcode definiert haben; wir hätten sie auch vorher definieren können. Rust
 interessiert es nicht, wo du deine Funktionen definierst, nur dass sie irgendwo
 definiert sind.
@@ -49,9 +49,9 @@ Hallo Welt!
 Eine andere Funktion.
 ```
 
-Die Zeilen werden in der Reihenfolge ausgeführt, in der sie in der
-`main`-Funktion erscheinen. Zuerst wird die Nachricht „Hallo Welt!“ ausgegeben
-und dann wird `another_function` aufgerufen und ihre Nachricht ausgegeben.
+Die Zeilen werden in der Reihenfolge ausgeführt, in der sie in der Funktion
+`main` erscheinen. Zuerst wird die Nachricht „Hallo Welt!“ ausgegeben und dann
+wird `another_function` aufgerufen und ihre Nachricht ausgegeben.
 
 ### Parameter
 
@@ -285,7 +285,7 @@ fn main() {
 ```
 
 Es gibt keine Funktionsaufrufe, Makros oder gar `let`-Anweisungen in der
-`five`-Funktion – nur die Zahl `5` selbst. Das ist eine vollkommen
+Funktion `five` – nur die Zahl `5` selbst. Das ist eine vollkommen
 gültige Funktion in Rust. Beachte, dass der Rückgabetyp der Funktion ebenfalls
 angegeben ist, mit `-> i32`. Versuche diesen Code auszuführen; die Ausgabe
 sollte wie folgt aussehen:

src/ch07-01-packages-and-crates.md

@@ -19,7 +19,7 @@ oder einen Server. Jede muss eine Funktion namens `main` haben, die definiert,
 was passiert, wenn die ausführbare Datei läuft. Alle Kisten, die wir bisher
 erstellt haben, waren binäre Kisten.
 
-_Bibliothekskisten_ (library crates) haben keine `main`-Funktion und sie werden
+_Bibliothekskisten_ (library crates) haben keine Funktion `main` und sie werden
 nicht zu einer ausführbaren Datei kompiliert. Stattdessen definieren sie
 Funktionalität, die für mehrere Projekte gemeinsam genutzt werden soll. Zum
 Beispiel bietet die Kiste `rand`, die wir in [Kapitel 2][rand] verwendet haben,

src/ch07-03-paths-for-referring-to-an-item-in-the-module-tree.md

@@ -266,7 +266,7 @@ an.
 Auf dem absoluten Pfad beginnen wir mit `crate`, der Wurzel des Modulbaums
 unserer Kiste. Dann wird das Modul `front_of_house` in der Kistenwurzel
 definiert. Während das Modul `front_of_house` nicht öffentlich ist, weil die
-`eat_at_restaurant`-Funktion im gleichen Modul wie `front_of_house` definiert
+Funktion `eat_at_restaurant` im gleichen Modul wie `front_of_house` definiert
 ist (d.h. `eat_at_restaurant` und `front_of_house` sind Geschwister), können
 wir auf `front_of_house` von `eat_at_restaurant` aus zugreifen. Als nächstes
 wird das Modul `hosting` mit `pub` gekennzeichnet. Wir können auf das

src/ch09-02-recoverable-errors-with-result.md

@@ -493,7 +493,7 @@ der frühe Rückgabezweig liefert einen `Err(e)`-Wert. Der Rückgabetyp der
 Funktion muss ein `Result` sein, damit er mit `return` kompatibel ist.
 
 Schauen wir uns in Codeblock 9-10 an, was passiert, wenn wir den `?`-Operator
-in einer `main`-Funktion verwenden, deren Rückgabetyp nicht mit dem Typ des
+in einer Funktion `main` verwenden, deren Rückgabetyp nicht mit dem Typ des
 Wertes, für den wir `?` verwenden, kompatibel ist.
 
 <span class="filename">Dateiname: src/main.rs</span>
@@ -506,13 +506,12 @@ fn main() {
 }
 ```
 
-<span class="caption">Codeblock 9-10: Der Versuch, das `?` in der
-`main`-Funktion zu verwenden, die `()` zurückgibt, lässt sich nicht
-kompilieren.</span>
+<span class="caption">Codeblock 9-10: Der Versuch, das `?` in der Funktion
+`main` zu verwenden, die `()` zurückgibt, lässt sich nicht kompilieren.</span>
 
 Dieser Code öffnet eine Datei, was fehlschlagen kann. Der `?`-Operator folgt
-dem `Result`-Wert, der von `File::open` zurückgegeben wird, aber diese
-`main`-Funktion hat den Rückgabetyp `()`, nicht `Result`. Wenn wir diesen Code
+dem `Result`-Wert, der von `File::open` zurückgegeben wird, aber diese Funktion
+`main` hat den Rückgabetyp `()`, nicht `Result`. Wenn wir diesen Code
 kompilieren, erhalten wir folgende Fehlermeldung:
 
 ```console
@@ -644,14 +643,14 @@ Der Typ `Box<dyn Error>` ist ein _Merkmalsobjekt_ (trait object), über das wir
 in [„Merkmalsobjekte (trait objects) die Werte unterschiedlicher Typen
 erlauben“][trait-objects] in Kapitel 18 sprechen werden. Vorerst kannst du
 `Box<dyn Error>` als „eine beliebige Fehlerart“ ansehen. Das Verwenden von `?`
-auf einen `Result`-Wert in einer `main`-Funktion mit dem Fehlertyp `Box<dyn
+auf einen `Result`-Wert in einer Funktion `main` mit dem Fehlertyp `Box<dyn
 Error>` ist erlaubt, weil dadurch ein `Err`-Wert frühzeitig zurückgegeben
-werden kann. Obwohl der Rumpf dieser `main`-Funktion nur Fehler des Typs
+werden kann. Obwohl der Rumpf dieser Funktion `main` nur Fehler des Typs
 `std::io::Error` zurückgibt, ist diese Signatur durch die Angabe von
 `Box<dyn Error>` auch dann noch korrekt, wenn weiterer Code, der andere Fehler
 zurückgibt, dem Rumpf von `main` hinzugefügt wird.
 
-Wenn eine `main`-Funktion ein `Result<(), E>` zurückgibt, beendet sich die
+Wenn eine Funktion `main` ein `Result<(), E>` zurückgibt, beendet sich die
 ausführbare Datei mit einem Wert von `0`, wenn `main` den Wert `Ok(())`
 zurückgibt, und mit einem Wert ungleich Null, wenn `main` einen `Err`-Wert
 zurückgibt. In C geschriebene ausführbare Programme geben beim Beenden ganze

src/ch09-03-to-panic-or-not-to-panic.md

@@ -66,7 +66,7 @@ let home: IpAddr = "127.0.0.1"
 Wir erstellen eine `IpAddr`-Instanz, indem wir eine hartkodierte Zeichenkette
 parsen. Wir können sehen, dass `127.0.0.1` eine gültige IP-Adresse ist, sodass
 es akzeptabel ist, hier `expect` zu verwenden. Eine hartkodierte, gültige
-Zeichenkette ändert jedoch nicht den Rückgabetyp der `parse`-Methode: Wir
+Zeichenkette ändert jedoch nicht den Rückgabetyp der Methode `parse`: Wir
 erhalten immer noch einen `Result`-Wert und der Compiler wird von uns
 verlangen, `Result` so zu behandeln, als ob die `Err`-Variante möglich wäre,
 weil der Compiler nicht klug genug ist, um zu erkennen, dass diese

src/ch10-02-traits.md

@@ -316,7 +316,7 @@ Nachdem wir `summarize_author` definiert haben, können wir `summarize` auf
 Instanzen der `SocialPost`-Struktur aufrufen, und die Standard-Implementierung
 von `summarize` wird die Definition von `summarize_author` aufrufen, die wir
 bereitgestellt haben. Da wir `summarize_author` implementiert haben, hat uns
-das Merkmal `Summary` das Verhalten der `summarize`-Methode mitgeliefert, ohne
+das Merkmal `Summary` das Verhalten der Methode `summarize` mitgeliefert, ohne
 dass wir weiteren Code schreiben müssen. Das sieht dann so aus:
 
 ```rust,ignore
@@ -677,7 +677,7 @@ impl<T: Display> ToString for T {
 ```
 
 Da die Standardbibliothek diese Pauschal-Implementierungen hat, können wir die
-`to_string`-Methode, die durch das Merkmal `ToString` definiert ist, bei jedem
+Methode `to_string`, die durch das Merkmal `ToString` definiert ist, bei jedem
 Typ aufrufen, der das Merkmal `Display` implementiert. Zum Beispiel können wir
 ganze Zahlen in ihre entsprechenden `String`-Werte umwandeln, weil ganze
 Zahlen `Display` implementieren:

src/ch11-03-test-organization.md

@@ -384,7 +384,7 @@ Implementierungsdetails testen. Integrationstests prüfen, ob viele Teile der
 Bibliothek korrekt zusammenarbeiten, und sie verwenden die öffentliche
 Programmierschnittstelle (API) der Bibliothek, um den Code auf die gleiche
 Weise zu testen, wie externer Code ihn verwenden wird. Auch wenn das Typsystem
-und die Eigentümerschaftsregeln von Rust dazu beitragen, einige Fehlerarten zu
+und die Eigentumsregeln von Rust dazu beitragen, einige Fehlerarten zu
 verhindern, sind Tests immer noch wichtig, um Logikfehler zu reduzieren, die
 damit zu tun haben, wie sich dein Code voraussichtlich verhalten wird.
 

src/ch12-01-accepting-command-line-arguments.md

@@ -68,7 +68,7 @@ Importieren von `use std::env::args` und dem anschließenden Aufrufen der
 Funktion nur mit `args`, weil `args` leicht mit einer Funktion verwechselt
 werden könnte, die im aktuellen Modul definiert ist.
 
-> ### Die `args`-Funktion und ungültiger Unicode
+> ### Die Funktion `args` und ungültiger Unicode
 >
 > Beachte, dass `std::env::args` abstürzt, wenn ein Argument einen ungültigen
 > Unicode enthält. Wenn dein Programm Argumente mit ungültigem Unicode