C1ph4: Die Seite wurde neu angelegt: „{{Infobox Programmiersprache | Name = Rust | Logo = [[Datei:Rust programming language black logo.svg|120px]…“

2018-05-22T17:14:39Z

Die Seite wurde neu angelegt: „{{Infobox Programmiersprache | Name = Rust | Logo = [[Datei:Rust programming language black logo.svg|120px]…“

Neue Seite

{{Infobox Programmiersprache
| Name = Rust
| Logo = [[Datei:Rust programming language black logo.svg|120px]]
| Beschreibung =
| Paradigma = [[Programmierparadigma|Multiparadigmen]] ([[Generische Programmierung|generisch]], [[Nebenläufigkeit|nebenläufig]], [[Funktionale Programmierung|funktional]], [[Imperative Programmierung|imperativ]], [[Strukturierte Programmierung|strukturiert]])
| Erscheinungsjahr = 2010; erste stabile Version 2015
| Designer =
| Entwickler = Früher Graydon Hoare, heute Rust Project Developers
| AktuelleVersion = 1.26.0
| AktuelleVersionFreigabeDatum = {{Datum|10|05|2018}}<ref>[https://blog.rust-lang.org/2018/05/10/Rust-1.26.html], The Rust Core Team, 10. Mai 2018</ref>
| AktuelleVorabVersion =
| AktuelleVorabVersionFreigabeDatum =
| Typisierung = [[Starke Typisierung|stark]], [[Statische Typisierung|statisch]], [[Lineares Typsystem|linear]], [[Typinferenz]]
| Implementierung =
| Dialekte =
| Standardisierungen =
| Beeinflusst_von =
| Beeinflusste =
| Betriebssystem = [[Linux]], [[macOS]], [[Microsoft Windows|Windows]], [[FreeBSD]], [[Android (Betriebssystem)|Android]], [[Apple iOS|iOS]]<ref>{{cite web|url=https://github.com/rust-lang/rust/wiki/Doc-building-for-ios |title=Doc building for ios |website=GitHub |accessdate=2015-01-04}}</ref>
| Lizenz = [[Apache License]] 2.0 und [[MIT License]]<ref name="'license'">{{cite web | url = https://github.com/mozilla/rust/blob/master/COPYRIGHT | title = COPYRIGHT | accessdate = 2012-12-17 | publisher=Rust compiler source repository}}</ref>
| Website = [https://www.rust-lang.org/ rust-lang.org]
| dialects =
}}

'''Rust''' ist eine [[Programmierparadigma|Multiparadigmen]]-[[Systemprogrammiersprache]], entwickelt von [[Mozilla]] Research.<ref name="lamda">{{cite web|url = https://www.mozilla.org/en-US/research/projects/|title = Mozilla Research Projects|author = |date = |publisher = Mozilla Research|accessdate = 2015-05-19}}</ref> Sie wurde entwickelt, um eine sichere, [[Nebenläufigkeit|nebenläufige]] und praxisnahe Sprache zu sein.<ref name="rust-lang">{{cite web|url=https://www.rust-lang.org/|title=The Rust Programming Language|accessdate=2012-10-21}}</ref> Sicherheit bedeutet hier, dass solche [[Programmierfehler]] weitgehend ausgeschlossen werden, die zu [[Zugriffsverletzung|Speicherzugriffsfehlern]] oder [[Pufferüberlauf|Pufferüberläufen]] und damit häufig zu [[Sicherheitslücke (Software)|Sicherheitslücken]] führen. Im Gegensatz zu anderen Programmiersprachen mit automatischer [[Speicherverwaltung]] verwendet Rust hierfür keine [[Garbage Collection]], sondern setzt auf ein besonderes [[Typsystem]], eine bei funktionalen Sprachen übliche Eigenschaft.

Rust vereint Ansätze aus verschiedenen [[Programmierparadigma|Programmierparadigmen]], unter anderem aus der [[Funktionale Programmierung|funktionalen]], der [[Objektorientierte Programmierung|objektorientierten]] und der [[Nebenläufige Programmierung|nebenläufigen]] Programmierung, und erlaubt so ein hohes [[Abstraktion (Informatik)|Abstraktionsniveau]]. Beispielsweise gibt es in Rust algebraische Datentypen, [[Pattern Matching]], [[Trait (Programmierung)|Traits]] (ähnlich den Typklassen in [[Haskell (Programmiersprache)|Haskell]]), [[Closure (Funktion)|Closures]], sowie Unterstützung für [[Ressourcenbelegung ist Initialisierung|RAII]]. Die Sprache wurde so entworfen, dass die Kosten der Abstraktionen zur [[Laufzeit (Informatik)|Laufzeit]] so gering wie möglich bleiben können (''zero-cost abstractions''), um eine mit [[C++]] vergleichbare [[Effizienz (Informatik)|Effizienz]] zu erreichen.<ref>{{Internetquelle |url=https://doc.rust-lang.org/complement-lang-faq.html#how-fast-is-rust? |titel=The Rust Language FAQ: How fast is Rust? |autor=The Rust Project Developers |hrsg= |werk= |datum= |sprache=en |zugriff=2015-05-19 |zitat=That said, it is an explicit goal of Rust to be as fast as C++ for most things.}}</ref>

Die Sprache entstand aus einem persönlichen Projekt des Mozilla-Mitarbeiters Graydon Hoare. Mozilla begann das Sponsoring des Projekts im Jahr 2009.<ref name="proj-faq">{{cite web|url=https://github.com/mozilla/rust/wiki/Doc-project-FAQ|title=Project FAQ|date=2010-09-14|accessdate=2012-01-11}}</ref> Es wurde 2010 zum ersten Mal angekündigt.<ref name="future-tense">{{cite web|url=https://www.slideshare.net/BrendanEich/future-tense-7782010|title=Future Tense|date=2011-04-29|accessdate=2012-02-06|quote=At Mozilla Summit 2010, we launched Rust, a new programming language motivated by safety and concurrency for parallel hardware, the “manycore” future which is upon us.}}</ref> Im selben Jahr begann der Wechsel von einem (noch in [[OCaml]] geschriebenen) ersten [[Compiler]] zu einem neuen Compiler, der selbst in Rust geschrieben ist.<ref name="rust-in-rust">{{Internetquelle |url=http://blog.mozilla.com/graydon/2010/10/02/rust-progress/ |titel=Rust Progress |sprache=en |autor=Graydon Hoare |werk=Graydon’s work on Mozilla |datum=2010-10-02 |archiv-url=https://web.archive.org/web/20120319230524/http://blog.mozilla.com/graydon/2010/10/02/rust-progress/ |archiv-datum=2012-03-19 |zugriff=2016-04-03}}</ref> Dieser ''rustc'' genannte Compiler verwendet [[LLVM]] als [[Front-End und Back-End|Back-End]] und kann sich seit 2011 erfolgreich selbst übersetzen.<ref name="rust-compiles-rust">{{cite web|url=https://mail.mozilla.org/pipermail/rust-dev/2011-April/000330.html|title=[rust-dev] stage1/rustc builds|last=Hoare|first=Graydon|date=2011-04-20|accessdate=2011-04-20|quote=After that last change fixing the logging scope context bug, looks like stage1/rustc builds. Just shy of midnight :)}}</ref> Eine erste stabile Version von Compiler und [[Standardbibliothek]], Rust 1.0, wurde am 15. Mai 2015 veröffentlicht.<ref name="rust-1.0">[https://blog.rust-lang.org/2015/05/15/Rust-1.0.html Announcing Rust 1.0]</ref>

== Sprachdesign ==
=== Syntax, Sprachkonstrukte ===
Syntaktisch ist die Sprache an [[C (Programmiersprache)|C]] angelehnt. Mehrere aufeinanderfolgende Anweisungen werden durch ein [[Semikolon]] getrennt, Blöcke stehen in geschweiften Klammern. In vielen Details weicht die [[Syntax]] allerdings davon ab, so werden beispielsweise keine Klammern um die Bedingungen von <code>if</code>- und <code>while</code>-Statements benötigt, stattdessen aber geschweifte Klammern um den dahinterstehenden Block erzwungen, auch wenn dort nur eine Anweisung steht. Das Schlüsselwort <code>for</code> leitet in Rust immer eine [[Foreach-Schleife]] ein, die das Iterieren über beliebige (auch benutzerdefinierte) Container und Objekte ermöglicht. Anstelle des <code>switch</code>-Statements gibt es die wesentlich mächtigeren <code>match</code>-Ausdrücke, die nicht nur mit Zahlen und Zeichenketten umgehen können, sondern [[Pattern Matching]] auf beliebig verschachtelten Strukturen durchführen können.

Variablen werden normalerweise klein (in Snake case) geschrieben, Datentypen mit Ausnahme der primitiven mit großem Anfangsbuchstaben (in Camel case). Typparameter von generischen Typen und Funktionen stehen in spitzen Klammern. Zwei Doppelpunkte drücken aus, dass der Bezeichner auf der rechten Seite aus dem Namensraum des Bezeichners auf der linke Seite entstammen soll. Die Bindung eines Bezeichners <code>x</code> an einen Wert wird
: <code>let x: Typ = Wert;</code>
geschrieben, wobei die Angabe des Typs auch entfallen darf, wenn der Typ [[Typinferenz|inferiert]] werden kann. Eine Variablen-Deklaration für die Variable <code>v</code> hat die Form:
: <code>let mut v: Typ = Initialwert;</code>
oder allgemeiner:
: <code>let mut v: Typ;</code><br /><code>v = Wert;</code>
Der Compiler überprüft mittels [[Datenflussanalyse]], dass alle Bindungen und Variablen vor dem Auslesen initialisiert wurden. Verwendung von uninitialisiertem Speicher ist nur über einen speziellen Befehl möglich, welcher zwingend mit <code>unsafe</code> markiert werden muss.

=== Typsystem ===
Benutzerdefinierte Datentypen können entweder als <code>struct</code> ([[Struktur (Datentyp)|Struktur]] wie in C) oder als <code>enum</code> ([[Verbund (Datentyp)#Unions|tagged-Union]]) definiert werden. Für beide Arten von Datentypen kann man mittels des <code>impl</code>-Schlüsselswortes [[Methode (Programmierung)|Methoden]] definieren. Die sonst für [[objektorientierte Programmierung]] übliche [[Vererbung (Programmierung)|Vererbung]] gibt es in Rust allerdings nicht, [[Polymorphie (Programmierung)|Polymorphie]] wird stattdessen durch Traits und [[generische Programmierung]] ermöglicht. Ein Trait definiert eine Menge von Funktionen und Methoden, die dann jeweils zusammen von Datentypen implementiert werden und bei [[Generischer Typ|Typparametern]] als Einschränkung für die erlaubten Typen dienen können. Dies wird auch für Operatoren verwendet, sodass beispielsweise der Operator <code>+</code> mit jedem Datentyp verwendet werden kann, der den Trait <code>Add</code> implementiert.<ref>[https://static.rust-lang.org/doc/stable/std/ops/trait.Add.html Dokumentation des „Add“-Traits]</ref> Alle Funktions-, Methoden- und Operatoraufrufe werden dabei statisch gebunden, wodurch dem Compiler einige [[Programmoptimierung|Optimierungen]] ermöglicht werden, allerdings kann über sogenannte ''Trait-Objects'' auch mittels [[Dynamische Bindung|dynamischer Bindung]] auf Trait-Methoden zugegriffen werden. Es ist erlaubt, sowohl existierende Traits aus fremdem Code für benutzerdefinierte Typen, als auch neue, benutzerdefinierte Traits für existierende Typen zu implementieren.

=== Zeiger, Speicherverwaltung ===
Rust kennt neben den sogenannten Raw-[[Zeiger (Informatik)|Pointern]], die Zeigern in C entsprechen und nur in explizit als <code>unsafe</code> markiertem Code dereferenziert werden dürfen, auch noch [[Referenz (Programmierung)|Referenzen]]. Diese zeigen immer auf gültigen Speicher und dürfen niemals den Wert [[Zeiger (Informatik)#Nullzeiger|null]] annehmen. Es werden zwei verschiedene Arten von Referenzen unterschieden: gemeinsame Referenzen (''shared references''), eingeleitet durch <code>&</code>, und veränderbare Referenzen (''mutable references''), eingeleitet durch <code>&mut</code>. Der Rust-Compiler garantiert [[Statische Code-Analyse|statisch]], dass keine Referenz das von ihr referenzierte Objekt [[Variable (Programmierung)#Lebensdauer von Variablen|„überlebt“]], dass das referenzierte Objekt nicht verändert wird, während eine Referenz (egal ob gemeinsam oder veränderbar) existiert, und dass eine veränderbare Referenz – wenn eine solche existiert – stets die einzige Referenz auf ein Objekt ist, sodass Veränderungen am Objekt vorgenommen werden können, ohne dabei Referenzen zum selben Objekt an anderen Stellen im Code oder sogar in anderen [[Thread (Informatik)|Threads]] ungültig zu machen.

Das Erstellen von Referenzen wird auch als ''Borrowing'' (Ausleihen) bezeichnet, und bildet zusammen mit dem Konzept der ''Ownership'' (Besitz) die Grundlage für die sichere Speicherverwaltung ohne Garbage Collection. ''Ownership'' bedeutet hier, dass jedes Objekt im Speicher im Besitz derjenigen Variable ist, der es bei der Erstellung zugewiesen wird. Am Ende der [[Variable (Programmierung)#Lebensdauer von Variablen|Lebensdauer]] dieser Variable wird der Speicher automatisch freigegeben. Für die meisten komplexeren Datentypen verwendet Rust die sogenannte ''Move''-[[Semantik]], sodass bei Zuweisung eines Objektes zu einer anderen Variablen das Objekt „verschoben“ wird, und ein Zugriff auf die alte Variable daraufhin nicht mehr möglich ist. Auch beim Übergeben von Objekten als [[Wertparameter]] an Funktionen (''call by value'') werden solche Objekte in die Funktion „hineingeschoben“ und sind von außen nicht mehr zugreifbar, wenn sie nicht wieder von der Funktion zurückgegeben werden. [[Datentyp#Elementare Datentypen|Primitive Datentypen]] verwenden keine ''Move''-Semantik, sondern die sonst übliche ''Copy''-Semantik (Zuweisungen erstellen eine Kopie), und bei benutzerdefinierten Datentypen kann mittels des ''Copy''-Traits selbst entschieden werden, ob ''Move''- oder ''Copy''-Semantik verwendet werden soll.

Zur dynamischen Speicherverwaltung stehen die [[Intelligenter_Zeiger|Smart-Pointer-Typen]] <code>Box</code>, <code>Rc</code> und der Hilfstyp <code>RefCell</code> zur Verfügung, welche einerseits dem System Ownership-Borrowing-Lifetime-Move unterworfen sind, dieses System andererseits auf die Laufzeitdynamik übertragen. Der Typ <code>Box<T></code> beschreibt einen besitzenden Zeiger auf einen Wert vom Typ <code>T</code> im dynamisch allozierten Speicher. Der Typ <code>Rc<T></code> beschreibt über [[Referenzzählung]] einen gemeinschaftlichen Besitz auf einen unveränderlichen Wert. Ein unveränderlicher Wert kann jedoch veränderliche inneren Daten vom Typ <code>RefCell<T></code> besitzen, wobei jeweils ein Referenzzähler für einen Zugriff analog zu <code>&</code> und <code>&mut</code> das sichere dynamische Borrowing durch Prüfung zur Laufzeit ermöglicht.

Mit <code>Rc</code> allein ist keine Dynamik zyklischer Datenstrukturen möglich. Hierzu kann wieder <code>RefCell</code> herangezogen werden, wobei die Zyklen manuell aufgebrochen werden müssen, damit es nicht zu einem [[Speicherleck]] kommt. Als alternatives Konzept ist der Zeigertyp <code>Weak<T></code> vorhanden, bei dem die Zeiger analog zu <code>Rc</code> sind, jedoch keinen Besitz am Wert haben. Zur Umsetzung von <code>Weak</code> ist in <code>Rc</code> ein zweiter Referenzzähler implementiert. Ein Zeiger vom Typ <code>Weak</code> verhindert zwar nicht den Destruktor-Aufruf beim Verschwinden aller Zeiger vom Typ <code>Rc</code>, die Deallokation des brach liegenden Knotens geschieht dann allerdings erst beim Verschwinden des letzten Zeigers vom Typ <code>Weak</code>. Die Destruktor-Aufrufe sorgen dabei für ein automatisches Aufbrechen der Zyklen.

Für die nebenläufige Programmierung ist ein Austausch von <code>Rc</code> gegen <code>Arc</code>, und <code>RefCell</code> gegen die analogen Konzepte <code>Mutex</code> oder <code>RwLock</code> notwendig.

[[Zeiger_(Informatik)#Nullzeiger|Nullzeiger]] kommen in Rust nicht vor. Abwesenheit eines Werts wird stattdessen durch den Typ <code>Option<T></code> modelliert, welcher es als <code>enum</code> ermöglicht, zwischen <code>Some(T)</code> (Vorhandensein) und <code>None</code> (Abwesenheit) zu unterscheiden. Die Verwendung von Optionen ist nicht auf Zeiger beschränkt. Möchte man z. B. einen großen Teil einer <code>struct</code> zunächst uninitialisiert lassen, dann kann man diesen als innere <code>struct</code> hinter einer Option verbergen und mit <code>None</code> initialisieren.

=== Fehlerbehandlung ===
In Rust gibt es die in vielen Sprachen vorhandene Ausnahmebehandlung mit automatischem Stack unwinding nicht. Stattdessen werden Fehler als gewöhnliche Rückgabewerte von Funktionen modelliert. Zur strengen Typisierung dient dabei der Typ <code>Result<T,E></code>, welcher als <code>enum</code> formuliert ist, um zwischen <code>Ok(T)</code> (normale Werte) und <code>Err(E)</code> (Fehlerwerte) unterscheiden zu können.

Ein Laufzeitnachteil entsteht bei der Rückgabe von <code>enum</code> bzw. <code>struct</code> in vielen Fällen nicht, da der Compiler in der Lage ist, für größere Objekte automatisch Zeiger zu erzeugen und Nullzeiger-Optimierungen durchzuführen.

== "Hello, world"-Funktion ==
<syntaxhighlight lang="rust">
fn main() {
println!("Hello, world!");
}
</syntaxhighlight>

Das obige Beispiel gibt den Text <code>Hello, world!</code> am Ausgabemedium aus. <code>println!()</code> ist hierbei keine gewöhnliche [[Funktion (Programmierung)|Funktion]], sondern ein [[Makro]]. Die Funktionsdeklaration erfolgt in Rust mit dem [[Schlüsselwort (Programmierung)|Schlüsselwort]] <code>fn</code>.

== Verwendung ==
Der Rust-Compiler wird standardmäßig mit [[Cargo (Software)|Cargo]], einer [[Paketverwaltung]] für Rust-Software, ausgeliefert, die verwendete [[Programmbibliothek|Bibliotheken]] automatisch herunterlädt und Abhängigkeiten auflöst. Eine Vielzahl wiederverwendbarer [[Open Source|Open-Source]]-Komponenten stehen im offiziellen Paket-[[Repository]] ''crates.io''<ref>{{Internetquelle |url=https://crates.io/ |titel=The Rust community’s crate host |sprache=en |zugriff=2017-04-03}}</ref> zur Verfügung.


Rust findet darüber hinaus unter anderem in folgenden Projekten Verwendung:
* [[Mozilla Firefox]]<ref>{{Internetquelle |url=https://hacks.mozilla.org/2016/07/shipping-rust-in-firefox/ |titel=Shipping Rust in Firefox |sprache=en |autor=Dave Herman |werk=Mozilla Hacks |datum=2016-07-12 |zugriff=2017-04-02}}</ref><ref>{{Internetquelle |url=https://wiki.mozilla.org/Quantum |titel=Quantum |sprache=en |werk=Mozilla Wiki |zugriff=2017-04-03}}</ref>
* [[Servo (Software)|Servo]] – eine neue [[Layout-Engine]] für [[Webbrowser]] von [[Mozilla]].<ref>{{Internetquelle |url=https://www.heise.de/newsticker/meldung/Mozilla-veroeffentlicht-erste-Preview-der-neuen-Browser-Engine-Servo-3253464.html |werk=[[Heise Newsticker]] |zugriff=2016-07-04 |datum=2016-07-04 |titel=Mozilla veröffentlicht erste Preview der neuen Browser-Engine Servo |autor=Rainald Menge-Sonnentag}}</ref>
* Redox OS – ein [[Unixoides System|unixähnliches]], in Rust geschriebenes Betriebssystem mit [[Mikrokernel|Microkernel]]. Es ist [[Freie Software|frei]], [[Open Source|Open-Source]] und steht unter der [[MIT-Lizenz]].<ref>{{cite news|last1=Yegulalp|first1=Serdar|title=Rust’s Redox OS could show Linux a few new tricks|url=http://www.infoworld.com/article/3046100/open-source-tools/rusts-redox-os-could-show-linux-a-few-new-tricks.html|accessdate=2016-03-21|publisher=infoworld}}</ref><ref>{{Literatur |Titel=Redox OS: Wer nicht rustet, rostet - Golem.de |Online=https://www.golem.de/news/redox-os-wer-nicht-rustet-rostet-1612-124867.html |Abruf=2018-02-12}}</ref>
* Magic Pocket – Software, die auf den Diskotech-[[Storage]]-Servern von [[Dropbox]] läuft und mit Datenmengen im [[Petabyte]]-Bereich umgeht.<ref>{{Internetquelle |url=https://www.wired.com/2016/03/epic-story-dropboxs-exodus-amazon-cloud-empire/ |titel=The Epic Story of Dropbox’s Exodus From the Amazon Cloud Empire |sprache=en |autor=Cade Metz |datum=2016-03-14 |hrsg=[[Wired]] |zugriff=2017-04-03}}</ref>
* [[OpenDNS]] – verwendet Rust in zwei Softwarekomponenten.<ref>{{cite web|last1=Frank|first1=Denis|title=Using HyperLogLog to Detect Malware Faster Than Ever|url=https://labs.opendns.com/2013/12/05/hyperloglog-and-malware-detection/|website=OpenDNS Security Labs|accessdate=2016-03-19}}</ref><ref>{{cite web|last1=Denis|first1=Frank|title=ZeroMQ: Helping us Block Malicious Domains in Real Time |url=https://labs.opendns.com/2013/10/04/zeromq-helping-us-block-malicious-domains/|website=OpenDNS Security Labs|accessdate=2016-03-19}}</ref>
* ripgrep – eine in Rust geschriebene, plattformübergreifende und auf Geschwindigkeit optimierte Alternative zu [[grep]].<ref>{{Internetquelle |url=http://blog.burntsushi.net/ripgrep/ |titel=ripgrep is faster than {grep, ag, git grep, ucg, pt, sift} |sprache=en |autor=Andrew Gallant |datum=2016-09-23 |werk=Andrew Gallant’s Blog |zugriff=2017-04-03}}</ref>

== Externe Links ==
* {{Internetquelle|url=https://rustbyexample.com/ |titel=Introduction - Rust By Example |autor= |werk=rustbyexample.com | sprache=en |datum= |zugriff=2018-02-09}}

== Einzelnachweise ==
<references/>

[[Kategorie:Programmiersprache]]
[[Kategorie:Mozilla]]

Rust (Programmiersprache) - Versionsgeschichte

C1ph4: Die Seite wurde neu angelegt: „{{Infobox Programmiersprache | Name = Rust | Logo = [[Datei:Rust programming language black logo.svg|120px]…“