Ero sivun ”Rust (ohjelmointikieli)” versioiden välillä
[katsottu versio] | [katsottu versio] |
esimerkin pitäisi olla vain esimerkki |
esimerkkiä ei tarvita heti alussa |
||
Rivi 26: | Rivi 26: | ||
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. Merkittävä osa kielen hyvistä puolista onkin sen kääntäjässä.<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]]. |
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. Merkittävä osa kielen hyvistä puolista onkin sen kääntäjässä.<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 == |
== Ominaisuudet == |
||
Rivi 167: | Rivi 152: | ||
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" /> |
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" /> |
||
⚫ | |||
⚫ | |||
⚫ | |||
⚫ | |||
⚫ | |||
⚫ | |||
⚫ | |||
⚫ | |||
⚫ | |||
⚫ | |||
⚫ | |||
⚫ | |||
⚫ | |||
== Yhteisö == |
== Yhteisö == |
Versio 10. huhtikuuta 2024 kello 16.44
Rust | |
---|---|
Paradigma | moniparadigma, funktionaalinen, imperatiivinen |
Tyypitys | staattinen, vahva |
Yleinen suoritusmalli | käännettävä |
Muistinhallinta | RAII |
Julkaistu | 2010 |
Kehittäjä | Graydon Hoare, Rust -projektin kehittäjät |
Vakaa versio | 1.82.0 ()[1] |
Merkittävimmät toteutukset | Rust |
Vaikutteet | C++ |
Käyttöjärjestelmä | Android, FreeBSD, iOS, Linux, macOS, Windows |
Verkkosivu | Rust Language |
Rust on ohjelmointikieli, jonka on kehittänyt Mozilla Foundation.[2] Rust on suunniteltu suorituskykyiseksi järjestelmätason ohjelmointikieleksi, joka välttäisi tyypillisten C- tai C++-ohjelmien muistinhallintaan liittyvät virhetilat. Sen syntaksi muistuttaa C-kieltä, mutta muuten eroaa siitä ominaisuuksiltaan. Rust sisältää muun muassa nimiavaruudet, rinnakkainajon, sulkeumat ja tyypinpäättelyn.[3]
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äikeiden kilpailutilanteiden suhteen. Toisaalta Rust erottuu monista muista moderneista kielistä siten, että siinä on mahdollista myös halutessaan ohittaa turvallisuusmekanismit ja käyttää esimerkiksi osoitinmuuttujia vapaasti.
Rust on käännettävä kieli, joka tukee Unicode-merkistöä. 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. Merkittävä osa kielen hyvistä puolista onkin sen kääntäjässä.[4] Rust sisältää myös sisäänrakennetun valmiuden yksikkötestaamiselle.
Ominaisuudet
Rust tarjoaa korkean abstraktiotason kielen ominaisuudet matalalla prosessointitasolla. Rustin päämäärinä ovat turvallisuus, nopeus ja rinnakkaisuus.[5] Rustilla voidaan kirjoittaa käyttöjärjestelmiä, laiteajureita ja se voidaan sulauttaa toisiin ohjelmiin.[5] Tärkeitä alueita rustille ovat myös pelikehitys ja webpalvelut.
Muistinhallinta
Rust ratkaisee muistinhallinnan ongelmat käyttämällä datan omistajan, lainaamisen ja turvattoman (unsafe) käsitteitä.[6] Tämä mahdollistaa automaattista roskienkeruutakin paremmat ominaisuudet: deterministisen muistivapautuksen, ei kilpailutilanteita (data race) ja iteroijien tarkistus (ei muokata ja viitata samanaikaisesti).
Rust-ohjelmien muistialue koostuu kahdesta alueesta: pino ja 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).[6] Nämä ratkaisut mahdollistavat turvallisen rinnakkaisajon ja estävät segmentaatiovirheet, jotka C-kielessä johtuvat luvattomien muistialueiden käsittelystä.
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ä.
Jokaisella arvolla on Rustissa yksi omistaja kullakin hetkellä. Kun omistaja katoaa näkyvistä, arvo pudotetaan pois. Kekomuistissa pidettyä tietoa ei koskaan kopioida ilman clone()
-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ä (&x
, x: &Y
) eli lainataan. Referoimisen vastaoperaatio on dereferointi *x
. Yhteen arvoon voi olla yhdessä näkymässä vain yksi muuntamisen salliva referenssi (&mut x
). (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.[7]
Elinaikojen avulla referenssit ovat voimassa niin kauan kuin niitä tarvitaan. Elinaika määritellään tarvittaessa syntaksilla &'a Tyyppi
, fn nimi<'a>(x: &'a Tyyppi) -> &'a Tyyppi { ... }
, struct Nimi<'a> { x: &'a Tyyppi, }
ja impl<'a> Tyyppi<'a> { ... }
. Tätä tarvitaan, kun käytetään referenssejä eikä kääntäjällä ole tarpeeksi informaatiota varmistaa, että elinajat riittävät. 'static
tarkoittaa, että referenssi voi elää koko ohjelman ajon ajan.[7]
Tavallisten referenssien (osoittimien) lisäksi Rustissa voidaan käyttää älyosoittimia, joista tavallisimpia ovat standardikirjaston Box<T>
(kekomuistiallokaatio), Rc<T>
(referenssien laskentaan perustuva moniomistajuus) ja RefCell<T>
(lainaussääntöjen ajonaikainen tarkistus).[7]
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ä laatikko::moduuli::funktio
. Alkiot ovat oletuksena yksityisiä eli käytettävissä vain oman moduulinsa sisällä.[7]
Moduuleja käytetään seuraavan syntaksin avulla:[7]
mod x { ... }
määrittelee uuden moduulinuse laatikko::moduuli::moduuli as mdl;
tuo moduulin näkymään niin, ettei koko polkua ole tarpeen käyttää vaanmdl::funktio
riittääuse laatikko::moduuli{self, moduuli::alkio, moduuli, alkio};
tuo näkymään neljä polkua samalla lauseellapub
tekee moduuleista, alkioista tai kentistä käytettäviä moduulin ulkopuolella (julkistettava yksitellen)pub use ...;
tekee siis näkymään tuodusta polusta julkisen
Rinnakkaisohjelmointi
Rinnakkaiseen ja asynkroniseen ohjelmointiin löytyy tukea erityisesti Rustin standardikirjastosta. Esimerkiksi std::thread::spawn
ajaa annetun sulkeuman uudessa säikeessä ja palauttaa kahvan, jonka join
-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 move || println!(x);
. Viestien välitys säikeiden välillä onnistuu standardikirjaston std::sync::mpsc::channel
-funktion avulla. Myös muistin jakaminen säikeiden välillä onnistuu std::sync::Mutex
- (lukko) ja std::sync::Arc
-tietueen (moniomistajuus) avulla.[7]
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ä pub
-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 <Box<dyn Piirre>>
, joka mahdollistaa erilaisten ja uusien tyyppien käsittelemisen samassa kokoelmassa ajon aikana – kunhan ne vain toteuttavat annetun piirteen (dyn
-avainsana tulee sanasta dynaaminen). Tämä vastaa ankkatyypitystä – 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.[7]
Funktionaalinen ohjelmointi
Sulkeumat ovat Rustin nimettömiä funktioita, jotka määritellään tyylillä |x| println!("{}-{}", x, y);
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 Box<dyn Fn(T) -> T>
.[7]
Iteraattorit ovat tyyppejä, jotka palauttavat jokaisella next
-metodin kutsulla uuden arvon, kunnes kaikki arvot on kulutettu. Mikä tahansa tyyppi voi olla iteroitava, jos sille on määritelty Iterator
-piirre (Item
-tyyppi ja next
-metodi riittävät). Kun iteraattoria muutetaan muodosta toiseen, collect
-metodilla (tai muulla ns. kuluttavalla metodilla) voidaan lopuksi kuluttaa se, eli esim. palauttaa iteraattorista haluttu vektorityypin rakenne (vektori.iter().map(sulkeuma).collect();
).[7]
Funktioita voidaan antaa argumentteina toisiin funktioihin, jotka on määritelty tyylillä fn nimi(f: fn(T) -> T, x: T) -> T { f(x) }
.[7]
Hahmonsovitus on Rustissa hyvin tavallista. Se onnistuu match
-, if let
-, while let
-, for
- ja let
-lauseissa sekä funktioiden parametreissa. Hahmonsovitus mahdollistaa myös monikkojen, tietueiden ja luetteloiden destrukturoinnin tyylillä let (x, y) = (1, 2)
. Alaviivalla _
voidaan jättää osia hahmosta huomiotta ja ..
-syntaksilla voidaan jättää kokonainen arvoväli jostakin kokoelmasta huomiotta.[7]
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ä macro_rules! nimi { hahmo => koodi }
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ä makro!...
tai attribuutteina tyylillä #[makro(...)]
ja #[derive(makro)]
.[7]
Yleisiä makroja ovat[7]
println!
, joka kirjoittaa standarditulosteeseeneprintln!
, joka kirjoittaa standardivirheeseendgb!
, joka kirjoittaa standardivirheeseen käyttämälläDebug
-piirteen määrittelemää formaattiaassert_eq!
, joka varmistaa yhtäläisyydenformat!
, joka liittää muuttujien saamat arvot tekstiliteraaliinpanic!
, joka pysäyttää ohjelman virheeseen
Virheidenhallinta
Rustissa käsitellään virheitä yleensä luettelon enum Result<T, E> { Ok(T), Err(E), }
ja hahmonsovituksen match
avulla. Result
-arvon voi käsitellä erityisen lyhyesti ?
-operaattorin avulla tyylillä moduuli::funktio()?
, jolloin tilanteessa Ok(arvo)
lauseke palauttaa suoraan arvo
. ?
-operaattori on käytettävissä vain funktioissa, jotka palauttavat Result
- tai vastaavan tyypin arvon. Toinen tavallinen tapa on käyttää Result
-arvon unwrap_or_else
-metodia, joka palauttaa arvon tai ajaa annetun sulkeuma. expect
-metodi taas kutsuu virhetilanteessa suoraan panic!
-makron, mikä on hyödyllistä ohjelman kehityksen alkuvaiheessa.[7]
Tietotyypit
Tietotyyppejä Rustissa ovat muun muassa[7]
- Kokonaisluvut muotoa
i32
(oletus),isize
,u64
ja literaalit5
,10_000
,0b1010_0011
- Liukuluku
f32
jaf64
ja literaalit esim.2.
ja-24.55
- Boolen tyyppi ja literaalit
true
jafalse
- Merkki
char
ja literaalit't'
(ei"
) - Monikko esim.
(1, 2.0, 'c')
((i32, f32, char)
) - Taulukko esim.
[1, 2, 3]
([i32; 3]
), millä on vakiopituus - Teksti
String
(muunnettava) ja literaalit"Hei, Wikipedia!"
(muuttumaton) - Viipale
&x[0..5]
("Hei, Wikipedia!"
on myös viipale tyyppiä&str
) - Tietue
struct Nimi { nimi: String }
, josta luodaan instanssi tyylilläNimi { nimi: String::from("Arvo"), };
- Monikkotietue
struct Nimi(i32, String);
, jonka kenttiä ei nimetä - Yksikkötietue
struct Nimi;
, jolla ei ole kenttiä - Luettelo
enum Nimi { Variantti1(u8), Variantti(String, i32), }
, josta voidaan tehdä instansseja tyylillälet x = Nimi::Variantti1(8);
. Rustissa ei olenull
-arvoa vaan puuttuvaa arvoa edustamaan käytetään tyyppiäenum Option<T> { None, Some(T), }
. - Vektori
Vec<T>
, joka sisältää vaihtelevan pituisen, samaa tyyppiä olevan arvojonon. Instanssi voidaan luoda makrollavec![1, 2, 3]
. - Hajautustaulu
std::collections::HashMap
- Piirreobjektit
Box<dyn Error>
- Geneeriset tyypit
None
,Some
,Option
Ok
,Err
,Result
Geneeriset rakenteet
Geneerisiä funktioita voidaan määritellä tyylillä fn nimi<T>(x: &T) -> &T { ... }
, tietueissa struct Nimi<T> { x: T }
, luetteloissa enum Nimi<T> { Tyyppi(T), }
ja metodeissa impl<T> Nimi<T> { fn nimi(&self) -> &T { ... }
. Geneerinen koodi laajennetaan automaattisesti spesifiseksi käännösvaiheessa (engl. monomorphization), joten nämä geneeriset tyypit eivät hidasta ohjelmaa.[7]
Piirteet
Piirteet (engl. traits) ovat Rustin tapa organisoida metodeja rajapinnoiksi. Ne määritellään tyylillä trait Piirre { fn metodi(&self) -> Tyyppi; ... }
. Piirteeseen voidaan kirjoittaa oletustoteutus. Tyypille tehdään piirteen toteutus tyylillä impl Piirre for Tyyppi { ... }
– 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ä fn nimi(x: &impl Piirre) { ... }
tai fn nimi<T, U>(x: &T, y: &U) -> impl Piirre4 where T: Piirre1 + Piirre2, U: Piirre3 { ... }
. Samaan tapaan voidaan kirjoittaa geneeriselle tyypille metodeita (tai vastaava piirretoteutus) niin, että tämä koskee vain tietyt piirteet toteuttavia versioita, tyylillä impl<T: Piirre> Tyyppi<T> { ... }
.[7]
Tavallisia piirteitä ovat muun muassa[7]
Display
Clone
Debug
Copy
ToString
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.[5]
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.[8]
Pakettien asennus
Rust käyttää kirjastojen ja valmiiden rust-ohjelmien hallintaan Cargo-paketinhallintaa, joka perustuu Rubyn Bundler-paketinhallintaan. Cargo asentaa crate-ohjelmistopaketit crates.io-verkkopalvelusta.[9] Cargo toimii myös työvälineenä rust-ohjelmien rakentamiseen, korvaten historiallisen maken.
Testaaminen
Cargo helpottaa automaattista testaamista ajamalla kaikki tietyllä tavalla määritellyt testit komennolla cargo test
. Yksi tapa on kirjoittaa testit kuhunkin lähdetiedostoon #[cfg(test)]
-attribuutilla merkittyyn tests
-moduuliin, jossa testifunktioille annetaan attribuutti #[test]
. Toinen tapa on luoda tests
-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 assert!
, assert_eq!
ja assert_ne!
, mutta testin läpäisyä voi edustaa myös Ok(())
(ja virhettä Err(virhe))
. Normaalisti panic!
-kutsu tarkoittaa, ettei testiä läpäisty – päinvastaisessa tilanteessa käytetään attribuuttia #[should_panic(expected = "osa virheviestiä")]
.
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.[3]
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).[10] Kieltä kehitettäessä lähestymistapa on Klabnikin mukaan ollut empiirinen iteraatio, jossa implementoitujen ominaisuuksien toimivuus kokeillaan ennen niiden hyväksymistä.
Rust 1.0.0 julkaistiin 15. toukokuuta 2015. Julkaisuvuonna rustc-kääntäjän toteutuksessa oli 1 410 osallistujaa.[10] Hoare käytti rustin toteuttamiseen aluksi OCamlilla kirjoitettua tulkkia. Nykyisin rust on kirjoitettu rustilla.[10]
Esimerkki
Hello world -ohjelma.
// main.rs
// Ajo alkaa main-funktiosta.
fn main() {
// println-makro kirjoittaa stdout:iin.
println!("Hei, Wikipedia!");
}
// $ rustc main.rs
// $ ./main
// > Hei, Wikipedia!
Yhteisö
Klabnikin mukaan projektissa pidetty tärkeänä itse kielen ominaisuuksien lisäksi ekosysteemiä, työkaluohjelmia, vakautta ja yhteisöä.[10] 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.
Rust-koodia käyttävät muun muassa:
- Firefox-selain[11]
- Dropbox[12]
- Cloudflare, sen Pingora-palvelinohjelma[13]
- Tor-anonyymiverkkoalusta[14]
- npm-paketinhallinnan pakettirekisteri[15]
- Facebook, Rust Foundationin jäsen vuodesta 2016[16]
- Linux (ydin) versiosta 6.1 alkaen[17]
- Android versiosta 12 alkaen[18]
Vuonna 2024 Google on rahoittanut Rust Foundation -säätiötä miljoonalla dollarilla. Rahoitus on merkitty C++:n ja Rustin yhteensopivuuteen "Interop Initiative" -projektiin.[19]
Lähteet
- ↑ (en) Announcing Rust 1.82.0, (viitattu ). Tieto on haettu Wikidatasta.
- ↑ The Rust Language Lambda The Ultimate. 8.7.2010. Viitattu 4.9.2016. (englanniksi)
- ↑ a b Avram, Abel: Interview on Rust, a Systems Programming Language Developed by Mozilla InfoQ. 3.8.2012. C4Media Inc. Viitattu 4.9.2016. (englanniksi)
- ↑ https://medium.com/@AlexanderObregon/how-rust-compiles-an-introduction-to-the-rust-compiler-3c51027e7fb1
- ↑ a b c The Rust Programming Language The Rust Project Developers. Viitattu 22.10.2016. (englanniksi)
- ↑ a b The Rust Reference – 10 Memory model 2011. The Rust Project Developers. Viitattu 22.10.2016. (englanniksi)
- ↑ a b c d e f g h i j k l m n o p q r https://doc.rust-lang.org/stable/book (viitattu 14.11.2022)
- ↑ Rustup: The Rust Toolchain Installer Rustup. GitHub. Viitattu 9.9.2017. (englanniksi)
- ↑ Cargo, Rust’s Package Manager Crates. Viitattu 22.10.2016. (englanniksi)
- ↑ a b c d Klabnik, Steve: The History of Rust. Applicative 2016, 1.1.2016. New York: Association for Computing Machinery. doi:10.1145/2959689.2960081 (englanniksi)
- ↑ Serdar Yegulalp: Mozilla's Rust-based Servo browser engine inches forward InfoWorld. 3.4.2015. Viitattu 28.2.2019. (englanniksi)
- ↑ Go-ing to Rust: Optimizing Storage at Dropbox. QCon San Francisco 2016 going-rust-optimizing-storage-dropbox.html. 14.7.2016. Viitattu 28.2.2019. (englanniksi)[vanhentunut linkki]
- ↑ https://blog.cloudflare.com/pingora-open-source
- ↑ Sebastian Hahn: ? lists.torproject.org. 31.3.2017. Viitattu 28.2.2019. (englanniksi)
- ↑ Rust Case Study: Community makes Rust an easy choice for npm The Rust Project Developers. 2019. Rust-lang.org. Viitattu 28.2.2019. (englanniksi)
- ↑ https://engineering.fb.com/2021/04/29/developer-tools/rust/
- ↑ https://www.zdnet.com/article/rust-in-linux-where-we-are-and-where-were-going-next/
- ↑ Jeffrey Vander Stoep: Memory Safe Languages in Android 13 security.googleblog.com. 1.12.2022. Viitattu 3.2.2023. (englanniksi)
- ↑ Google Contributes $1M to Rust Foundation to Support C++/Rust “Interop Initiative” foundation.rust-lang.org. 5.2.2024. Viitattu 6.2.2024. (englanniksi)
Aiheesta muualla
- Virallinen rust-asennustyökalu rustup (Windows, Linux, Unix) (englanniksi)
- Rust-leikkikenttä Rust Languagessa Kokeile Rust-kieltä selaimellasi (englanniksi)
- Rust-leikkikenttä integer32.com:issa Kokeile Rust-kieltä selaimellasi (englanniksi)
- Dunham, E: Rust 101 Käytännön johdatus Rustiin Australaasian Linux-konferenssissa. (webm-video) Wikimedia Commons. (englanniksi)
|
|