Rust (programovací jazyk)

**Rust** je slobodný viacúčelový, multiparadigmatický, kompilovaný programovací jazyk, vyvinutý organizáciou Mozilla Research. Je navrhnutý ako programovací jazyk so zameraním na výkon, spoľahlivosť a produktivitu,  podporujúci čisto funkcionálne, imperatívno-procedurálne, štrukturované a objektovo orientované programovacie štýly. 

Vysoký výkon je umožnený absenciou behového prostredia a zberača odpadu. Spoľahlivosť zabezpečuje model vlastníctva, ktorý garantuje bezpečnosť pri práci s pamäťou a s viacerými vláknami. Produktivitu zabezpečuje rozsiahla dokumentácia, priateľský kompilátor, integrovaný manažér externých balíčkov a podpora moderných vývojových prostredí.

## História
Rust vznikol v roku 2006 ako bočný projekt Graydona Hoarea, zamestnanca firmy Mozilla. Mozilla si uvedomila potenciál nového jazyka a začala ho sponzorovať od roku 2009. Jazyk bol predstavený verejnosti roku 2010. 

Ten istý rok sa práce posunuli z počiatočného prekladača (naprogramovaného v OCaml) do seba-hostujúceho prekladača napísaného v Ruste. Tento, známy ako rustc, úspešne preložil sám seba v roku 2011. rustc používa LLVM ako svoj backend. 

Graydon viedol projekt po technickej stránke do roku 2013, kedy vystúpil z Rust tímu kvôli osobným dôvodom.

Prvé pred-alfa vydanie Rust kompilátora sa uskutočnilo v januári 2012. Rust 1.0, prvá stabilná verzia bolo vydaná 15. mája 2015. Nasledujúc verziu 1.0, ďalšie stabilné verzie sa vydávajú každých 6 týždňov, rozšírenia sú k dispozícií v nočných verziách a následne testované v beta verziách.

V auguste 2020 Mozilla prepustila 250 zamestnancov z dôvodu reštrukturalizácie. Medzi týmito zamestnancami bola aj väčšina Rust tímu. Týždeň potom Rust Core tím oznámil plán vytvorenia Rust nadácie, ktorej primárnou úlohou je prevziať plné vlastníctvo ochrannej známky Rust jazyka. V novembri 2020 Amazon Web Services oznámili, že sa zaväzujú podporiť pokračovanie jazyka a že sami plánujú zvýšené nasadenie Rust jazyka v ich vlastných produktoch.

Momentálne je Rust spravovaný jeho komunitou, ktorá sa organizuje do tímov a pracovných skupín, ktoré sa zameriavajú na jednotlivé aspekty jazyka (napr. jadro, kompilátor, vývojové nástroje atď.). Menšie úpravy alebo opravy chýb sú implementované bežnou formou GitHub pull žiadosti. Závažnejšie zmeny sa uvádzajú do jazyka procesom RFC.

## Dizajn
Cieľom Rust je byť dobrým jazykom pre vytváranie vysoko paralelných a vysoko bezpečných systémov. Toto bol základ pre súbor vlastností s dôrazom na bezpečnosť, kontrolu rozvrhnutia pamäte, a paralelizmu. Výkon Rustu je porovnateľný s výkonom C++.

Syntax Rustu je podobná syntaxi C a C++, s blokmi kódu ohraničenými zloženými zátvorkami, a riadiace kľúčové slová ako `if`, `else`, `while` a `for`. Nie všetky kľúčové slova jazykov C a C++ sú prítomné, zatiaľ čo niektoré ďalšie (ako napríklad `match` pre viacnásobné skoky, podobné príkazu `switch` v iných jazykoch) boli zamenené alebo pridané. I cez syntaktickú podobnosť je Rust sémantický veľmi odlišný od C a C++.

### Hello, World!
Príklad "Hello, World!" programu v jazyku Rust vyzerá následovne:


```rust
fn main() {
    println!("Hello, World!");
}
```


