Rust (jazyk)

Rez
Logo.
Datum první verze July 7 , 2010
Paradigmata Imperativní , funkční , konkurenční
Autor Graydon hoare
Vývojáři Mozilla
Poslední verze 1.51.0 (25. března 2021)
Psaní na stroji Silný , statický
Ovlivněno C ++ , Erlang , Haskell , Scala , OCaml , Scheme , Swift , C # , Alef , Limbo
Napsáno Rez
Operační systém Cross-platform
Licence Licence Apache verze 2.0 a licence MIT
webová stránka www.rust-lang.org
Přípona souboru rs a rlib

Rust jekompilovaný programovací jazyk založený navíce paradigmatech navržený a vyvinutý společností Mozilla Research od roku 2010. Byl navržen jako „spolehlivý, souběžný a praktický jazyk“, podporující čistě funkční , herecký model , procedurální ,programovací stylyi objektově orientovaný v některých aspektech.

V roce 2020 je jeho preferovanou oblastí programování systému, aplikace příkazového řádku, webové aplikace prostřednictvím WebAssembly , síťové služby a vestavěné systémy.

Díky zásadám Mozilly je Rust plně vyvinut otevřeným způsobem (inženýři Mozilla Research publikují své nápady a rozhodnutí učiněná na schůzkách) a získávají zpětnou vazbu a příspěvky od komunity. Návrh jazyka se postupně vylepšuje zpětnou vazbou od týmu pracujícího na servo rendereru a pragmaticky při psaní kompilátoru. Přestože je projekt financován společností Mozilla, většina příspěvků pochází z komunity.

Popis

Rust si klade za cíl být silným, bezpečným a produktivním jazykem.

Jazyk může zejména poskytovat záruky absence chyby segmentace nebo souběžnosti z fáze kompilace. Kromě toho se to provádí bez odvozu odpadu . Jeho výkon je srovnatelný s výkonem C nebo C ++, pokud jde o rychlost provádění.

Nakonec Rust přichází s Cargo , správcem balíčků pro správu kompilace a závislostí mezi balíčky. Kompilátor poskytuje explicitní a užitečné chybové zprávy. K dispozici jsou také další editační nástroje pro IDE a rozsáhlá dokumentace.

Dějiny

Jazyk se vyvinul z osobního projektu Graydona Hoare, který na něm začal pracovat v roce 2006. Jeho zaměstnavatel, Mozilla , se začal účastnit v roce 2009 a svou práci poprvé oficiálně odhalil v roce 2010. Ve stejném roce přešel projekt z původně použitý kompilátor (napsaný v OCaml ) na hostovaný kompilátor napsaný v Rustu. Tento kompilátor, známý jako rustc , byl úspěšně zkompilován v roce 2011. Kompilátor s vlastním hostitelem používá pro svůj backend LLVM .

První očíslovaná alfa verze kompilátoru Rust se objevila v lednu 2012.

První stabilní verze Rustu, 1.0, byla vydána v roce 2015.

V roce 2017 Mozilla oznámila, že Rust podporuje kompilaci do sady instrukčních sad architektury RISC-V .

Vlastnosti

Syntax

Syntaxe jazyk je podobný C , který se skládá z kódových bloků oddělených podpěr a řídicích struktur , jako jsou if, else, whilea for.

Rustova sémantika je však zcela odlišná. Ve skutečnosti jsou bloky a řídicí struktury výrazy, jak vidíme na příkladu:

let x = if n < 10 { n } else { n - 10 };

V jazyce C taková operace není kompilátoru „srozumitelná“; buď bude nutné zapouzdřit podmíněný blok do jiné funkce, nebo použít ternární operátor int x = (n < 10) ? n : n - 10;.

Použití výrazů tak přibližuje Rust funkčním jazykům jako Haskell nebo OCaml .

Hodnota a proměnlivost

Ve většině jazyků je proměnná ve výchozím nastavení upravitelná. Rust obrátí tuto logiku tím, že se zaměří na konzistenci: klíčové slovo letdefault deklaruje neměnné proměnné ( neměnná proměnná v angličtině), které nelze přiřadit pouze jednou, ale jejichž hodnotu lze nastavit za běhu. Je nutné přidat klíčové slovo mut, aby proměnná byla „proměnlivá“ nebo „proměnlivá“: omezíme tedy proměnné, které jsou skutečně oprávněny měnit. Typ proměnných je odvozen, kdykoli je to možné.

Pro konstantní hodnoty známé při kompilaci constnahradí klíčové slovo let. Musí být zadán jejich typ a musí být inicializovány z konstantního výrazu, s výjimkou výsledků volání funkcí.

