Rust (programmeringssprog) - Rust (programming language)

Rustfundament
Dannelse	8. februar 2021 ; 10 måneder siden
Grundlæggere
Type	Organisation uden fortjeneste
Beliggenhed
formand	Shane Miller
Administrerende direktør	Rebecca Rumbul
Internet side	fundament .rust-lang .org

Rust
	Det officielle Rust-logo
Paradigmer	Multi-paradigme : samtidig , funktionel , generisk , imperativ , struktureret
Designet af	Graydon Hoare
Udvikler	Rustfonden
Først dukkede op	7. juli 2010 ; 11 år siden
Stabil udgivelse	1.57.0 / 2. december 2021 ; 29 dage siden
Maskinskrivningsdisciplin	Affin , udledt , nominel , statisk , stærk
Implementeringssprog	Rust
Platform	AMD64 , i686 , arm , AArch64 , armv7 , mips , mips64 , mipsel , mips64el , powerpc , powerpc64 , powerpc64le , risc -v , s390x , WebAssembly
OS	Windows , Linux , macOS , FreeBSD , NetBSD , Illumos , Haiku , Android , Redox , iOS , Fuchsia
Licens	MIT eller Apache 2.0
Filnavneudvidelser	.rs, .rlib
Internet side	www .rust-lang .org
Påvirket af
	Alef; C#; C++; Cyklon; Erlang; Haskell; Limbo; Newsqueak; OKaml; Rubin; Ordning; Standard ML; Swift;
Påvirket
	Krystal; Elm; Idris; Gnist; Swift; Projekt Verona; Zig; PHP;

Rust er et multiparadigme , alment programmeringssprog designet til ydeevne og sikkerhed , især sikker samtidighed . Rust ligner syntaktisk C++ , men kan garantere hukommelsessikkerhed ved at bruge en lånekontrol til at validere referencer . Rust opnår hukommelsessikkerhed uden affaldsopsamling , og referencetælling er valgfri. Rust er blevet kaldt et systemprogrammeringssprog , og ud over funktioner på højt niveau, såsom funktionel programmering , tilbyder det også mekanismer til hukommelsesstyring på lavt niveau .

Rust blev oprindeligt designet af Graydon Hoare ved Mozilla Research, med bidrag fra Dave Herman, Brendan Eich og andre. Designerne forfinede sproget, mens de skrev Servo- eksperimentelle browsermotor og Rust- kompileren . Det har fået stigende brug i industrien, og Microsoft har eksperimenteret med sproget til sikre og sikkerhedskritiske softwarekomponenter.

Rust er blevet kåret som det "mest elskede programmeringssprog" i Stack Overflow Developer Survey hvert år siden 2016, selvom det kun blev brugt af 7 % af de adspurgte i 2021.

Historie

Et eksempel på kompilering af et Rust-program

Sproget voksede ud af et personligt projekt startet i 2006 af Mozilla-medarbejder Graydon Hoare. Hoare har oplyst, at projektet muligvis er opkaldt efter rustsvampe, og at navnet også er en understreng af "robust". Mozilla begyndte at sponsorere projektet i 2009 og annoncerede det i 2010. Samme år skiftede arbejdet fra den oprindelige compiler (skrevet i OCaml ) til en LLVM- baseret selvhostende compiler skrevet i Rust. Opkaldt rustc , det med succes samlet sig i 2011.

Den første nummererede pre-alpha-udgivelse af Rust-kompileren fandt sted i januar 2012. Rust 1.0, den første stabile udgivelse, blev udgivet den 15. maj 2015. Efter 1.0 leveres stabile point-udgivelser hver sjette uge, mens funktioner udvikles i natlig udgivelse. Rust med daglige udgivelser, derefter testet med beta-udgivelser, der varer seks uger. Hvert 2. til 3. år produceres en ny Rust "Edition". Dette er for at give et let referencepunkt for ændringer på grund af den hyppige karakter af Rusts togfrigivelsesplan, samt for at give et vindue til at foretage brydende ændringer. Udgaver er stort set kompatible.

