Rust (programozási nyelv)

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

1. teljeskörűen a biztonságos programozásra törekszik,
2. ugyanakkor lehetőséget ad „unsafe { ... }” blokkok forráskódban való elhelyezésére, amely kulcsszó ebben a blokkban kikapcsolja Rust „védőhálóját”,
3. egyúttal könnyen integrálható a meglévő C-ben vagy más nyelven írt szoftverkomponensekkel.

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.77.2 (stabil verzió, 2024. április 9.)
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

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.82, ami a „Rust 2024 Edition” – várható kiadás, aktív tervezés alatt

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 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 objektum orientá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ő. 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.

Kódtisztaság

• Egységes kódkinézet: rustfmt *.rs vagy cargo fmt
• Olyan gyakori hibák feltárása, amelyre van elegánsabb Rust kifejezés: cargo clippy