Rust (limbaj de programare)

De la Wikipedia, enciclopedia liberă
Jump to navigation Jump to search
Rust
Rust programming language black logo.svg
Rust logo
Extensii fișiere.rs, .rlib
ParadigmăMulti-paradigm, calcul simultan, funcțional, generic, imperativă, structurată
Apărut în07 iulie 2010; acum 10 ani (2010-07-07)
Dezvoltat deGraydon Hoare
DeveloperMozilla
Influențat deAlef,[1] C#,[1] C++,[1] Cyclone,[1][2] Erlang,[1] Haskell,[1] Limbo,[1] Newsqueak,[1] OCaml,[1] Ruby,[1] Scheme,[1] Standard ML,[1] Swift[1][3]
InfluențeCrystal, Elm,[4] Idris,[5] Spark,[6] Swift,[7] Project Verona[8]
PlatformăARM, IA-32, x86-64, MIPS, PowerPC, SPARC, RISC-V[9][10]
Sistem de operareLinux, macOS, Windows, FreeBSD, OpenBSD,[11] Redox, Android, iOS[12]
LicențăMIT or Apache 2.0[13]
Websitewww.rust-lang.org

Rust este un limbaj de programare[14] axat pe siguranță, în special concurența sigură.[15][16] Rust este similar sintactic cu C++,[17] dar este conceput pentru a oferi o mai bună siguranță a memoriei, menținând în același timp performanțe ridicate.

Rust a fost proiectat inițial de Graydon Hoare la Mozilla Research, cu contribuții de la Dave Herman, Brendan Eich și alții.[18][19] Designerii au perfecționat limbajul în timp ce scriau macheta Servo sau motorul browserului,[20] și compilatorul Rust. Compilatorul este un software gratuit și open-source cu licență dublă sub Licența MIT și Licența Apache 2.0.

Rust a fost „cel mai îndrăgit limbaj de programare” de la Stack Overflow Developer Survey în fiecare an începând cu 2016.[21][22][23][24]

Design[modificare | modificare sursă]

Rustul este destinat să fie un limbaj pentru sisteme foarte concurente și extrem de sigure,[25] și programarea în mare, adică crearea și menținerea de limite care păstrează integritatea sistemului mare.[26] Acest lucru a dus la un set de caracteristici cu accent pe siguranță, controlul dispunerii memoriei și concurență.

Performanța Rust idiomatic[modificare | modificare sursă]

Performanța Rust idiomatic este comparabilă cu performanța idiomatică C ++.[27][28]

Sintaxă[modificare | modificare sursă]

Sintaxa concretă a Rust este similară cu C și C++, cu blocuri de cod delimitate de paranteze cretate și cuvinte cheie de control, cum ar fi if, else, while, și for. Nu toate cuvintele cheie C sau C ++ sunt implementate, însă unele funcții Rust (cum ar fi utilizarea potrivirii cuvintelor cheie pentru potrivirea modelului) vor fi mai puțin familiare cu cele versate în aceste limbi. În ciuda asemănării superficiale cu C și C ++, sintaxa Rust în sens mai profund este mai aproape de cea a familiei ML de limbi și a limbii Haskell. Aproape fiecare parte a unui corp de funcții este o expresie,[29] controlează chiar și operatorii de flux. De exemplu, expresia obișnuită dacă if și locul condiționatului ternar al lui C. O funcție nu trebuie să se termine cu o expresie return: în acest caz, dacă punctul virgulă este omis, ultima expresie din funcție creează valoarea returnare.

Securitatea memoriei[modificare | modificare sursă]

Rugul este proiectat să fie în siguranță pentru memorie și, prin urmare, nu permite indicatoarele nule, indicatoarele sau cursele de date în cod sigur.[30][31][32][33] Valorile datelor pot fi inițializate doar printr-un set fix de formulare, care necesită deja inițializarea intrărilor lor.[34] Pentru a reproduce funcția în alte limbi de pointeri, fie valabilă sau NULL, cum ar fi în structurile de date de listă legată sau în arborele binar, biblioteca de bază Rust oferă un tip de opțiune, care poate fi utilizat pentru a testa dacă un pointer are Some valoari sau None. De asemenea, Rust introduce sintaxa suplimentară pentru a gestiona viața de viață, iar compilatorul motivează acest lucru prin intermediul verificatorului său de împrumut.

