Open Source im professionellen Einsatz
Linux-Magazin 10/2012
© Dimitri Surkov, 123RF.com

© Dimitri Surkov, 123RF.com

Die Programmiersprache Rust

Mozillas Mixtur

Von der Öffentlichkeit weitgehend unbeachtet arbeitet die Mozilla Foundation an einer eigenen Programmiersprache. Rust soll das Schreiben von zuverlässigen und schnellen nebenläufigen Anwendungen erleichtern. Zu diesem Zweck machen die Entwickler großzügig Anleihen bei anderen Sprachen.

662

Laut Mozilla-CTO Brendan Eich entsteht mit Rust die Programmiersprache der Zukunft: Einerseits biete sie mehr Sicherheit als C++, zum anderen soll mit ihr umfassende Parallelisierung in den Webbrowser einziehen [1]. Der Entwickler Graydon Hoare begann die Arbeit an Rust bereits 2006, drei Jahre später übernahm die Mozilla Foundation das Ruder.

Dennoch dauerte es bis zum Januar 2012, ehe die erste Version mit der Nummer 0.1 erschien. Wie die zaghafte Nummerierung schon andeutet, ist Rust immer noch in einem recht frühen Stadium, Syntax und Semantik können sich noch in allen Teilen ändern. Die folgenden Ausführungen basieren auf der Version 0.3 vom 12. Juli 2012 ([2], Abbildung 1).

Abbildung 1: Die Programmiersprache Rust und ihre Implementierung befinden sich noch im Alphastadium.

Kompiliert

Entgegen allen aktuellen Trends laufen in Rust geschriebene Programme nicht in einer virtuellen Maschine, ein Compiler übersetzt sie in nativen Maschinencode. Dank eingebauter Garbage Collection und des so genannten Reference Counting muss sich der Programmierer dennoch nicht selbst mit der Speicherverwaltung herumschlagen.

Rust mischt imperative, objektorientierte und funktionale Programmierparadigmen. Die meisten Anleihen stammen aus der funktionalen Programmierung sowie aus C. So dient auch in Rust eine »main()« -Funktion als Einsprungspunkt ins Programm. Ein einfaches Hallo-Welt-Beispiel sieht daher wie folgt aus:

fn main() {
 io::println("Hallo Welt!");
}

Lokale Variablen deklariert ein vorangestelltes »let« :

let hallo = "Hallo Welt!";

Eine solche Variable ist standardmäßig unveränderlich. Möchte ihr der Programmierer später einen anderen Wert zuweisen, muss er das explizit mit dem Schlüsselwort »mut« anzeigen:

let mut zaehler = 1;

Den Typ einer Variablen ermittelt Rust normalerweise automatisch. Gibt man ihn dennoch an, steht er im Gegensatz zu vielen anderen statisch typisierten Sprachen hinter dem Variablennamen, abgetrennt durch einen Doppelpunkt:

let mut zaehler: int = 1;

Während Strings in der UTF-8-Zeichenkodierung vorliegen müssen, hat der Rust-Programmierer bei Zahlen die Wahl zwischen verschiedenen Bitgrößen. So ist etwa »zaehler« in

let mut zaehler: i16 = 1;

eine 16 Bit große Integerzahl. Die Größe von »int« orientiert sich dagegen wie in C an der Zielarchitektur.

Vektoren, in anderen Sprachen als Arrays bekannt, erzeugt der Entwickler so:

let x: ~[mut str] = ~[mut "Es", "war","schlecht"];

In diesem Fall entsteht ein Vektor »~[]« , der Strings (»str« ) enthält. Diese darf der Programmierer allesamt nachträglich verändern (»mut« ). Die Anweisung »x[2] = "gut";« verbessert das dritte Wort. Da Rust die Elemente des Vektors mit 0 beginnend nummeriert, greift »[2]« auf das dritte Element des Vektors zu.

Funktionsdefinitionen sehen in Rust etwas merkwürdig aus:

fn ggT(x: int, y: int) -> int { ... }

Das Schlüsselwort »fn« leitet die Funktionsdefinition ein. In den runden Klammern stehen die zu übergebenden Parameter. Im Gegensatz zu anderen Sprachen notiert der Rust-Anwender auch hier erst den Variablennamen und dann den zugehörigen Typ. Welchen Datentyp die Funktion zurückliefert, steht hinter dem Pfeil »->« . Diese Notation ist notwendig, da in Rust eine Funktion mehrere Werte zurückgeben kann:

fn beispiel() -> int, str, float { ... }

Die Kontrollstrukturen »if« und »while« ähneln schon wieder mehr ihren C-Vorbildern, verzichten aber auf die runden Klammern um die Bedingung. Listing 1 zeigt dafür ein Beispiel.

Listing 1

Größter gemeinsamer Teiler

01 fn ggt(c: int, d: int) -> int {
02         let mut a = c;
03         let mut b = d;
04
05         if a==0 { ret b; }
06         else {
07                 while b != 0 {
08                         if a > b {
09                                 a = a-b;
10                         }
11                         else {
12                                 b = b-a;
13                         }
14                 }
15         }
16         ret a;
17 }
18
19 fn main() {
20         let ergebnis = ggt(16,6);
21
22         io::println(#fmt("%d", ergebnis));
23 }

Angemerkt

Kommentare stehen in Rust zwischen »/*« und »*/« . Zudem darf der Entwickler Funktionen mit so genannten Annotationen ausstatten, die Meta-Informationen angeben. Daneben können diese Anmerkungen sogar bestimmte Aktionen steuern. Zum Beispiel würde in

#[cfg(windows)]
fn nur_fuer_windows() { ... }

die Funktion nur unter Windows übersetzt. Die Annotation »#[cfg(windows)]« leistet hier das Gleiche wie ein entsprechendes »#ifdef« in C.

Diesen Artikel als PDF kaufen

Express-Kauf als PDF

Umfang: 5 Heftseiten

Preis € 0,99
(inkl. 19% MwSt.)

Linux-Magazin kaufen

Einzelne Ausgabe
 
Abonnements
 
TABLET & SMARTPHONE APPS
Bald erhältlich
Get it on Google Play

Deutschland

Ähnliche Artikel

comments powered by Disqus

Ausgabe 10/2017

Digitale Ausgabe: Preis € 6,40
(inkl. 19% MwSt.)

Artikelserien und interessante Workshops aus dem Magazin können Sie hier als Bundle erwerben.