Sammen med konventionel statisk skrivning understøttede Rust før version 0.4 også typetilstande . Typestate-systemet modellerede påstande før og efter programerklæringer ved brug af en speciel checkerklæring. Uoverensstemmelser kunne opdages på kompileringstidspunktet snarere end ved runtime , som det kan være tilfældet med påstande i C- eller C++-kode. Typestate-konceptet var ikke unikt for Rust, da det først blev introduceret på sproget NIL . Typestates blev fjernet, fordi de i praksis var lidt brugt, selvom den samme funktionalitet kan opnås ved at udnytte Rust udspil semantik .

Den objektsystem stil ændret sig betydeligt inden versioner 0,2, 0,3 og 0,4 for Rust. Version 0.2 introducerede klasser for første gang, og version 0.3 tilføjede adskillige funktioner, herunder destruktorer og polymorfi gennem brug af grænseflader. I Rust 0.4 blev træk tilføjet som et middel til at give arv ; grænseflader blev forenet med træk og fjernet som en separat funktion. Klasser blev også fjernet og erstattet af en kombination af implementeringer og strukturerede typer .

Startende i Rust 0.9 og slutter i Rust 0.11, havde Rust to indbyggede pointertyper : ~og @, hvilket forenkler kernehukommelsesmodellen . Det genimplementerede disse pointertyper i standardbiblioteket som Boxog (den nu fjernede) Gc.

I januar 2014, før den første stabile udgivelse, Rust 1.0, kommenterede chefredaktøren for Dr. Dobb's , Andrew Binstock, Rusts chancer for at blive en konkurrent til C++ og til de andre kommende sprog D , Go , og Nim (dengang Nimrod). Ifølge Binstock, mens Rust blev "udbredt set som et bemærkelsesværdigt elegant sprog", gik adoptionen langsommere, fordi det gentagne gange skiftede mellem versioner.

Rust har en udenlandsk funktion grænseflade (FFI), som kan kaldes fra, fx C-sprog, og kan ringe C. Mens kalde C ++ har historisk set været udfordrende (fra alle sprog), Rust har et bibliotek, CXX, at tillade at kalde til eller fra C++, og "CXX har nul eller ubetydelig overhead."

I august 2020 afskedigede Mozilla 250 af sine 1.000 ansatte på verdensplan som led i en virksomhedsomstrukturering forårsaget af den langsigtede virkning af COVID-19-pandemien . Blandt de afskedigede var de fleste af Rust-holdet, mens Servo-holdet var helt opløst. Arrangementet rejste bekymringer om Rusts fremtid.

I den følgende uge erkendte Rust Core Team den alvorlige virkning af fyringerne og meddelte, at planer om en Rust-fond var undervejs. Fondens første mål ville være at tage ejerskab af alle varemærker og domænenavne og også tage økonomisk ansvar for deres omkostninger.

Den 8. februar 2021 blev dannelsen af Rust Foundation officielt annonceret af dets fem stiftende virksomheder ( AWS , Huawei , Google , Microsoft og Mozilla).

Den 6. april 2021 annoncerede Google understøttelse af Rust i Android Open Source Project som et alternativ til C/C++.

Syntaks

Her er et "Hej, verden!" program skrevet i Rust. Den println! makro udskriver beskeden til standard output .

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

Den syntaks af Rust ligner C og C ++ , med blokke af kode afgrænset af krøllede parenteser , og kontrol flyde kategorier såsom if, else, whileog forselv om specifikke syntaks for at definere funktioner ligner mere Pascal . På trods af den syntaktiske lighed med C og C++, er Rust semantikken tættere på ML-familien af sprog og Haskell-sproget . Næsten alle dele af en funktions krop er et udtryk , selv kontrolflowoperatorer. For eksempel tager det ordinære ifudtryk også pladsen for C's ternære betingede , et formsprog brugt af ALGOL 60 . Som i Lisp behøver en funktion ikke at ende med et returnudtryk: i dette tilfælde, hvis semikolon er udeladt, skaber det sidste udtryk i funktionen returværdien , som det ses i den følgende rekursive implementering af faktorfunktionen :

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

Følgende iterative implementering bruger ..=operatøren til at skabe et inkluderende område:

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

Mere avancerede funktioner i Rust inkluderer brugen af generiske funktioner for at opnå type polymorfi . Følgende er et Rust-program til at beregne summen af to ting, som addition er implementeret for, ved hjælp af en generisk funktion:

use std::ops::Add;

fn Sum<T: Add<Output = T> + Copy> (num1: T, num2: T) -> T {
    num1 + num2
}

