Muokataan sivua Rust (ohjelmointikieli)

Siirry navigaatioon Siirry hakuun

Et ole kirjautunut sisään. IP-osoitteesi näytetään julkisesti sivun muokkaushistoriassa. Harkitse käyttäjätunnuksen rekisteröimistä: se ei vaadi henkilökohtaisia tietoja ja tuo mukanaan lisätoimintoja. IP-osoitteellesi lähetetyt viestit näkyvät keskustelusivullasi.

Ole hyvä äläkä tallenna testimuokkauksia. Voit harjoitella muokkaamista hiekkalaatikolla.

Kumoaminen voidaan suorittaa. Varmista alla olevasta vertailusta, että haluat saada aikaan tämän lopputuloksen, ja sen jälkeen julkaise alla näkyvät muutokset.

{{Ohjelmointikieli
 | nimi = Rust
 | logo = Rust_programming_language_black_logo.svg
 | logon leveys = 100
 | paradigma = moniparadigma, funktionaalinen, imperatiivinen
 | tyypitys = staattinen, vahva
 | suoritusmalli = käännettävä
 | muistinhallinta = [[RAII]]
 | julkaistu = 2010
 | suunnittelija = 
 | kehittäjä = Graydon Hoare, Rust -projektin kehittäjät
 | vakaa-versio = {{Wikidata-fr|P348|showqualifiers=P577|showsource=true}}
 | viimeisin-julkaisupäivä = 
 | kehitys-versio = 
 | toteutukset = Rust
 | vaikutteet = [[C++]]
 | vaikuttaja = 
 | murteet = 
 | käyttöjärjestelmä = [[Android]], [[FreeBSD]], [[iOS]], [[Linux#Linux-jakelut ja käyttökohteet|Linux]], [[macOS]], [[Microsoft Windows|Windows]]
 | www = {{URL|https://www.rust-lang.org/en-US/|Rust Language}}
 | uutisryhmä = 
}}
'''Rust''' on [[ohjelmointikieli]], jonka on kehittänyt [[Mozilla Foundation]].<ref>{{Verkkoviite | Osoite = http://lambda-the-ultimate.org/node/4009 | Nimeke = The Rust Language | Julkaisu = Lambda The Ultimate | Ajankohta = 8.7.2010 | Viitattu = 4.9.2016 | Kieli = {{en}} }}</ref> Rust on suunniteltu suorituskykyiseksi järjestelmätason ohjelmointikieleksi, joka välttäisi tyypillisten [[C (ohjelmointikieli)|C-]] tai [[C++]]-ohjelmien [[muistinhallinta]]an liittyvät virhetilat. Sen syntaksi muistuttaa C-kieltä, mutta muuten eroaa siitä ominaisuuksiltaan. Rust sisältää muun muassa [[Nimiavaruus|nimiavaruudet]], [[rinnakkaisuus|rinnakkainajon]], [[sulkeuma (ohjelmointi)|sulkeumat]] ja [[Tyyppijärjestelmä|tyypinpäättelyn]].<ref name=":2">{{Verkkoviite | Osoite = https://www.infoq.com/news/2012/08/Interview-Rust | Nimeke = Interview on Rust, a Systems Programming Language Developed by Mozilla | Tekijä = Avram, Abel | Julkaisu = InfoQ | Ajankohta = 3.8.2012 | Julkaisija = C4Media Inc | Viitattu = 4.9.2016 | Kieli = {{en}} }}</ref>

Muista moderneista ohjelmointikielistä poiketen Rust toteuttaa muistinhallinnan turvallisuuden ajoajan sijaan kielen syntaksissa ja ohjelman kääntämisen aikana, mikä tarkoittaa lisää rajoituksia ohjelmoijalle, mutta enemmän nopeutta ohjelman ajoon, jotta tehossa ei hävittäisi perinteisille ohjelmointikielille. Lisäksi Rustissa on pyritty kehittämään turvallisuutta myös ohjelman [[Säie (tietotekniikka)|säikeiden]] kilpailutilanteiden suhteen. Toisaalta Rust erottuu monista muista moderneista kielistä siten, että siinä on mahdollista myös halutessaan ohittaa turvallisuusmekanismit ja käyttää esimerkiksi [[Osoitinmuuttuja|osoitinmuuttujia]] vapaasti.{{Lähde||19. tammikuuta 2020|vuosi=2020}}

Rust on [[Ohjelmointikielen kääntäjä|käännettävä]] kieli, joka tukee [[Unicode]]-merkistöä.{{Lähde||19. tammikuuta 2020|vuosi=2020}} Rustin käyttöön liittyen sen ohjelmointikielen kääntäjä ilmoittaa virheet tarkasti ja perusteellisesti verrattuna C- ja C++-kieliin, mikä helpottaa ohjelmointivirheiden korjaamista. Rustin kääntäjä myös jossain määrin tarjoutuu avustamaan virheiden korjaamisessa.<ref>https://medium.com/@AlexanderObregon/how-rust-compiles-an-introduction-to-the-rust-compiler-3c51027e7fb1</ref> Rust sisältää myös sisäänrakennetun valmiuden [[Yksikkötestaaminen|yksikkötestaamiselle]].

== Ominaisuudet ==

Rust tarjoaa korkean abstraktiotason kielen ominaisuudet matalalla prosessointitasolla. Rustin päämäärinä ovat turvallisuus, nopeus ja rinnakkaisuus.<ref name=":0">{{Verkkoviite | Osoite = https://doc.rust-lang.org/book/README.html | Nimeke = The Rust Programming Language | Julkaisija = The Rust Project Developers | Viitattu = 22.10.2016 | Kieli = {{en}} }}</ref> Rustilla voidaan kirjoittaa käyttöjärjestelmiä, laiteajureita ja se voidaan [[Sulautettu järjestelmä|sulauttaa]] toisiin ohjelmiin.<ref name=":0" /> Tärkeitä alueita rustille ovat myös pelikehitys ja webpalvelut.{{Lähde||19. tammikuuta 2020|vuosi=2020}}

=== Muistinhallinta ===

Rust ratkaisee muistinhallinnan ongelmat käyttämällä datan omistajan, lainaamisen ja turvattoman (unsafe) käsitteitä.<ref name=":1">{{Verkkoviite | Osoite = https://doc.rust-lang.org/reference.html#memory-model | Nimeke = The Rust Reference – 10 Memory model | Ajankohta = 2011 | Julkaisija = The Rust Project Developers | Viitattu = 22.10.2016 | Kieli = {{en}} }}</ref> Tämä mahdollistaa [[Automaattinen roskienkeräys|automaattista roskienkeruutakin]] paremmat ominaisuudet: [[Determinismi#Determinismi_tietotekniikassa|deterministisen muistivapautuksen]], ei kilpailutilanteita (data race) ja iteroijien tarkistus (ei muokata ja viitata samanaikaisesti).{{Lähde||19. tammikuuta 2020|vuosi=2020}}

Rust-ohjelmien muistialue koostuu kahdesta alueesta: ''[[pino]]'' ja ''[[keko (muistialue)|keko]]'' (stack, heap) – aivan kuten C-kielessäkin. Pinossa olevat muuttujat omistaa joku keossa oleva ''laatikko'' (box). Laatikoiden omistamia muuttujia, ''tavaroita'' (items), voi vaihdella funktioiden kesken jos ne ovat muuttumattomia (static). Muuttuvien muuttujien (avainsana mut) jakaminen on mahdollista lainaamalla niitä funktioilta tai säikeiltä toisille (borrowing).<ref name=":1" /> Nämä ratkaisut mahdollistavat turvallisen rinnakkaisajon ja estävät segmentaatiovirheet, jotka C-kielessä johtuvat luvattomien muistialueiden käsittelystä.{{Lähde||19. tammikuuta 2020|vuosi=2020}}

Turvattoman (unsafe) muistihallinnan kautta rust-ohjelmat voivat kommunikoida toisten järjestelmäprosessien ja eri kielellä kirjoitettujen ohjelmien kanssa ilman ristiriitoja, ja tarvittaessa rikkoa omistukseen liittyviä sääntöjä.{{Lähde||19. tammikuuta 2020|vuosi=2020}}

Jokaisella arvolla on Rustissa yksi omistaja kullakin hetkellä. Kun omistaja katoaa näkyvistä, arvo pudotetaan pois. Kekomuistissa pidettyä tietoa ei koskaan kopioida ilman <code>clone()</code>-metodin käyttöä. Muuttujat eivät voi viitata samaan kekomuistissa olevaan tietoon; vain viimeisimpänä määritelty muuttuja on voimassa. Muuttujan sijoittaminen funktioon siirtää arvon omistajuuden funktiolle eli muuttuja katoaa näkyvistä. Jos omistajuutta ei haluta siirtää, käytetään muuttujan referenssiä (<code>&x</code>, <code>x: &Y</code>) eli lainataan. Referoimisen vastaoperaatio on dereferointi <code>*x</code>. Yhteen arvoon voi olla yhdessä näkymässä vain yksi muuntamisen salliva referenssi (<code>&mut x</code>). (Metodeissa Rust tekee automaattisen referoinnin ja dereferoinnin.) Tietorakenteiden kuten tietueiden arvojen on oltava voimassa yhtä kauan kuin koko kokoelmakin – tämä on mahdollista elinaikojen avulla.<ref name="book"/>

Elinaikojen avulla referenssit ovat voimassa niin kauan kuin niitä tarvitaan. Elinaika määritellään tarvittaessa syntaksilla <code>&'a Tyyppi</code>, <code>fn nimi<'a>(x: &'a Tyyppi) -> &'a Tyyppi { ... }</code>, <code>struct Nimi<'a> { x: &'a Tyyppi, }</code> ja <code>impl<'a> Tyyppi<'a> { ... }</code>. Tätä tarvitaan, kun käytetään referenssejä eikä kääntäjällä ole tarpeeksi informaatiota varmistaa, että elinajat riittävät. <code>'static</code> tarkoittaa, että referenssi voi elää koko ohjelman ajon ajan.<ref name="book"/>

Tavallisten referenssien (osoittimien) lisäksi Rustissa voidaan käyttää [[Osoitin (ohjelmointi)|älyosoittimia]], joista tavallisimpia ovat standardikirjaston <code>Box<T></code> (kekomuistiallokaatio), <code>Rc<T></code> (referenssien laskentaan perustuva moniomistajuus) ja <code>RefCell<T></code> (lainaussääntöjen ajonaikainen tarkistus).<ref name="book"/>

=== Moduulit ===

Rust-ohjelmat organisoidaan paketteihin, laatikoihin (engl. ''crate'') ja moduuleihin. Paketti ei ole varsinaisesti Rustin vaan sen apuohjelman Cargon ominaisuus – paketti muodostuu useista laatikoista, joista yhden on oltava kirjasto. Laatikot ovat kirjastoja tai ajotiedostoja, jotka muodostuvat moduulipuusta. Rust-kääntäjälle kaikki lähdetiedostot ovat laatikoita, mutta yleensä laatikolla tarkoitetaan kirjastolaatikkoa (ei ajotiedostolaatikkoa). Moduulit ovat nimiavaruuksia, joiden avulla ohjelman alkioita ja niiden näkyvyyttä organisoidaan. Moduulin alkiot kuten funktiot (ja alimoduulit) nimetään moduulipolun mukaan tyylillä <code>laatikko::moduuli::funktio</code>. Alkiot ovat oletuksena yksityisiä eli käytettävissä vain oman moduulinsa sisällä.<ref name="book">https://doc.rust-lang.org/stable/book (viitattu 14.11.2022)</ref>

Moduuleja käytetään seuraavan syntaksin avulla:<ref name="book"/>
* <code>mod x { ... }</code> määrittelee uuden moduulin
* <code>use laatikko::moduuli::moduuli as mdl;</code> tuo moduulin näkymään niin, ettei koko polkua ole tarpeen käyttää vaan <code>mdl::funktio</code> riittää
* <code>use laatikko::moduuli{self, moduuli::alkio, moduuli, alkio};</code> tuo näkymään neljä polkua samalla lauseella
* <code>pub</code> tekee moduuleista, alkioista tai kentistä käytettäviä moduulin ulkopuolella (julkistettava yksitellen)
* <code>pub use ...;</code> tekee siis näkymään tuodusta polusta julkisen

=== Rinnakkaisohjelmointi ===

Rinnakkaiseen ja asynkroniseen ohjelmointiin löytyy tukea erityisesti Rustin standardikirjastosta. Esimerkiksi <code>std::thread::spawn</code> ajaa annetun sulkeuman uudessa säikeessä ja palauttaa kahvan, jonka <code>join</code>-metodilla voidaan odottaa säikeen valmistumista. Referenssien elinaika on epäselvä asynkronisessa ajossa, joten annetun sulkeuman on omistettava ympäristöstään kaappaamansa arvot – tämä onnistuu syntaksilla <code>move || println!(x);</code>. Viestien välitys säikeiden välillä onnistuu standardikirjaston <code>std::sync::mpsc::channel</code>-funktion avulla. Myös muistin jakaminen säikeiden välillä onnistuu <code>std::sync::Mutex</code>- (lukko) ja <code>std::sync::Arc</code>-tietueen (moniomistajuus) avulla.<ref name="book"/>

=== Olioperusteinen ohjelmointi ===

Rustissa ei käytetä sanaa objekti tai olio, mutta tietueille ja luetteloille voidaan määritellä metodeja, mikä mahdollistaa olio-perusteisen ohjelmoinnin. Kapselointi onnistuu käyttämällä <code>pub</code>-avainsanaa niiden tietotyyppien ja metodien määritelmissä, jotka muodostavat kyseisen tietotyypin julkisen rajapinnan. Periminen ei ole mahdollista, mutta geneeriset tyypit ja piirteiden oletustoteutukset ja reunaehdot mahdollistavat vastaavia rakenteita. Näiden lisäksi abstraktimpi tapa on käyttää kokoelman tyyppinä Rustin piirreobjektia <code><Box<dyn Piirre>></code>, joka mahdollistaa erilaisten ja uusien tyyppien käsittelemisen samassa kokoelmassa ajon aikana – kunhan ne vain toteuttavat annetun piirteen (<code>dyn</code>-avainsana tulee sanasta dynaaminen). Tämä vastaa [[ankkatyypitys]]tä – eli varsinaisella tyypillä ei ole väliä kunhan se toteuttaa tietyt metodit – mutta Rust-kääntäjä varmistaa jo käännösvaiheessa, että metodit ovat olemassa ennen niiden kutsumista. Tilaobjektimallin käyttö on mahdollista, mutta Rustissa on tyypillisempää esittää olioiden erilaiset tilat omina tyyppeinään, jolloin voidaan hyödyntää Rust-kääntäjän tyypintarkastusta.<ref name="book"/>

=== Funktionaalinen ohjelmointi ===

Sulkeumat ovat Rustin nimettömiä funktioita, jotka määritellään tyylillä <code>|x| println!("{}-{}", x, y);</code> ja voivat kaapata arvoja ympäristöstä, jossa ne on määritelty. Sulkeuma voidaan sijoittaa muuttujaan tai funktion argumentiksi arvojen tavoin. Jos sulkeuman tyyppejä ei merkitä, kääntäjä päättelee ja merkitsee ne ensin käytettyjen tyyppien mukaan. Sulkeuma voidaan myös palauttaa funktiosta, jos käytetään piirreobjektia <code>Box<dyn Fn(T) -> T></code>.<ref name="book"/>

Iteraattorit ovat tyyppejä, jotka palauttavat jokaisella <code>next</code>-metodin kutsulla uuden arvon, kunnes kaikki arvot on kulutettu. Mikä tahansa tyyppi voi olla iteroitava, jos sille on määritelty <code>Iterator</code>-piirre (<code>Item</code>-tyyppi ja <code>next</code>-metodi riittävät). Kun iteraattoria muutetaan muodosta toiseen, <code>collect</code>-metodilla (tai muulla ns. kuluttavalla metodilla) voidaan lopuksi kuluttaa se, eli esim. palauttaa iteraattorista haluttu vektorityypin rakenne (<code>vektori.iter().map(sulkeuma).collect();</code>).<ref name="book"/>

Funktioita voidaan antaa argumentteina toisiin funktioihin, jotka on määritelty tyylillä <code>fn nimi(f: fn(T) -> T, x: T) -> T { f(x) }</code>.<ref name="book"/>

Hahmonsovitus on Rustissa hyvin tavallista. Se onnistuu <code>match</code>-, <code>if let</code>-, <code>while let</code>-, <code>for</code>- ja <code>let</code>-lauseissa sekä funktioiden parametreissa. Hahmonsovitus mahdollistaa myös monikkojen, tietueiden ja luetteloiden destrukturoinnin tyylillä <code>let (x, y) = (1, 2)</code>. Alaviivalla <code>_</code> voidaan jättää osia hahmosta huomiotta ja <code>..</code>-syntaksilla voidaan jättää kokonainen arvoväli jostakin kokoelmasta huomiotta.<ref name="book"/>

=== Metaohjelmointi ===

Makrot tuottavat koodia kääntämisvaiheessa ja toimivat kuin funktiot, mutta huomattavasti vapaammilla säännöillä. Deklaratiiviset makrot määritellään omalla syntaksillaan tyylillä <code>macro_rules! nimi { hahmo => koodi }</code> ja makro voi näin kaapata mitä tahansa tekstiä ja käyttää sitä tuottamaan mitä tahansa koodia. Proseduraaliset makrot ovat taas tavanomaisia Rust-funktioita, jotka manipuloivat saamansa Rust-koodin abstraktia syntaksipuuta. Makroja kutsutaan funktioiden tapaan tyylillä <code>makro!...</code> tai attribuutteina tyylillä <code>#[makro(...)]</code> ja <code>#[derive(makro)]</code>.<ref name="book"/>

Yleisiä makroja ovat<ref name="book"/>
* <code>println!</code>, joka kirjoittaa standarditulosteeseen
* <code>eprintln!</code>, joka kirjoittaa standardivirheeseen
* <code>dgb!</code>, joka kirjoittaa standardivirheeseen käyttämällä <code>Debug</code>-piirteen määrittelemää formaattia
* <code>assert_eq!</code>, joka varmistaa yhtäläisyyden
* <code>format!</code>, joka liittää muuttujien saamat arvot tekstiliteraaliin
* <code>panic!</code>, joka pysäyttää ohjelman virheeseen

=== Virheidenhallinta ===

Rustissa käsitellään virheitä yleensä luettelon <code>enum Result<T, E> { Ok(T), Err(E), }</code> ja hahmonsovituksen <code>match</code> avulla. <code>Result</code>-arvon voi käsitellä erityisen lyhyesti <code>?</code>-operaattorin avulla tyylillä <code>moduuli::funktio()?</code>, jolloin tilanteessa <code>Ok(arvo)</code> lauseke palauttaa suoraan <code>arvo</code>. <code>?</code>-operaattori on käytettävissä vain funktioissa, jotka palauttavat <code>Result</code>- tai vastaavan tyypin arvon. Toinen tavallinen tapa on käyttää <code>Result</code>-arvon <code>unwrap_or_else</code>-metodia, joka palauttaa arvon tai ajaa annetun sulkeuma. <code>expect</code>-metodi taas kutsuu virhetilanteessa suoraan <code>panic!</code>-makron, mikä on hyödyllistä ohjelman kehityksen alkuvaiheessa.<ref name="book"/>

=== Tietotyypit ===

Tietotyyppejä Rustissa ovat muun muassa<ref name="book"/>
* Kokonaisluvut muotoa <code>i32</code> (oletus), <code>isize</code>, <code>u64</code> ja literaalit <code>5</code>, <code>10_000</code>, <code>0b1010_0011</code>
* Liukuluku <code>f32</code> ja <code>f64</code> ja literaalit esim. <code>2.</code> ja <code>-24.55</code>
* Boolen tyyppi ja literaalit <code>true</code> ja <code>false</code>
* Merkki <code>char</code> ja literaalit <code>'t'</code> (ei <code>"</code>)
* Monikko esim. <code>(1, 2.0, 'c')</code> (<code>(i32, f32, char)</code>)
* Taulukko esim. <code>[1, 2, 3]</code> (<code>[i32; 3]</code>), millä on vakiopituus
* Teksti <code>String</code> (muunnettava) ja literaalit <code>"Hei, Wikipedia!"</code> (muuttumaton)
* Viipale <code>&x[0..5]</code> (<code>"Hei, Wikipedia!"</code> on myös viipale tyyppiä <code>&str</code>)
* Tietue <code>struct Nimi { nimi: String }</code>, josta luodaan instanssi tyylillä <code>Nimi { nimi: String::from("Arvo"), };</code>
* Monikkotietue <code>struct Nimi(i32, String);</code>, jonka kenttiä ei nimetä
* Yksikkötietue <code>struct Nimi;</code>, jolla ei ole kenttiä
* Luettelo <code>enum Nimi { Variantti1(u8), Variantti(String, i32), }</code>, josta voidaan tehdä instansseja tyylillä <code>let x = Nimi::Variantti1(8);</code>. Rustissa ei ole <code>null</code>-arvoa vaan puuttuvaa arvoa edustamaan käytetään tyyppiä <code>enum Option<T> { None, Some(T), }</code>.
* Vektori <code>Vec<T></code>, joka sisältää vaihtelevan pituisen, samaa tyyppiä olevan arvojonon. Instanssi voidaan luoda makrolla <code>vec![1, 2, 3]</code>.
* Hajautustaulu <code>std::collections::HashMap</code>
* Piirreobjektit <code>Box<dyn Error></code>
* Geneeriset tyypit
* <code>None</code>, <code>Some</code>, <code>Option</code>
* <code>Ok</code>, <code>Err</code>, <code>Result</code>

=== Geneeriset rakenteet ===

Geneerisiä funktioita voidaan määritellä tyylillä <code>fn nimi<T>(x: &T) -> &T { ... }</code>, tietueissa <code>struct Nimi<T> { x: T }</code>, luetteloissa <code>enum Nimi<T> { Tyyppi(T), }</code> ja metodeissa <code>impl<T> Nimi<T> { fn nimi(&self) -> &T { ... }</code>. Geneerinen koodi laajennetaan automaattisesti spesifiseksi käännösvaiheessa (engl. ''monomorphization''), joten nämä geneeriset tyypit eivät hidasta ohjelmaa.<ref name="book"/>

=== Piirteet ===

Piirteet (engl. ''traits'') ovat Rustin tapa organisoida metodeja rajapinnoiksi. Ne määritellään tyylillä <code>trait Piirre { fn metodi(&self) -> Tyyppi; ... }</code>. Piirteeseen voidaan kirjoittaa oletustoteutus. Tyypille tehdään piirteen toteutus tyylillä <code>impl Piirre for Tyyppi { ... }</code> – tällöin Rust-kääntäjä huolehtii, että kaikki piirteeseen kuuluvat metodit tulevat määritellyksi. Piirteet toimivat kuin tyypit ja mahdollistavat geneeristen funktioiden kirjoittamisen kaikille tyypeille, jotka toteuttavat tietyn piirteen, tyylillä <code>fn nimi(x: &impl Piirre) { ... }</code> tai <code>fn nimi<T, U>(x: &T, y: &U) -> impl Piirre4 where T: Piirre1 + Piirre2, U: Piirre3 { ... }</code>. Samaan tapaan voidaan kirjoittaa geneeriselle tyypille metodeita (tai vastaava piirretoteutus) niin, että tämä koskee vain tietyt piirteet toteuttavia versioita, tyylillä <code>impl<T: Piirre> Tyyppi<T> { ... }</code>.<ref name="book"/>

Tavallisia piirteitä ovat muun muassa<ref name="book"/>
* <code>Display</code>
* <code>Clone</code>
* <code>Debug</code>
* <code>Copy</code>
* <code>ToString</code>

== Kirjastot ==
=== Rust Standard Library ===

RSL sisältää tärkeimmät ominaisuudet ohjelmointia varten. Moduulit sisältävät kirjastoja muistialueiden, primitiivityyppien, kokoelmien ja virheiden käsittelyyn, iterointiin, IO-operaatioihin, säikeistykseen ja prosessien hallintaan, sekä joukon makroja.<ref name=":0" />

== Ympäristö ==
=== Kielen asennus ===

Rust-projekti käyttää rustin asentamiseen rustup-työkalua, joka asentaa kohdeympäristöön virallisia kanavia pitkin julkaistun rust-version. Se toimii kaikissa rust-kielen tukemissa käyttöjärjestelmissä, mukaan lukien Windows.<ref>{{Verkkoviite | Osoite = https://github.com/rust-lang-nursery/rustup.rs/blob/master/README.md | Nimeke = Rustup: The Rust Toolchain Installer | Julkaisu = Rustup | Julkaisija = GitHub | Viitattu = 9.9.2017 | Kieli = {{en}} }}</ref>

=== Pakettien asennus ===

Rust käyttää kirjastojen ja valmiiden rust-ohjelmien hallintaan Cargo-paketinhallintaa, joka perustuu [[Ruby]]n Bundler-paketinhallintaan. Cargo asentaa ''crate''-ohjelmistopaketit crates.io-verkkopalvelusta.<ref>{{Verkkoviite | Osoite = http://doc.crates.io/index.html | Nimeke = Cargo, Rust’s Package Manager | Julkaisu = Crates | Viitattu = 22.10.2016 | Kieli = {{en}} }}</ref> Cargo toimii myös työvälineenä rust-ohjelmien rakentamiseen, korvaten historiallisen [[make]]n.{{Lähde||19. tammikuuta 2020|vuosi=2020}}

=== Testaaminen ===

Cargo helpottaa automaattista testaamista ajamalla kaikki tietyllä tavalla määritellyt testit komennolla <code>cargo test</code>. Yksi tapa on kirjoittaa testit kuhunkin lähdetiedostoon <code>#[cfg(test)]</code>-attribuutilla merkittyyn <code>tests</code>-moduuliin, jossa testifunktioille annetaan attribuutti <code>#[test]</code>. Toinen tapa on luoda <code>tests</code>-kansio, jonka kaikki lähdetiedostot tulkitaan testeiksi eikä osaksi laatikkoa. Tämä kansio on tarkoitettu kirjaston testaamiseen integroivalla tavalla. Testifunktiot käyttävät yleensä makroja kuten <code>assert!</code>, <code>assert_eq!</code> ja <code>assert_ne!</code>, mutta testin läpäisyä voi edustaa myös <code>Ok(())</code> (ja virhettä <code>Err(virhe))</code>. Normaalisti <code>panic!</code>-kutsu tarkoittaa, ettei testiä läpäisty – päinvastaisessa tilanteessa käytetään attribuuttia <code>#[should_panic(expected = "osa virheviestiä")]</code>.

== Historia ==

Ohjelmointikieli-insinööri Graydon Hoare aloitti rustin kehittämisen vuonna 2006. Hoare esitteli rustia työnantajalleen Mozilla-säätiössä, jonka jälkeen Mozilla perusti tiimin toteuttamaan rustilla tehdyn selainmoottorin, Servon.<ref name=":2" />

Steve Klabnik tunnistaa rustin historiassa neljä aikakautta: henkilökohtainen (2006–2010), Graydonin vuodet (2010–2012), tyyppijärjestelmävuodet (2012–2014) ja julkaisuaika (2015 – toukokuu 2016).<ref name=":3">{{Lehtiviite | Tekijä = Klabnik, Steve | Otsikko = The History of Rust | Julkaisu = Applicative 2016 | Ajankohta = 1.1.2016 | Julkaisupaikka = New York | Julkaisija = Association for Computing Machinery | Doi = 10.1145/2959689.2960081 | Viitattu = | Kieli = {{en}} }}</ref> Kieltä kehitettäessä lähestymistapa on Klabnikin mukaan ollut empiirinen [[Iterointi|iteraatio]], jossa implementoitujen ominaisuuksien toimivuus kokeillaan ennen niiden hyväksymistä.{{Lähde||19. tammikuuta 2020|vuosi=2020}}

Rust 1.0.0 julkaistiin 15. toukokuuta 2015. Julkaisuvuonna rustc-kääntäjän toteutuksessa oli {{Luku|1410|osallistujaa}}.<ref name=":3" /> Hoare käytti rustin toteuttamiseen aluksi [[OCaml|OCamlilla]] kirjoitettua tulkkia. Nykyisin rust on kirjoitettu rustilla.<ref name=":3" />

== Esimerkki ==

Hello world -ohjelma.
<syntaxhighlight lang="rust">
// main.rs
// Ajo alkaa main-funktiosta.
fn main() {
 // println-makro kirjoittaa stdout:iin.
 println!("Hei, Wikipedia!");
}
// $ rustc main.rs
// $ ./main
// > Hei, Wikipedia!
</syntaxhighlight>

== Yhteisö ==

Klabnikin mukaan projektissa pidetty tärkeänä itse kielen ominaisuuksien lisäksi ekosysteemiä, työkaluohjelmia, vakautta ja yhteisöä.<ref name=":3" /> Rust-yhteisössä tärkeitä ovat myös käytöskoodi, inhimillinen käytös ja turhan työn automaatio. Rust-projektin koodirepositorio tervehtii automaattisesti uusia toteuttajia, ja muutokset koodikantaan valitaan formalisoidun automaation avulla, jotta vältytään sosiaalisilta ristiriitatilanteilta.{{Lähde||19. tammikuuta 2020|vuosi=2020}}

Rust-koodia käyttävät muun muassa:
* [[Mozilla Firefox|Firefox-selain]]<ref>{{Verkkoviite|osoite = https://www.infoworld.com/article/2905688/mozillas-rust-based-servo-browser-engine-inches-forward.html |nimeke =Mozilla's Rust-based Servo browser engine inches forward|tekijä=Serdar Yegulalp|julkaisu=InfoWorld|ajankohta=2015-04-03|viitattu=2019-02-28|ietf-kielikoodi=en}}</ref>
* [[Dropbox]]<ref>{{Verkkoviite|osoite=http://going-rust-optimizing-storage-dropbox.html/|nimeke=Go-ing to Rust: Optimizing Storage at Dropbox. QCon San Francisco 2016|julkaisu=going-rust-optimizing-storage-dropbox.html|ajankohta=2016-07-14|viitattu=2019-02-28|ietf-kielikoodi=en}}{{Vanhentunut linkki|bot=InternetArchiveBot }}</ref>
*[[Cloudflare]], sen [[Pingora]]-palvelinohjelma<ref>https://blog.cloudflare.com/pingora-open-source</ref>
* [[Tor (verkko)|Tor]]-anonyymiverkkoalusta<ref>{{Verkkoviite|osoite = https://lists.torproject.org/pipermail/tor-dev/2017-March/012088.html|nimeke = ?|tekijä=Sebastian Hahn|ajankohta= 31.3.2017|viitattu=2019-02-28 |ietf-kielikoodi=en}}</ref>
* [[npm]]-paketinhallinnan pakettirekisteri<ref>{{Verkkoviite|osoite = https://www.rust-lang.org/static/pdfs/Rust-npm-Whitepaper.pdf |nimeke =Rust Case Study: Community makes Rust an easy choice for npm |julkaisu=The Rust Project Developers|ajankohta=2019|julkaisija=Rust-lang.org|viitattu=28.2.2019 |ietf-kielikoodi=en}}</ref>
*[[Facebook]], Rust Foundationin jäsen vuodesta 2016<ref>https://engineering.fb.com/2021/04/29/developer-tools/rust/</ref>
*[[Linux (ydin)]] versiosta 6.1 alkaen<ref>https://www.zdnet.com/article/rust-in-linux-where-we-are-and-where-were-going-next/</ref>
*[[Android]] versiosta 12 alkaen<ref>{{Verkkoviite | osoite = https://security.googleblog.com/2022/12/memory-safe-languages-in-android-13.html | nimeke = Memory Safe Languages in Android 13 | tekijä = Jeffrey Vander Stoep | ajankohta = 1.12.2022 | viitattu = 3.2.2023 | kieli = {{en}} }}</ref>

Vuonna 2024 Google on rahoittanut Rust Foundation -säätiötä miljoonalla dollarilla. Rahoitus on merkitty C++:n ja Rustin yhteensopivuuteen "Interop Initiative" -projektiin.<ref>{{Verkkoviite | osoite = https://foundation.rust-lang.org/news/google-contributes-1m-to-rust-foundation-to-support-c-rust-interop-initiative/ | nimeke = Google Contributes $1M to Rust Foundation to Support C++/Rust “Interop Initiative” | ajankohta = 5.2.2024 | viitattu = 6.2.2024 | kieli = {{en}} }}</ref>

== Lähteet ==

== Aiheesta muualla ==
{{Sisarprojektit
| 1 = Rust
| wikinews    = -
| wikibooks   = -
| meta        = -
| commons     = Category:Rust (programming language)
| wikiquote   = -
| wikispecies = -
| wikivoyage  = -
| wikisource  = -
| wiktionary  = -
| wikiversity = :en:Rust
| mediawiki   = -
| wiki        = -
}}
* [https://doc.rust-lang.org/book/ The Rust Programming Language -kirjan nettiversio] {{en}}
* [https://www.rustup.rs/ Virallinen rust-asennustyökalu rustup (Windows, Linux, Unix)] {{en}}
* [https://play.rust-lang.org/ Rust-leikkikenttä Rust Languagessa] Kokeile Rust-kieltä selaimellasi {{en}}
* [http://play.integer32.com/ Rust-leikkikenttä integer32.com:issa] Kokeile Rust-kieltä selaimellasi {{en}}
* Dunham, E: [[:commons:File:Rust_101.webm|Rust 101]] Käytännön johdatus Rustiin Australaasian Linux-konferenssissa. (webm-video) Wikimedia Commons. {{en}}
* [https://fitech101.aalto.fi/programming-languages/rust/ Ilmainen MOOC-kurssi, jossa opetellaan Rust-ohjelmointikielen perusteet] {{en}}

{{Ohjelmointikielet}}
{{Auktoriteettitunnisteet}}
[[Luokka:Vuoden 2010 ohjelmistot]]
[[Luokka:2010-luvun ohjelmointikielet]]

Yhteenveto (?)

Lisäämäsi sisältö ei saa rikkoa tekijänoikeuksia, ja sen pitää olla tarkistettavissa. Tallentamalla julkaiset muokkauksesi peruuttamattomasti Creative Commons Attribution/Share-Alike 4.0- ja GFDL-lisensseillä. Aineiston myöhemmät käyttäjät saattavat mainita käyttäjätunnuksesi, vähintään linkin tai osoitteen kautta muokkaamaasi artikkeliin. Lisätietoja löytyy käyttöehdoista.
Muutoksesi astuvat voimaan välittömästi. Kokeile muokkaamista hiekkalaatikolla. Kun teet muokkauksen ilman käyttäjätunnusta, IP-osoitteesi tallentuu julkisesti nähtäväksi.

Peruuta Muokkausohjeet (avautuu uuteen ikkunaan)

Välimerkit: – ” ’ … ° ≈ ≠ ≤ ≥ ± − × ÷ ← → · §

Wiki: {{}} | [] [[]] [[Luokka:]] #OHJAUS [[]] <s></s> <code></code> <blockquote></blockquote> <ref></ref> <ref name=""></ref> <ref name="" /> {{Viitteet}} <includeonly></includeonly> <noinclude></noinclude> {{AAKKOSTUS:}} <nowiki></nowiki>  • (mallineet)
Symbolit: ~ | ¡ ¿ † ‡ ↔ ↑ ↓ • ¶ # ¹ ² ³ ½ ⅓ ⅔ ¼ ¾ ⅛ ⅜ ⅝ ⅞ ∞ ‘ “ ’ ” ¤ ₳ ฿ ₵ ¢ ₡ ₢ $ ₫ ₯ € ₠ ₣ ƒ ₴ ₭ ₤ ℳ ₥ ₦ ₧ ₰ £ ៛ ₨ ₪ ৳ ₮ ₩ ¥ ● ○ ♠ ♣ ♥ ♦
Erikoismerkit: Á á Ć ć É é Í í Ĺ ĺ Ń ń Ó ó Ŕ ŕ Ś ś Ú ú Ý ý Ź ź À à È è Ì ì Ò ò Ù ù Â â Ĉ ĉ Ê ê Ĝ ĝ Ĥ ĥ Î î Ĵ ĵ Ô ô Ŝ ŝ Û û Ŵ ŵ Ŷ ŷ Ä ä Ë ë Ï ï Ö ö Ü ü Ÿ ÿ ß Ã ã Ẽ ẽ Ĩ ĩ Ñ ñ Õ õ Ũ ũ Ỹ ỹ Ç ç Ģ ģ Ķ ķ Ļ ļ Ņ ņ Ŗ ŗ Ş ş Ţ ţ Ș ș Ț ț Đ đ Ů ů Ǎ ǎ Č č Ď ď Ě ě Ǐ ǐ Ľ ľ Ň ň Ǒ ǒ Ř ř Š š Ť ť Ǔ ǔ Ž ž Ā ā Ē ē Ī ī Ō ō Ū ū Ȳ ȳ Ǣ ǣ ǖ ǘ ǚ ǜ Ă ă Ĕ ĕ Ğ ğ Ĭ ĭ Ŏ ŏ Ŭ ŭ Ċ ċ Ė ė Ġ ġ İ ı Ż ż Ą ą Ę ę Į į Ǫ ǫ Ų ų Ḍ ḍ Ḥ ḥ Ḷ ḷ Ḹ ḹ Ṃ ṃ Ṇ ṇ Ṛ ṛ Ṝ ṝ Ṣ ṣ Ṭ ṭ Ł ł Ő ő Ű ű Ŀ ŀ Ħ ħ Ð ð Þ þ Œ œ Æ æ Ø ø Å å Ə ə • {{Unicode|}}
Kreikkalaiset aakkoset: Ά ά Έ έ Ή ή Ί ί Ό ό Ύ ύ Ώ ώ Α α Β β Γ γ Δ δ Ε ε Ζ ζ Η η Θ θ Ι ι Κ κ Λ λ Μ μ Ν ν Ξ ξ Ο ο Π π Ρ ρ Σ σ ς Τ τ Υ υ Φ φ Χ χ Ψ ψ Ω ω • {{Polytoninen|}}
Kyrilliset aakkoset: А а Б б В в Г г Ґ ґ Ѓ ѓ Д д Ђ ђ Е е Ё ё Є є Ж ж З з Ѕ ѕ И и І і Ї ї Й й Ј ј К к Ќ ќ Л л Љ љ М м Н н Њ њ О о П п Р р С с Т т Ћ ћ У у Ў ў Ф ф Х х Ц ц Ч ч Џ џ Ш ш Щ щ Ъ ъ Ы ы Ь ь Э э Ю ю Я я
IPA: t̪ d̪ ʈ ɖ ɟ ɡ ɢ ʡ ʔ ɸ ʃ ʒ ɕ ʑ ʂ ʐ ʝ ɣ ʁ ʕ ʜ ʢ ɦ ɱ ɳ ɲ ŋ ɴ ʋ ɹ ɻ ɰ ʙ ʀ ɾ ɽ ɫ ɬ ɮ ɺ ɭ ʎ ʟ ɥ ʍ ɧ ɓ ɗ ʄ ɠ ʛ ʘ ǀ ǃ ǂ ǁ ɨ ʉ ɯ ɪ ʏ ʊ ɘ ɵ ɤ ə ɚ ɛ ɜ ɝ ɞ ʌ ɔ ɐ ɶ ɑ ɒ ʰ ʷ ʲ ˠ ˤ ⁿ ˡ ˈ ˌ ː ˑ ̪ • {{IPA|}}

Tällä sivulla käytetyt Wikidata-kohteet

Rust: Sivulinkki, Otsikko, Joitain esityksiä, Muut (esim. aliakset, kohteen olemassaolo), Kuvaus: fi

Tällä sivulla käytetyt mallineet:

Malline:!- (näytä wikiteksti) (osittain suojattu)
Malline:Aihealue/luokitus (muokkaa)
Malline:Aihealue/reunus (muokkaa)
Malline:Aihealue/taustaväri (muokkaa)
Malline:Aihealue/tekstinväri (muokkaa)
Malline:Auktoriteettitunnisteet (näytä wikiteksti) (osittain suojattu)
Malline:En (näytä wikiteksti) (osittain suojattu)
Malline:Kielisymboli (näytä wikiteksti) (osittain suojattu)
Malline:Lehtiviite (näytä wikiteksti) (osittain suojattu)
Malline:Luku (muokkaa)
Malline:Lähde (näytä wikiteksti) (osittain suojattu)
Malline:Navbox (muokkaa)
Malline:Nimiavaruus (näytä wikiteksti) (osittain suojattu)
Malline:Nowrap (muokkaa)
Malline:Ns (muokkaa)
Malline:Ohjelmointikielet (muokkaa)
Malline:Ohjelmointikieli (muokkaa)
Malline:Sisarprojektit (muokkaa)
Malline:Tietolaatikko (näytä wikiteksti) (osittain suojattu)
Malline:Tietolaatikko/kuva (muokkaa)
Malline:Tietolaatikko/otsikko (muokkaa)
Malline:Tietolaatikko/tietorivi (näytä wikiteksti) (autoreviewer protected)
Malline:Työkaluvihje (muokkaa)
Malline:URL (muokkaa)
Malline:Vaakalista (muokkaa)
Malline:Vanhentunut linkki (näytä wikiteksti) (osittain suojattu)
Malline:Verkkoviite (näytä wikiteksti) (osittain suojattu)
Malline:Viitteet (näytä wikiteksti) (osittain suojattu)
Malline:Wikidata-fr (muokkaa)
Moduuli:Arguments (näytä wikiteksti) (osittain suojattu)
Moduuli:Authority control (näytä wikiteksti) (osittain suojattu)
Moduuli:Authority control/config (näytä wikiteksti) (osittain suojattu)
Moduuli:Check for unknown parameters (näytä wikiteksti) (osittain suojattu)
Moduuli:EditAtWikidata (näytä wikiteksti) (osittain suojattu)
Moduuli:Fr:Biblio (muokkaa)
Moduuli:Fr:Biblio/Commun (muokkaa)
Moduuli:Fr:Biblio/Lien web (muokkaa)
Moduuli:Fr:Biblio/Références (muokkaa)
Moduuli:Fr:Date (muokkaa)
Moduuli:Fr:Date/Data (muokkaa)
Moduuli:Fr:Date complexe (muokkaa)
Moduuli:Fr:Dictionnaire Wikidata/Codes langue (muokkaa)
Moduuli:Fr:Interface Wikidata (muokkaa)
Moduuli:Fr:Langue (muokkaa)
Moduuli:Fr:Langue/Data (muokkaa)
Moduuli:Fr:Linguistique (muokkaa)
Moduuli:Fr:Outils (muokkaa)
Moduuli:Fr:TableBuilder (muokkaa)
Moduuli:Fr:Utilitaire Wikidata (muokkaa)
Moduuli:Fr:Wikidata (muokkaa)
Moduuli:Fr:Wikidata/Analyse transitive (muokkaa)
Moduuli:Fr:Wikidata/Formatage entité (muokkaa)
Moduuli:Fr:Wikidata/I18n (muokkaa)
Moduuli:Fr:Wikidata/Outils (muokkaa)
Moduuli:Fr:Wikidata/Récup (muokkaa)
Moduuli:Lehtiviite (näytä wikiteksti) (osittain suojattu)
Moduuli:Magic-escape (näytä wikiteksti) (suojattu)
Moduuli:Navbar (näytä wikiteksti) (osittain suojattu)
Moduuli:Navbar/styles.css (muokkaa)
Moduuli:Navbox (näytä wikiteksti) (osittain suojattu)
Moduuli:Navbox/styles.css (muokkaa)
Moduuli:Sisarprojektit (muokkaa)
Moduuli:String (näytä wikiteksti) (osittain suojattu)
Moduuli:Testaus (muokkaa)
Moduuli:Tietolaatikko (muokkaa)
Moduuli:URL (muokkaa)
Moduuli:ValidateInfobox (muokkaa)
Moduuli:Verkkoviite (näytä wikiteksti) (osittain suojattu)

Tämä sivu kuuluu seuraaviin piilotettuihin luokkiin:

Noudettu kohteesta ”https://fi.wikipedia.org/wiki/Rust_(ohjelmointikieli)”

@@ Rivi 23: / Rivi 23: @@
 '''Rust''' on [[ohjelmointikieli]], jonka on kehittänyt [[Mozilla Foundation]].<ref>{{Verkkoviite | Osoite = http://lambda-the-ultimate.org/node/4009 | Nimeke = The Rust Language | Julkaisu = Lambda The Ultimate | Ajankohta = 8.7.2010 | Viitattu = 4.9.2016 | Kieli = {{en}} }}</ref> Rust on suunniteltu suorituskykyiseksi järjestelmätason ohjelmointikieleksi, joka välttäisi tyypillisten [[C (ohjelmointikieli)|C-]] tai [[C++]]-ohjelmien [[muistinhallinta]]an liittyvät virhetilat. Sen syntaksi muistuttaa C-kieltä, mutta muuten eroaa siitä ominaisuuksiltaan. Rust sisältää muun muassa [[Nimiavaruus|nimiavaruudet]], [[rinnakkaisuus|rinnakkainajon]], [[sulkeuma (ohjelmointi)|sulkeumat]] ja [[Tyyppijärjestelmä|tyypinpäättelyn]].<ref name=":2">{{Verkkoviite | Osoite = https://www.infoq.com/news/2012/08/Interview-Rust | Nimeke = Interview on Rust, a Systems Programming Language Developed by Mozilla | Tekijä = Avram, Abel | Julkaisu = InfoQ | Ajankohta = 3.8.2012 | Julkaisija = C4Media Inc | Viitattu = 4.9.2016 | Kieli = {{en}} }}</ref>
-Muista moderneista ohjelmointikielistä poiketen Rust toteuttaa muistinhallinnan turvallisuuden ajoajan sijaan kielen syntaksissa ja ohjelman kääntämisen aikana, mikä tarkoittaa lisää rajoituksia ohjelmoijalle, mutta enemmän nopeutta ohjelman ajoon, jotta tehossa ei hävittäisi perinteisille ohjelmointikielille. Lisäksi Rustissa on pyritty kehittämään turvallisuutta myös ohjelman [[Prosessi (tietotekniikka)|säikeiden]] kilpailutilanteiden suhteen. Toisaalta Rust erottuu monista muista moderneista kielistä siten, että siinä on mahdollista myös halutessaan ohittaa turvallisuusmekanismit ja käyttää esimerkiksi [[Osoitin (ohjelmointi)|osoitinmuuttujia]] vapaasti.{{Lähde||19. tammikuuta 2020|vuosi=2020}}
+Muista moderneista ohjelmointikielistä poiketen Rust toteuttaa muistinhallinnan turvallisuuden ajoajan sijaan kielen syntaksissa ja ohjelman kääntämisen aikana, mikä tarkoittaa lisää rajoituksia ohjelmoijalle, mutta enemmän nopeutta ohjelman ajoon, jotta tehossa ei hävittäisi perinteisille ohjelmointikielille. Lisäksi Rustissa on pyritty kehittämään turvallisuutta myös ohjelman [[Säie (tietotekniikka)|säikeiden]] kilpailutilanteiden suhteen. Toisaalta Rust erottuu monista muista moderneista kielistä siten, että siinä on mahdollista myös halutessaan ohittaa turvallisuusmekanismit ja käyttää esimerkiksi [[Osoitinmuuttuja|osoitinmuuttujia]] vapaasti.{{Lähde||19. tammikuuta 2020|vuosi=2020}}
 Rust on [[Ohjelmointikielen kääntäjä|käännettävä]] kieli, joka tukee [[Unicode]]-merkistöä.{{Lähde||19. tammikuuta 2020|vuosi=2020}} Rustin käyttöön liittyen sen ohjelmointikielen kääntäjä ilmoittaa virheet tarkasti ja perusteellisesti verrattuna C- ja C++-kieliin, mikä helpottaa ohjelmointivirheiden korjaamista. Rustin kääntäjä myös jossain määrin tarjoutuu avustamaan virheiden korjaamisessa.<ref>https://medium.com/@AlexanderObregon/how-rust-compiles-an-introduction-to-the-rust-compiler-3c51027e7fb1</ref> Rust sisältää myös sisäänrakennetun valmiuden [[Yksikkötestaaminen|yksikkötestaamiselle]].

Muokataan sivua Rust (ohjelmointikieli)

Navigointivalikko

Haku