Gestionarea memoriei[modificare | modificare sursă]

Rust nu utilizează un sistem automat de colectare a gunoiului precum cele utilizate de Go, Java sau .NET Framework. În schimb, memoria și alte resurse sunt gestionate prin convenția de achiziție a resurselor este inițializarea (RAII), cu numărarea de referință opțională. Rust asigură gestionarea deterministă a resurselor, cu cheltuieli generale foarte scăzute. Rugul favorizează, de asemenea, alocarea stivei de valori și nu realizează implicit box.

Există, de asemenea, un concept de referințe (folosind simbolul &), care nu implică numărarea de referințe în timp de rulare. Siguranța utilizării acestor indicatoare este verificată la timp de compilare de către verificatorul împrumutului, prevenind indicatoarele și alte forme de comportament nedefinit.

Proprietate[modificare | modificare sursă]

Rust are un sistem de proprietate în care toate valorile au un proprietar unic, iar sfera valorii este aceeași cu sfera proprietarului.[35][36] Valorile pot fi transmise prin referință imuabilă, folosind &T, prin referință mutabilă, folosind &mut T, sau prin valoare, folosind T. În orice moment, pot fi fie mai multe referințe imuabile, fie o referință mutabilă (o blocare implicită pentru cititori-scriitori). Compilatorul Rust aplică aceste reguli la timp de compilare și, de asemenea, verifică dacă toate referințele sunt valide.

Exemple[modificare | modificare sursă]

Hello World[modificare | modificare sursă]

Iată un simplu „Program Hello, world!” program scris în Rust. println! macro imprimă mesajul la ieșire standard.

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

Funcția factorială[modificare | modificare sursă]

Recursivă[modificare | modificare sursă]

fn factorial(i: u64) -> u64 {
    match i {
        0 => 1,
        n => n * factorial(n-1)
    }
}

Repetată[modificare | modificare sursă]

fn factorial(i: u64) -> u64 {
    let mut acc = 1;
    for num in 2..=i {
        acc *= num;
    }
    acc
}

Folosirea iteratoarelor[modificare | modificare sursă]

fn factorial(i: u64) -> u64 {
    (1..=i).product()
}