fn main() {
    let result1 = Sum(10,20);
    println!("Sum is: {:?}", result1);
    
    let result2 = Sum(10.23,20.45);
    println!("Sum is: {:?}", result2);
}

Funktioner

Afspil medier

En præsentation om Rust af Emily Dunham fra Mozillas Rust-team ( linux.conf.au- konference, Hobart, 2017)

Rust er beregnet til at være et sprog for meget samtidige og yderst sikre systemer og programmering i det store , det vil sige at skabe og vedligeholde grænser, der bevarer integriteten i store systemer. Dette har ført til et funktionssæt med vægt på sikkerhed, kontrol af hukommelseslayout og samtidighed .

Hukommelsessikkerhed

Rust er designet til at være hukommelsessikker . Det tillader ikke nullpointere , dinglende pointere eller dataløb . Dataværdier kan kun initialiseres gennem et fast sæt formularer, som alle kræver, at deres input allerede er initialiseret. Til gentagne pointere er enten gyldig eller NULL, såsom i forbundet liste eller binære træ datastrukturer , Rust kerne bibliotek giver en mulighed typen , som kan anvendes til at teste, om en pointer har Someværdi eller None. Rust har tilføjet syntaks til at styre levetider , som kontrolleres på kompileringstidspunktet af lånekontrollen . Usikker kode kan undergrave nogle af disse begrænsninger ved at bruge unsafenøgleordet.

Hukommelseshåndtering

Rust bruger ikke automatisk affaldsindsamling . Hukommelse og andre ressourcer administreres gennem ressourceanskaffelse er initialiseringskonventionen , med valgfri referencetælling . Rust giver deterministisk styring af ressourcer med meget lav overhead . Rust favoriserer stakallokering af værdier og udfører ikke implicit boksning .

Der er konceptet med referencer (ved hjælp af &symbolet), som ikke involverer runtime referencetælling. Sikkerheden af sådanne pointere verificeres på kompileringstidspunktet, hvilket forhindrer dinglende pointere og andre former for udefineret adfærd . Rusts typesystem adskiller delte, uforanderlige pointere af formen &Tfra unikke, foranderlige pointere af formen &mut T. En foranderlig pointer kan tvinges til en uforanderlig pointer, men ikke omvendt.

Ejendomsret

Rust har et ejersystem, hvor alle værdier har en unik ejer, og omfanget af værdien er det samme som ejerens omfang. Værdier kan overføres ved uforanderlig reference, ved hjælp af &T, ved foranderlig reference, ved hjælp af &mut T, eller ved værdi, ved hjælp af T. Til enhver tid kan der enten være flere uforanderlige referencer eller en foranderlig reference (en implicit læser-skriver-lås ). Rust-kompileren håndhæver disse regler på kompileringstidspunktet og kontrollerer også, at alle referencer er gyldige.

Typer og polymorfi

Rusts typen systemet understøtter en mekanisme kaldet træk , inspireret af typen klasser i Haskell sprog. Træk annoterer typer og bruges til at definere delt adfærd mellem forskellige typer: f.eks. kan flydende og heltal implementere en "Tilføj"-egenskab, fordi de begge kan tilføjes; og enhver type, der kan udskrives som en streng, implementerer "Display" eller "Debug" egenskaberne. Denne facilitet er kendt som ad hoc polymorfi .

Rust bruger typeinferens for variabler, der er erklæret med nøgleordet let . Sådanne variabler kræver ikke, at der først tildeles en værdi for at bestemme deres type. En kompileringstidsfejl opstår, hvis en kodegren efterlader variablen uden en tildeling. Variabler, der er tildelt flere gange, skal markeres med nøgleordet mut(forkortelse for mutable).

En funktion kan tildeles generiske parametre , som gør det muligt at anvende den samme funktion på forskellige typer. Generiske funktioner kan begrænse den generiske type til at implementere en bestemt egenskab eller egenskaber; for eksempel kan en "tilføj en"-funktion kræve typen for at implementere "Tilføj". Det betyder, at en generisk funktion kan typetjekkes, så snart den er defineret.