fn main() { // Déclaration de variables let mut a = 5; // a est une variable modifiable let b = a * 2; // b est non modifiable et du même type que a //constantes const c:u32 = 5; // déclaration d'une constante entière non-signée const c:u8 = b - 3; // interdit car `b - 3` n'est pas une expression constante (b non défini à la compilation) const c = 5; //interdit car le type de c n'est pas précisé //altération c = 3; // illégal car c est une constante b = 3; // illégal car b est une variable immuable a = 2; // autorisé car a est déclaré comme "mut" let a = a+5; // autorisé une nouvelle variable a est créée valant 7, //l'ancienne variable a est "couverte" par la nouvelle (shadowing) //vérification des valeurs assert_eq!(a, 5);//faux assert_eq!(b, 10);//vrai }


Výčty a filtrování podle vzoru

Rust umožňuje definici typů součtu (nebo výčtu) pomocí klíčového slova enum. Tyto typy součtu můžeme použít s filtrováním vzorů , například pomocí klíčového slova match.

Příklad:

// On crée un type « Forme » pour décrire des formes géométriques. enum Forme { Point, // une forme peut être un point, sans données attachées. Rectangle(f64, f64), // une forme peut être un rectangle, caractérisé par les longueurs de ses côtés. Cercle(f64), // une forme peut être un cercle, caractérisé par son rayon. } // Calcule l'aire d'une forme géométrique. fn aire(f: Forme) -> f64 { match f { // Filtrage par motif avec « match » Forme::Point => 0.0, Forme::Cercle(rayon) => 3.14 * rayon * rayon, Forme::Rectangle(cote_a, cote_b) => cote_a * cote_b, } }

Některé výčty jsou součástí standardní knihovny, například Option , aby se zabránilo použití ukazatele NULL .

Metaprogramování povoleno díky filtrování vzorů

Držení a půjčování

K získání bezpečnostních záruk používá Rust pojmy vlastnictví (vlastnictví nebo vlastnictví) a výpůjčky (výpůjčky).

Hodnota má tedy vždy pouze jednoho vlastníka. Pokud hodnota změní vlastnictví, předchozí vlastník ji již nebude moci používat.

Například :

fn prend_possession(v: Vec<i32>) { // Cette fonction prend possession de son paramètre v et ne la rend pas. println!("{:?}", v); } fn main() { let mut a = vec![1, 2, 3]; // a est le propriétaire du vecteur. let mut b = a; // b est maintenant le propriétaire du vecteur. // pas clair, a.push(4); // erreur de compilation : a n'a plus le droit d'utiliser ce vecteur prend_possession(b); b.push(5); // erreur de compilation : b n'a plus le droit d'utiliser ce vecteur }

Chcete-li použít hodnotu na několika místech současně, je možné ji zapůjčit vytvořením odkazů .

Je možné vytvořit:

  • Buď neměnné odkazy , s operátorem &.
  • Buď proměnlivý odkaz s operátorem & mut.

Zejména není možné kombinovat proměnlivé a neměnné odkazy.

Příklad:

fn take_reference(v: &Vec<i32>) { // Cette fonction prend une référence vers un vecteur println!("{:?}", v); } fn correct() { let a = vec![1, 2, 3]; let ref_1 = &a; let ref_2 = &a; // On crée plusieurs références immuables vers a que l'on peut passer à des fonctions. // Faire ceci ne serait pas possible si l'on travaillait avec une fonction qui prend // l'ownership de a. take_reference(ref_1); take_reference(ref_2); } fn incorrect() { let mut a = vec![1, 2, 3]; // Ce code ne compile pas. // En effet, on travaille à la fois avec une référence muable vers a (ref_1), // et à la fois avec une référence immuable vers a (ref_2). let ref_1 = &mut a[0]; let ref_2 = &a; println!("{}", *ref_1); take_reference(ref_2); }

Silné body

Rust je založen na známých a osvědčených koncepcích (odtud název Rust ,  v angličtině „ rez “) a neintegruje nové a nevyzkoušené koncepty . Tyto koncepty byly vypůjčené ze stávajících programovacích jazyků a sestaveny do jednoho jazyka:

  • odvození typů  ;
  • filtrování vzorů  ;
  • obecnost .

    • Rust je často popisován jako jeden z potenciálních nástupců C a C ++ (spolu s D a v menší míře Go ), zejména pro svou bezpečnost a rychlost - to je cíl jasně stanovený vývojáři.

    Rez založené projekty

    Příklady kódu

    Ahoj světe  :

    // This is the main function fn main() { // The statements here will be executed when the compiled binary is called // Print text to the console println!("Hello World!"); }

    Pole a řezy  :

    use std::mem; // This function borrows a slice fn analyze_slice(slice: &[i32]) { println!("first element of the slice: {}", slice[0]); println!("the slice has {} elements", slice.len()); } fn main() { // Fixed-size array (type signature is superfluous) let xs: [i32; 5] = [1, 2, 3, 4, 5]; // All elements can be initialized to the same value let ys: [i32; 500] = [0; 500]; // Indexing starts at 0 println!("first element of the array: {}", xs[0]); println!("second element of the array: {}", xs[1]); // `len` returns the size of the array println!("array size: {}", xs.len()); // Arrays are stack allocated println!("array occupies {} bytes", mem::size_of_val(&xs)); // Arrays can be automatically borrowed as slices println!("borrow the whole array as a slice"); analyze_slice(&xs); // Slices can point to a section of an array println!("borrow a section of the array as a slice"); analyze_slice(&ys[1 .. 4]); // Out of bound indexing yields a panic println!("{}", xs[5]); }

    Dodatky

    Související články

    externí odkazy

    Reference

    1. „  Oznámení Rust 1.51.0 | Rust Blog  » ,25. března 2021
    2. "  Verze 1.51.0  " ,25. března 2021
    3. "  Vydání 1.51.0  " ,25. března 2021(zpřístupněno 16. dubna 2021 )
    4. https://doc.rust-lang.org/stable/reference/influences.html
    5. „  https://github.com/rust-lang/rust/blob/master/COPYRIGHT  “
    6. (in) „  The Rust Save  “ Lambda the Ultimate,8. července 2010(zpřístupněno 30. října 2010 ) .
    7. (in) „  The Rust Programming Language  “ (zpřístupněno 21. října 2012 ) .
    8. (in) „  Doc language FAQ  “ (zpřístupněno 21. října 2012 ) .
    9. https://doc.rust-lang.org/book/ch17-01-what-is-oo.html
    10. (in) „  The Mozilla Manifesto  “ (zpřístupněno 9. dubna 2012 ) .
    11. (in) Peter Bright, „  Samsung se spojil s Mozillou a vytvořil motor prohlížeče pro vícejádrový stroj  “ ,3. dubna 2013(zpřístupněno 4. dubna 2013 ) .
    12. https://www.rust-lang.org/
    13. https://doc.rust-lang.org/nomicon/what-unsafe-does.html
    14. https://www.rust-lang.org/en-US/faq.html#is-rust-garbage-collected
    15. https://benchmarksgame-team.pages.debian.net/benchmarksgame/fastest/rust.html
    16. (in) „  Project FAQ  “ ,14. září 2010(zpřístupněno 11. ledna 2012 ) .
    17. (in) „  Budoucí čas  “ ,29.dubna 2011(zpřístupněno 6. února 2012 )  : „  Na Mozilla Summit 2010 jsme spustili Rust, nový programovací jazyk motivovaný bezpečností a souběžností pro paralelní hardware, budoucnost„ manycore “, která je před námi.  "
    18. (in) Graydon Hoare , „  Rust Progress  “ [ archiv15. srpna 2014] ,2. října 2010(zpřístupněno 30. října 2010 ) .
    19. (in) Graydon Hoare , „  [rust-dev] stage1 / rustc builds  “ ,20. dubna 2011(zpřístupněno 20. dubna 2011 )  :„  Po této poslední změně, která opravuje chybu kontextu oboru protokolování, vypadá to, že se staví stage1 / rustc. Jen se stydím o půlnoci :)  “.
    20. (in) catamorphism, „  Mozilla and the community release Rust Rust 0.1 (a strong-typeed systems programming language with focus in safety safety and concurrency)  " ,20. ledna 2012(zpřístupněno 6. února 2012 ) .
    21. (in) Lucian Armasu, „  Big Tech Hráči začínají přijímat architekturu čipů RISC-V  “ , na Tomově hardware ,29. listopadu 2017
    22. „  Proměnné a proměnlivost - programovací jazyk Rust  “ , na doc.rust-lang.org (přístup k 5. července 2019 )
    23. https://doc.rust-lang.org/book/second-edition/ch06-01-defining-an-enum.html#the-option-enum-and-its-advantages-over-null-values
    24. „  Presentation of Rust on Léa-Linux  “ (přístup 11. prosince 2013 ) .
    25. (in) Nicholas Matsakis a Aaron Turon, „  Preambule  “ (zpřístupněno 12. června 2019 )
    26. „  Rust 0,8 vydán  “ (přístup k 15. říjnu 2013 ) .
    27. Vincent Hermann, „  Microsoft zkoumá jazyk Rust pro programování systému  “ (zpřístupněno 26. července 2019 )
    28. „  Shipping Rust in Firefox ★ Mozilla Hacks - the Web developer blog  “ , na hacks.mozilla.org (přístup 19. října 2016 )
    29. (in) „  Rust whitepaper NPM  “ , Vývojáři projektu Rust ,25. února 2019( číst online )
    30. „  Proč Discord přechází z Go to Rust,  “ na https://blog.discordapp.com/ (přístup 6. února 2020 )
    31. (en-US) Boyd Johnson, „  Bezpečnost, výkon a inovace: Rust v Hyperledger Sawtooth  “ ,18. ledna 2019(zpřístupněno 26. srpna 2019 )
    32. (en-US) Cade Metz , „  Epický příběh Exodu Dropboxu z Amazonské cloudové říše  “ , WIRED ,14. března 2016( číst online , konzultováno 19. října 2016 )