Note[modificare | modificare sursă]

  1. ^ a b c d e f g h i j k l m „The Rust Reference: Appendix: Influences”. Accesat în . Rust is not a particularly original language, with design elements coming from a wide range of sources. Some of these are listed below (including elements that have since been removed): SML, OCaml [...] C++ [...] ML Kit, Cyclone [...] Haskell [...] Newsqueak, Alef, Limbo [...] Erlang [...] Ruby [...] Swift [...] Scheme [...] C# [...] 
  2. ^ „Note Research: Type System”. . Accesat în . Papers that have had more or less influence on Rust, or which one might want to consult for inspiration or to understand Rust's background. [...] Region based memory management in Cyclone [...] Safe memory management in Cyclone 
  3. ^ „RFC for 'if let' expression”. Accesat în . 
  4. ^ „Command Optimizations?”. . Accesat în . I just added the outline of a Result library that lets you use richer error messages. It's like Either except the names are more helpful. The names are inspired by Rust's Result library. 
  5. ^ „Idris – Uniqueness Types”. Accesat în . 
  6. ^ Jaloyan, Georges-Axel (). „Safe Pointers in SPARK 2014”. Accesat în . 
  7. ^ Lattner, Chris. „Chris Lattner's Homepage”. Nondot.org. Accesat în . 
  8. ^ „Microsoft opens up Rust-inspired Project Verona programming language on GitHub”. Accesat în . Microsoft recently created a stir after revealing it was taking some ideas from the popular Rust programming language to create a new language for 'safe infrastructure programming' under the banner Project Verona. 
  9. ^ „Rust Platform Support”. Rust Forge. Accesat în . 
  10. ^ „Frequently Asked Questions”. Rust Embedded. Accesat în . 
  11. ^ „OpenBSD ports”. Accesat în . 
  12. ^ „Building and Deploying a Rust library on iOS”. . Accesat în . 
  13. ^ „Rust is a systems programming language”. Rust-lang.org. Accesat în . 
  14. ^ Hoare, Graydon (). „Rust is mostly safety”. Graydon2. Dreamwidth Studios. Accesat în . 
  15. ^ „FAQ – The Rust Project”. Rust-lang.org. Accesat în . 
  16. ^ „Rust vs. C++ Comparison”. Accesat în . Rust is syntactically similar to C++, but it provides increased speed and better memory safety 
  17. ^ Noel (). „The Rust Language”. Lambda the Ultimate. Accesat în . 
  18. ^ „Contributors to rust-lang/rust”. GitHub. Accesat în . 
  19. ^ Bright, Peter (). „Samsung teams up with Mozilla to build browser engine for multicore machines”. Ars Technica. Accesat în . 
  20. ^ „Stack Overflow Developer Survey 2016 Results”. Stack Overflow. Accesat în . 
  21. ^ „Stack Overflow Developer Survey 2017”. Stack Overflow. Accesat în . 
  22. ^ „Stack Overflow Developer Survey 2018”. Stack Overflow. Accesat în . 
  23. ^ „Stack Overflow Developer Survey 2019”. Stack Overflow. Accesat în . 
  24. ^ Avram, Abel (). „Interview on Rust, a Systems Programming Language Developed by Mozilla”. InfoQ. Accesat în . GH: A lot of obvious good ideas, known and loved in other languages, haven't made it into widely used systems languages ... There were a lot of good competitors in the late 1970s and early 1980s in that space, and I wanted to revive some of their ideas and give them another go, on the theory that circumstances have changed: the internet is highly concurrent and highly security-conscious, so the design-tradeoffs that always favor C and C++ (for example) have been shifting. 
  25. ^ „Debian package description: rustc”. 
  26. ^ Walton, Patrick (). „C++ Design Goals in the Context of Rust”. Accesat în . It's impossible to be 'as fast as C' in all cases while remaining safe ... C++ allows all sorts of low-level tricks, mostly involving circumventing the type system, that offer practically unlimited avenues for optimization. In practice, though, C++ programmers restrict themselves to a few tools for the vast majority of the code they write, including stack-allocated variables owned by one function and passed by alias, uniquely owned objects (often used with auto_ptr or the C++0x unique_ptr), and reference counting via shared_ptr or COM. One of the goals of Rust's type system is to support these patterns exactly as C++ does, but to enforce their safe usage. In this way, the goal is to be competitive with the vast majority of idiomatic C++ in performance, while remaining memory-safe ... 
  27. ^ „How Fast Is Rust?”. The Rust Programming Language FAQ. Accesat în . 
  28. ^ „rust/src/grammar/parser-lalr.y”. . Accesat în . 
  29. ^ Rosenblatt, Seth (). „Samsung joins Mozilla's quest for Rust”. Accesat în . [Brendan Eich] noted that every year browsers fall victim to hacking in the annual Pwn2Own contest at the CanSecWest conference. "There's no free memory reads" in Rust, he said, but there are in C++. Those problems "lead to a lot of browser vulnerabilities" and would be solved by Rust, which is a self-compiling language. 
  30. ^ Brown, Neil (). „A taste of Rust”. Accesat în . ... Other more complex data structures could clearly be implemented to allow greater levels of sharing, while making sure the interface is composed only of owned and managed references, and thus is safe from unplanned concurrent access and from dangling pointer errors. 
  31. ^ 'unsafe' – The Rust Programming Language”. 
  32. ^ „Data Races and Race Conditions”. 
  33. ^ „The Rust Language FAQ”. static.rust-lang.org. . Arhivat din original la . Accesat în . 
  34. ^ Klabnik, Steve; Nichols, Carol (iunie 2018). „Chapter 4: Understanding Ownership”. The Rust Programming Language (în engleză). San Francisco, California: No Starch Press. p. 44. ISBN 978-1-593-27828-1. Accesat în . 
  35. ^ „The Rust Programming Language: What is Ownership”. Rust-lang.org (în engleză). Accesat în . 

Legături externe[modificare | modificare sursă]