Implementeringen af Rust generics ligner den typiske implementering af C++ skabeloner: en separat kopi af koden genereres for hver instansiering. Dette kaldes monomorfisering og står i kontrast til det typesletningsskema , der typisk bruges i Java og Haskell. Rusts type sletning er også tilgængelig ved at bruge søgeordet dyn. Fordelen ved monomorfisering er optimeret kode til hver specifik brugssag; Ulempen er øget kompileringstid og størrelse af de resulterende binære filer.

I Rust oprettes brugerdefinerede typer med structnøgleordet. Disse typer indeholder normalt datafelter som objekter eller klasser på andre sprog. Den implnøgleord kan definere metoder til struct (data og funktion er defineret separat i en struct) eller implementere en egenskab for strukturen. En egenskab er en kontrakt om, at en struktur har visse nødvendige metoder implementeret. Træk bruges til at begrænse generiske parametre, og fordi træk kan give en struktur med flere metoder end brugeren definerede. For eksempel Iteratorkræver egenskaben , at nextmetoden er defineret for typen. Når først nextmetoden er defineret, giver egenskaben almindelige funktionelle hjælpemetoder over iteratoren som mapeller filter.

Objektsystemet indenfor Rust er baseret på implementeringer, træk og strukturerede typer. Implementeringer udfylder en rolle, der ligner den for klasser inden for andre sprog og er defineret med nøgleordet impl. Træk giver arv og polymorfi; de gør det muligt at definere metoder og blande dem i implementeringer. Strukturerede typer bruges til at definere felter. Implementeringer og træk kan ikke selv definere felter, og kun træk kan give arv. Blandt andre fordele forhindrer dette diamantproblemet med multipel arv , som i C++. Med andre ord, Rust understøtter grænsefladearv, men erstatter implementeringsarv med komposition ; se sammensætning over arv .

Komponenter

Rust har et stort antal komponenter, der udvider Rust-funktionssættet og gør Rust-udvikling lettere. Komponentinstallation styres typisk af rustup, en Rust- værktøjskædeinstallatør udviklet af Rust-projektet.

Last

Cargo er Rusts byggesystem og pakkehåndtering . Cargo håndterer download-afhængigheder og opbygning af afhængigheder. Cargo fungerer også som en indpakning til clippy og andre rustkomponenter . Det kræver, at projekter følger en bestemt mappestruktur.

Afhængighederne for en rustpakke er specificeret i en last. toml- fil sammen med versionskrav , der fortæller Cargo, hvilke versioner af afhængigheden der er kompatible med pakken. Som standard henter Cargo sine afhængigheder fra det brugerbidragede register crates.io, men Git- lagre og -pakker i det lokale filsystem kan også angives som afhængigheder.

Rustfmt

Rustfmt er en kodeformater til Rust. Det tager Rust kildekode som input og ændrer blanke tegn og indrykning til at producere formateret kode i overensstemmelse med den Rust stil vejledning eller regler er angivet i en rustfmt.toml fil. Rustfmt kan påberåbes som et selvstændigt program eller på et Rust-projekt gennem Cargo.

Clippy

Clippy er Rusts indbyggede fnugværktøj til at forbedre korrektheden, ydeevnen og læsbarheden af rustkoden. Det blev oprettet i 2014 og opkaldt efter den eponyme Microsoft Office-funktion . Fra 2021 har Clippy mere end 450 regler, som kan gennemses online og filtreres efter kategori. Nogle regler er deaktiveret som standard.

RLS

RLS er en sprog-server , der giver IDE'er og teksteditorer med mere information om en Rust projekt. Det giver linting kontrol via Clippy , formatering via Rustfmt, automatisk kode færdiggørelse via Racer , blandt andre funktioner. Udviklingen af Racer blev bremset til fordel for rust-analysator .

Sprogudvidelser

Det er muligt at udvide Rust-sproget ved hjælp af den proceduremæssige makromekanisme.

Procedurelle makroer bruger Rust-funktioner, der kører på kompileringstidspunktet for at ændre compilerens token-stream. Dette supplerer den deklarative makromekanisme (også kendt som makroer ved eksempel ), som bruger mønstermatchning til at opnå lignende mål.

Procedurelle makroer findes i tre varianter:

Funktionslignende makroer custom!(...)
Udled makroer #[derive(CustomDerive)]
Attribut makroer #[custom_attribute]

