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 garbage kolektora. 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:

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é.

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:
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:

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 – mikrokernel
 Stratis – správa súborového systému pre Fedoru a RHEL 8
 Fuchsia – 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 

Programovacie jazyky