Rust (programozási nyelv)

A Wikipédiából, a szabad enciklopédiából
Ugrás a navigációhoz Ugrás a kereséshez
Rust
Official Rust logo
Official Rust logo

Paradigma
Jellemző kiterjesztés
  • rs
  • rlib
Megjelent 2010. július 7.
Tervező Graydon Hoare
Fejlesztő
Utolsó kiadás1.39.0 (stabil verzió, 2019. november 7.)[1]
Hatással volt rá
Operációs rendszer platformfüggetlen
Licenc
  • Apache Licenc 2.0
  • MIT Licenc
Weboldal

A Rust egy programozási nyelv.

Története[szerkesztés]

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.xx, ami a „Rust 2021 Edition” nevet fogja viselni.

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[szerkesztés]

A Rust 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[szerkesztés]

Metódus[szerkesztés]

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) -> Rectangle {
       Rectangle { 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[szerkesztés]

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ó.

Cargo[szerkesztés]

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.
  1. https://blog.rust-lang.org/2019/11/07/Rust-1.39.0.html