Den println!makro er et eksempel på en funktion-lignende makro og serde_deriveer et almindeligt anvendt bibliotek til at generere kode til læsning og skrivning af data i mange formater som JSON . Attributmakroer bruges almindeligvis til sprogbindinger, såsom extendrbiblioteket for Rust-bindinger til R .

Følgende kode viser brugen af Serialize, Deserializeog Debugudleder proceduremæssige makroer til at implementere JSON læsning og skrivning samt evnen til at formatere en struktur til fejlretning.

use serde_json::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let point = Point { x: 1, y: 2 };

    let serialized = serde_json::to_string(&point).unwrap();
    println!("serialized = {}", serialized);

    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
    println!("deserialized = {:?}", deserialized);
}

Ydeevne

Rust sigter efter "at være lige så effektiv og bærbar som idiomatisk C++ uden at ofre sikkerheden". Da Rust anvender LLVM , overføres enhver ydeevneforbedringer i LLVM også til Rust.

Adoption

Nogle Rust-brugere omtaler sig selv som Rustaceans (et ordspil på krebsdyr ) og bruger Ferris som deres uofficielle maskot.

Rust er blevet adopteret af store softwareingeniørvirksomheder. For eksempel er Dropbox nu skrevet i Rust samt nogle komponenter hos Amazon , Facebook , Discord og Mozilla Foundation . Rust var det tredjemest elskede programmeringssprog i 2015 Stack Overflow årlige undersøgelse og tog førstepladsen for 2016-2021.

Webbrowsere og tjenester

Firefox har to projekter skrevet i Rust: Servo parallel browser-motoren udviklet af Mozilla i samarbejde med Samsung ; og Quantum , som er sammensat af flere delprojekter til forbedring af Mozillas Gecko- browsermotor.

OpenDNS bruger Rust i to af dets komponenter.

Deno , en sikker runtime til JavaScript og TypeScript , er bygget med V8 , Rust og Tokio.

Figma , en webbaseret vektorgrafikeditor, er skrevet i Rust.

Operativsystemer

Redox er et "fuldstændig Unix-lignende operativsystem" inklusive en mikrokerne skrevet i Rust.

Theseus, et eksperimentelt OS med "intralingual design", er skrevet i Rust.

Det kapacitetsbaserede Google Fuchsia -operativsystem har nogle værktøjer skrevet i Rust.

Stratis er en filsystemadministrator skrevet i Rust til Fedora og RHEL 8.

exa er et Unix/Linux kommandolinjealternativ til ls skrevet i Rust.

Andre bemærkelsesværdige projekter og platforme

Discord bruger Rust til dele af sin backend, såvel som videokodning på klientsiden, for at udvide kerneinfrastrukturen skrevet i Elixir .

Microsoft Azure IoT Edge, en platform, der bruges til at køre Azure-tjenester og kunstig intelligens på IoT-enheder, har komponenter implementeret i Rust.

Amethyst og Bevy er datadrevne spilmotorer bygget i Rust.

Polkadot (cryptocurrency) er en blockchain- platform skrevet i Rust.

Ruffle er en open source SWF- emulator skrevet i Rust.

TerminusDB , en open source grafdatabase designet til i fællesskab at bygge og kurere vidensgrafer , er skrevet i Prolog og Rust.

Governance

Den Rust Foundation er en non-profit medlemsorganisation stiftet i Delaware , USA , med de primære formål med at støtte vedligeholdelse og udvikling af sproget, dyrke Rust projekt teammedlemmer og brugergrupper, styre den tekniske infrastruktur ligger til grund for udviklingen af Rust , og administrere og varetage Rust-varemærket.

Det blev etableret den 8. februar 2021 med fem stiftende virksomhedsmedlemmer (Amazon Web Services, Huawei, Google, Microsoft og Mozilla). Fondens bestyrelse ledes af Shane Miller. Fra slutningen af 2021 er dens administrerende direktør og administrerende direktør Rebecca Rumbul. Før dette var Ashley Williams midlertidig administrerende direktør.

Udvikling

Rustkonferencer inkluderer:

RustConf: en årlig konference i Portland, Oregon . Afholdt årligt siden 2016 (undtagen i 2020 og 2021 på grund af COVID-19-pandemien ).
Rust Belt Rust: en #rustlang konference i Rust Belt
RustFest: Europas @rustlang-konference
RustCon Asien
Rust LATAM
Oxider globalt

Languages

In other projects