Anhang A: Schlüsselwörter

Die folgende Liste enthält Schlüsselwörter, die für die gegenwärtige oder zukünftige Verwendung durch die Sprache Rust reserviert sind. Als solche können sie nicht als Bezeichner verwendet werden (außer als Roh-Bezeichner, die wir im Abschnitt „Roh-Bezeichner“ besprechen werden). Bezeichner sind Namen von Funktionen, Variablen, Parametern, Strukturfeldern (struct fields), Modulen, Kisten (crates), Konstanten, Makros, statischen Werten, Attributen, Typen, Merkmalen (traits) und Lebensdauern (lifetimes).

Derzeit verwendete Schlüsselwörter

Nachstehend findest du eine Liste der derzeit verwendeten Schlüsselwörter mit einer Beschreibung ihrer Funktion.

  • as – primitive Typen umwandeln; ein spezifisches Merkmal mit einem Element eindeutig machen; Elemente in use-Anweisungen umbenennen
  • async – ein Future zurückgeben, anstatt den aktuellen Strang (thread) zu blockieren
  • await – Ausführung anhalten, bis das Ergebnis eines Future vorliegt
  • break – Schleife sofort verlassen
  • const – konstante Elemente oder konstante Roh-Referenzen definieren
  • continue – weiter zur nächsten Schleifeniteration
  • crate – in einem Modulpfad verweist auf das Stammverzeichnis der Kiste (crate)
  • dyn – dynamischer Aufruf (dispatch) eines Merkmalsobjekts (trait object)
  • else – Ersatzkontrollflusszweig bei if und if let
  • enum – eine Aufzählung (enumeration) definieren
  • extern – externe Funktion oder Variable verlinken
  • false – Boolesches Literal für „falsch“
  • fn – Funktion oder Funktionsreferenztyp definieren
  • for – wiederhole über Elemente einer Iteration; ein Merkmal (trait) implementieren; eine höherrangige Lebensdauer angeben
  • if – Verzweigen abhängig vom Ergebnis eines Bedingungsausdrucks
  • impl – Implementieren einer inhärenten oder Merkmalsfunktionalität (trait functionality)
  • in – Teil der for-Schleifensyntax
  • let – eine Variable binden
  • loop – wiederhole bedingungslos
  • match – einen Wert mit Muster abgleichen
  • mod – ein Modul definieren
  • move – Funktionsabschluss (closure) übernimmt Eigentümerschaft (ownership) all seiner Parameter
  • mut – Referenzen, Roh-Referenzen und Variablenbindungen als veränderbar kennzeichnen
  • pub – Strukturfelder (struct fields), impl-Blöcke und Module als öffentlich sichtbar kennzeichnen
  • ref – als Referenz binden
  • return – aus Funktion zurückkehren
  • Self – Typ-Alias für den zu definierenden oder implementierenden Typ
  • self – Methoden-Instanzobjekt; aktuelles Modul
  • static – globale Variable oder Lebensdauer während der gesamten Programmausführung
  • struct – eine Struktur definieren
  • super – Elternmodul des aktuellen Moduls
  • trait – ein Merkmal (trait) definieren
  • true – Boolesches Literal für „wahr“
  • type – einen Typ-Alias oder assoziierten Typ definieren
  • union – eine Vereinigung (union) definieren; ist nur ein Schlüsselwort innerhalb einer Vereinigungdeklaration
  • unsafe – Code, Funktionen, Merkmale (traits) und Implementierungen als unsicher kennzeichnen
  • use – Symbole in den Gültigkeitsbereich bringen
  • where – Klauseln zur Typabgrenzung angeben
  • while – wiederhole abhängig vom Ergebnis eines Bedingungsausdrucks

Schlüsselwörter reserviert für zukünftige Verwendung

Die folgenden Schlüsselwörter haben noch keine Funktionalität, sondern sind von Rust für eine mögliche zukünftige Verwendung reserviert.

  • abstract
  • become
  • box
  • do
  • final
  • macro
  • override
  • priv
  • try
  • typeof
  • unsized
  • virtual
  • yield

Roh-Bezeichner

Roh-Bezeichner (raw identifiers) sind eine Syntax, die es dir ermöglicht, Schlüsselwörter dort zu verwenden, wo sie normalerweise nicht erlaubt wären. Du verwendest einen Roh-Bezeichner, indem du einem Schlüsselwort das Präfix r# voranstellst.

Zum Beispiel ist match ein Schlüsselwort. Versuche, folgende Funktion zu kompilieren, die match als Namen benutzt:

Dateiname: src/main.rs

#![allow(unused)]
fn main() {
fn match(needle: &str, haystack: &str) -> bool {
    haystack.contains(needle)
}
}

Dann erhältst du diesen Fehler:

error: expected identifier, found keyword `match`
 --> src/main.rs:4:4
  |
4 | fn match(needle: &str, haystack: &str) -> bool {
  |    ^^^^^ expected identifier, found keyword

Der Fehler zeigt, dass du das Schlüsselwort match nicht als Funktionsbezeichner verwenden kannst. Um match als Funktionsnamen zu verwenden, musst du die Syntax für Roh-Bezeichner wie folgt verwenden:

Dateiname: src/main.rs

fn r#match(needle: &str, haystack: &str) -> bool {
    haystack.contains(needle)
}

fn main() {
    assert!(r#match("foo", "foobar"));
}

Dieser Code lässt sich fehlerfrei kompilieren. Beachte das r#-Präfix im Funktionsnamen in seiner Definition sowie an der Stelle, an der die Funktion in main aufgerufen wird.

Roh-Bezeichner erlauben es dir, jedes beliebige Wort als Bezeichner zu verwenden, auch wenn dieses Wort ein reserviertes Schlüsselwort ist. Dies gibt uns mehr Freiheit bei der Wahl der Bezeichner und ermöglicht uns die Integration in Programme, die in einer Sprache geschrieben wurden, in der diese Wörter keine Schlüsselwörter sind. Darüber hinaus ermöglicht dir der Roh-Bezeichner das Verwenden von Bibliotheken, die in einer anderen Rust-Ausgabe, als deine Kiste verwendet, geschrieben wurden. Zum Beispiel ist try in Ausgabe 2015 kein Schlüsselwort, aber in Ausgabe 2018 schon. Wenn du auf eine Bibliothek angewiesen bist, die mit Ausgabe 2015 geschrieben wurde und eine Funktion try hat, musst du die Roh-Bezeichner-Syntax verwenden, in diesem Fall r#try, um diese Funktion von deinem Code der Ausgabe 2018 aus aufzurufen. Siehe Anhang E für weitere Informationen zu Ausgaben.