Funkcia `fn main()` je spustená prvá. Telo funkcie je uzavrete v zložených zátvorkách. Výkričník v príkaze `println!` je špeciálnym označením volania makra. Reťazec `"Hello, World!` je argument makra. Príkaz je ukončený bodkočiarkou. 

### Dátové typy
Dátové typy sú rozdelene medzi skalárne a zložené. Skalárne typy reprezentujú jedinú hodnotu a patria sem `integer`/`float` bytové variácie (napr. 32 bitové číslo so znamienkom `i32` alebo bez znamienka `u32`), pravdivostný typ `bool` a znakový typ `char`. Medzi zložené typy patria n-tice `tuple` a polia `array`. 

### Premenné
Rust umožňuje odvodenie typu (po anglicky „type-interference“) deklaróvaných premenných použitím kľúčového slova `let`. Premenné sú v predvolenej forme nemenné. Premennú ktorej hodnota sa počas vykonávania mutuje musí programátor explicitne označiť kľúčovým slovom `mut`. Týmto spôsobom sa Rust snaží preferovať koncept nemennosti, ktorý vedie ku zvýšenej bezpečnosti, hlavne v paralelnom programovaní. Rust taktiež disponuje konštantami, ktoré sú taktiež nemenné ale rozlišujú sa od nemutovateľných premenných.

### Funkcie
Funkcie, ktoré vracajú hodnotu v Rust musia mať explicitne deklarovaný typ návratovej hodnoty. Návratová hodnota je automaticky prevzatá z posledného výrazu (pozn: príkaz je ukončený bodkočiarkou, výraz nie).  Funkcie môžu používať generické parametre, ale tie musia byť viazané traity. Neexistuje spôsob ako obísť signatúry typov, a pritom vo funkciách a operátoroch využívať generické premenné.

### Traity
Typový systém podporuje typ trait, ktorý je podobný typu trieda. Trait je priamo inšpirovaný jazykom Haskell. Jedná sa o nastroj pre ad-hoc polymorfizmus, čo bolo dosiahnuté zákazom písania deklarácii premenných. Ďalšie vlastnosti z jazyka Haskell, ako higher-kinded polymorfizmus, zatiaľ nie sú pridané.


```rust
trait MaObsah {
    fn obsah(&self) -> f64;
}

struct Kruh {
    x: f64,
    y: f64,
    polomer: f64,
}

impl MaObsah for Kruh {
    fn obsah(&self) -> f64 {
        std::f64::consts::PI * (self.polomer * self.polomer)
    }
}

struct Stvorec {
    x: f64,
    y: f64,
    strana: f64,
}

impl MaObsah for Stvorec {
    fn obsah(&self) -> f64 {
        self.strana * self.strana
    }
}

fn vypis_obsah(tvar: impl MaObsah) {
    println!("Tento utvar ma obsah {}", tvar.obsah());
}

fn main() {
    let c = Kruh {
        x: 0.0f64,
        y: 0.0f64,
        polomer: 1.0f64,
    };

    let s = Stvorec {
        x: 0.0f64,
        y: 0.0f64,
        strana: 1.0f64,
    };

    vypis_obsah(c);
    vypis_obsah(s);
}
```


Objektový systém v Ruste je založený okolo implementácií traitov a štruktúr. Ich použitie nahrádza role tried v iných (objektovo-orientovaných) jazykoch a je definované kľúčovým slovom impl. Dedičnosť a polymorfizmus sú poskytované traitmi; umožňujú ich metódy, ktoré sú definované v mixinoch k implementácií. Štrukturované typy sú použité pre definíciu členských premenných. Implementácia a traity nemôžu samé definovať členské premenné a iba traity môžu poskytovať dedičnosť. Tým sa predchádza diamantovému problému jazyka C++.

### Správa pamäte
**Model vlastníctva** zabezpečuje bezpečné používanie pamäte a tým preberá úlohu garbage kolektora. Program je skontrolovaný súborom pravidiel počas kompilácie, takže tento systém nemá žiadne negatívne následky na výkon počas behu programu.

Pravidlá:

