PROFILPELAJAR.COM

	Rust
Paradigma	systems programming; funkcionális programozás; párhuzamos programozás; Generikus programozás; imperatív programozás; objektumorientált programozás;
Jellemző kiterjesztés	rs
Megjelent	2006
Tervező	Graydon Hoare
Fejlesztő	Mozilla; Graydon Hoare; Rust Foundation;
Utolsó kiadás	1.83.0 (stabil verzió, 2024. november 28.)
Hatással volt rá	Alef; C++; C#; Cyclone; Erlang; Haskell; Limbo; Newsqueak; OCaml (programozási nyelv); Ruby; Scheme; SML; Swift;
Licenc	Apache Licenc 2.0; MIT-licenc;
	Weboldal

A Rust egy programozási nyelv. Különlegességét az adja, hogy

teljeskörűen a biztonságos programozásra törekszik,
ugyanakkor lehetőséget ad „unsafe { ... }” blokkok forráskódban való elhelyezésére, amely itt olyan metódusok használatát is lehetővé teszi, amely túlmutat a fordító biztonsági garanciáin
egyúttal könnyen integrálható a meglévő C-ben vagy más nyelven írt szoftverkomponensekkel.

Ezáltal a Rust biztonságos programozást tesz lehetővé, ugyanakkor a hardverközeli programozáshoz elengedhetetlen nem biztonságos megoldásokat szintén támogatja.

Története

Graydon Hoare kezdte el a nyelv fejlesztését 2006-ban, majd 2009-től a Mozilla is érdekelté vált a nyelv fejlesztésében, amit 2010-ben mutatott be. Mérföldkövek:

2012: első alpha kiadás
2015: Rust-1.0, ami a „Rust 2015 Edition”
2018: Rust-1.31, ami a „Rust 2018 Edition”
2021: Rust-1.56, ami a „Rust 2021 Edition”
2024: Rust-1.85, ami a „Rust 2024 Edition” – várható kiadás, aktív tervezés alatt^[2]

A Rust nyelv dinamikusan fejlődik. A fejlesztés során a fordító új stabil verziója 6 hetente jelenik meg. Az új verziókban gyakran jelentős újdonságok vannak.

Tulajdonsága

A Rust programozási nyelv^[3] alapvetően a C-re és a C++-ra épít, ugyanakkor nem implementál minden C++ -paradigmát és számos más nyelvből is vesz át ötleteket. Statikusan típusos és fordított nyelv.

A hangsúly a típushelyességen, memóriakezelésen, párhuzamosságon és a teljesítményen van. Összetett memória modellt alkalmaz, ami lehetővé teszi a hatékony adatszerkezetek és biztonságos konkurens minták használatát, illetve tiltja az érvénytelen memória hozzáféréseket amik szegmentációs hibákhoz vezethetnek. Rendszerprogramozásra tervezték.

Támogatja a multi-paradigma programozást, procedurális, funkcionális és objektumorientált módon. Néhány tulajdonsága:

Típuskikövetkeztetés: a típusok megadások a deklarációkban opcionális általában
Biztonságos task alapú konkurencia kezelés: task-okat alkalmaz a párhuzamosság megvalósításához, a köztük lévő kommunikációt pedig üzenetekkel valósítja meg és nem megosztott memóriával.
Magasabb rendű függvények. hatékony és flexibilis closure-k biztosítják
Mintaillesztés és algebrai típusok: minta illesztés a felsorolási típusoknál (hatékonyabban, mint C-ben), az algebrai típusok hasonlóak a funkcionális nyelvekben lévőkhöz
Polimorfizmus, típusváltozós függvények és típusok, típusosztályok és objektumorientált stílusú interfészek

Példakód

Metódus

Alábbi egyszerű példában téglalap struktúrát definiálunk (szélesség, magasság), majd implementálunk rá egy area metódust, amit meghívva visszakapjuk a téglalap területét.

struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    // A new() metódus hívása látja el a konstruktor szerepét.
    // Nem kötelező new() metódust készíteni.
    fn new(w: u32, h: u32) -> Self {
       Self { width: w, height: h }
    }

    fn area(&self) -> u32 {
        self.width * self.height
    }
}

fn main() {
    let rect1 = Rectangle { width: 3, height: 2 };
    let rect2 = Rectangle { width: 4, height: 5 };
    let rect3 = Rectangle::new(10, 20);            // ha van new() metódus

    println!("Area of rect1: {}", rect1.area());
    println!("Area of rect2: {}", rect2.area());
    println!("Area of rect3: {}", rect3.area());
}

A Rust-nak nincs nyelvi szinten konstruktora, viszont szokás new() metódust készíteni, amit a rect3-nál látható módon lehet használni. Bővebben: https://www.rust-lang.org/learn

Iterátor

Az alábbi példakód egy szövegből az ismétlődő szavakat eltávolítja. Ciklus helyett a Python nyelvhez hasonlóan iterátor és adaptereinek felhasználásával tömörebb, átláthatóbb forráskód készíthető:

use std::collections::HashSet;

fn remove_dup_words(s: &str) -> String {
    let mut wordlist: HashSet<&str> = HashSet::new();

    let v: Vec<&str> = s
        .split_whitespace()
        .filter(|w| wordlist.insert(w))
        .collect();
    v.join(" ")
}

fn main() {
    let res = remove_dup_words("víz árvíz víz víz ár árvíz");
    println!("{}", res); // víz árvíz ár
}

A példában használt HashSet::insert() leírása itt látható.

Az iménti példa itertools csomag felhasználásával is megoldható:

use itertools::Itertools;

fn main() {
    let s = "víz árvíz víz víz ár árvíz";
    let res = s.split_whitespace().unique().join(" ");
    println!("{}", res); // víz árvíz ár
}

Cargo

A Cargo a Rust programozási nyelvhez készült igen hatékony csomagkezelő.^[4] Segítségével

létrehozhatunk projektet: cargo new teszt
fordíthatunk programot: cargo build
futtathatunk (fordít + futtat): cargo run
futtathatunk unit tesztet: cargo test
benchmarkolhatunk: cargo bench
törölhetjük a fordítási munkamappákat: cargo clean
Cargo.toml állomány [dependencies] részébe beírhatjuk a fordításkor a crates.io-ról letöltendő csomag nevét akár konkrét verziószámmal együtt, netán saját git repóból letöltendő csomagot, továbbá ebben az állományban sok egyéb dolgot beállíthatunk.