* každá hodnota má premennú, ktorá je vlastníkom
* vlastníci sa môžu striedať ale v jednom čase môže byť len jeden vlastník
* ak premenná – vlastník sa dostane mimo oblasť pôsobnosti, hodnota je zahodená

Príklad:

```rust
let s1 = String::from("hello");
let s2 = s1;
println!("{}, world!", s1);
```

Daný program nie je možné skompilovať pretože v makre `println!` sa snažíme čítať hodnotu premennej `s1`, ktorá už nie je vlastníkom. Táto operácia sa nazýva „presun“ (po anglicky „move“). 

Kód by bol správny ak by sme najprv naklonovali hodnotu a tú priradili premennej `s2`:


```rust
let s1 = String::from("hello");
let s2 = s1.clone();
println!("{}, world!", s1);
```


Klonovanie je však drahšie a menej efektívne, pretože rovnaká hodnota je uložená v heap pamäti dvakrát.

Na rozdiel od dynamických hodnôt, statické hodnoty sa kopírujú. Takže ak sa numerická hodnota jednej premennej priradí druhej, tak na pozadí sa integer byty skopírujú na stack pamäti. 

Volanie funkcie s argumentom tiež presúva hodnotu do premennej v oblasti pôsobenia tela funkcie. Podobne, navrátenie hodnoty mení vlastníka z premennej funkcie na premennú, do ktorej sa číta návratová hodnota. Na obídenie ťažkopádnych presunov do a z funkcií je možné poslať ako argument smerník na hodnotu. Táto operácia sa v Rust nazýva „zapožičanie“ (po anglicky „borrowing“). Pravidlá nie sú porušené, pretože premenná vo funkcií nie je vlastníkom ozajstnej hodnoty ale vlastníkom adresy. Adresy sú statické hodnoty, takže tie sa v pamäti kopírujú.

Smerník v predvolenej forme neumožňuje meniť referovanú hodnotu. Rust disponuje mutovateľnými smerníkmi, ale na tie sa vzťahujú ďalšie pravidla, ktoré zabraňujú komplikáciám spôsobených „pretekmi o dáta“ (po anglicky „data race“). Na zamedzenie „voľne visiacich“ (po anglicky "dangling") smerníkov, Rust neumožňuje jednoducho zapožičať smerník ako návratovú hodnotu funkcie bez definovania „životnosti“ (po anglicky „lifetime“) hodnoty.

## Adopcia
Rust bol tretí najobľúbenejší programovací jazyk v Stack Overflow prieskume roka 2015 a na prvom mieste v rokoch 2016 až 2020.

### Webový prehliadač
* Servo – bezpečné a paralelné vykresľovacie jadro, ktoré vyvíja Mozilla a Samsung.
* Quantum – projekt s účelom vylepšiť vykresľovacie jadro Gecko prehliadača Firefox, ktoré vyvíja Mozilla

### Operačné systémy
* Redox (operačný systém) – mikrokernel
* Stratis – správa súborového systému pre Fedoru a RHEL 8
* Fuchsia – operačný systém
* KataOS – operačný systém
* Maestro – operačný systém

### Iné
* exa – moderná náhrada pre ls
* Microsoft Azure IoT Edge – platforma pre spúšťanie Azure služieb a umelej inteligencie na IoT zariadeniach. Rust použitý pre niektoré komponenty.
* OpenDNS – služba pre preklad doménových mien. Rust použitý pre niektoré komponenty.
* Tor – anonymná sieť. Originálne implementovaná v C, experimentuje s portovaním do Rust pre zvýšenie bezpečnosti.
* Deno – bezpečné behové prostredie pre JavaScript a TypeScript postavené na V8, Ruste a Tokiu
* Discord – komunikačná služba zameraná na hráčov. Rust použitý v častiach backendu a v enkódery na klientovi
* TerminusDB – otvorená grafová databáza s účelom kolaboratívneho vytvárania vedomostných grafov
* Zebra – implementácia Zcash protokolu

## Referencie


## Zdroj

Kategória:Programovacie jazyky