Rust: limbajul care te ceartă ca un prieten

Există un limbaj pe care programatorii îl votează an de an drept cel mai iubit, în care se rescriu bucăți din Windows, din Linux și din motorul Firefox — și care e faimos pentru cel mai politicos compilator din industrie: nu doar îți arată eroarea, ci îți propune și rezolvarea. Azi îl guști. La finalul laboratorului vei avea două executabile Rust construite cu cargo: un salut personalizat și — a treia oară în acest modul, a treia limbă — jocul „ghicește numărul". Același joc, ca să simți diferența dintre limbaje, nu dintre probleme.

Ce îți trebuie

• Rust, instalat prin unealta oficială rustup de pe rust-lang.org — butonul „Install"; pe Windows descarci și rulezi rustup-init.exe, pe macOS/Linux copiezi comanda afișată în terminal. Accepți instalarea standard (Enter) și aștepți câteva minute.
• VS Code cu extensia rust-analyzer (o cauți în Extensions) — subliniază erorile în timp ce scrii, înainte de compilare.
• Cont: niciunul. Internet: da, la instalare și la prima descărcare de pachete.
• Timp: 20 minute instalare + hello, 45 pe joc, restul pe misiune.

Verificarea, în terminal nou (important — cel vechi nu știe de instalare):

cargo --version

cargo e mai mult decât compilatorul: e managerul de proiecte al lui Rust — creează, compilează, rulează și aduce pachete, toate cu o singură unealtă. După aventura manuală cu g++ din laboratorul 4, o să-l apreciezi imediat.

Primul proiect: cargo face ordinea, tu faci codul

1. În folderul tău de proiecte:

cargo new salut-rust
cd salut-rust

Cargo ți-a construit un proiect întreg: Cargo.toml (cartea de identitate: nume, versiune, dependențe) și src/main.rs cu un program deja scris. Deschide folderul în VS Code.

2. Rulează ce există:

cargo run

Cargo compilează (Rust e compilat, ca C++ — vezi mesajele Compiling și Finished) și rulează executabilul imediat. Compilare + rulare într-un gest — exact ce ne lipsea la laboratorul 4.

3. Fă programul al tău în src/main.rs:

fn main() {
    let nume = "Ana";
    let varsta = 14;
    println!("Salut, {}! Anul viitor vei avea {} ani.", nume, varsta + 1);
}

Ce recunoști: fn main e ruda lui int main din C++, acoladele delimitează blocul, let declară variabile ca în alte limbaje moderne. Ce e nou: println! cu semnul exclamării (e un macro — deocamdată reține doar semnul), iar fiecare pereche {} din text e completată, în ordine, cu valorile de după virgulă.

4. Acum partea pentru care ai venit — provoacă intenționat compilatorul. Adaugă linia:

    nume = "Mihai";

și rulează cargo run. Citește toată eroarea: Rust îți spune că variabilele sunt implicit neschimbabile, îți arată exact linia, și îți sugerează el singur: help: consider making this binding mutable: mut nume. Repară urmând sfatul (let mut nume = "Ana";) și convinge-te că trece. Un compilator care îți dă soluția în mesajul de eroare — ăsta e argumentul de vânzare al Rust-ului.

Jocul, a treia oară: ghicește numărul în Rust

5. Proiect nou (cd .. mai întâi):

cargo new ghiceste-rust
cd ghiceste-rust

6. Numerele aleatoare nu sunt incluse în limbaj — vin dintr-un pachet (aici pachetele se numesc crates). Cargo îl aduce cu o comandă:

cargo add rand

Deschide Cargo.toml: la [dependencies] a apărut rand. Prima compilare de acum va descărca pachetul singură.

7. Jocul complet, în src/main.rs — tastează-l, nu-l copia cu ochii închiși, pentru că la punctul de control explici trei linii din el:

use std::io;
use rand::Rng;

fn main() {
    let secret = rand::thread_rng().gen_range(1..=100);
    let mut incercari = 0;

    println!("M-am gandit la un numar intre 1 si 100.");

    loop {
        println!("Ghiceste:");

        let mut text = String::new();
        io::stdin().read_line(&mut text).expect("Nu am putut citi");

        let raspuns: i32 = match text.trim().parse() {
            Ok(numar) => numar,
            Err(_) => {
                println!("Asta nu e un numar. Mai incearca.");
                continue;
            }
        };

        incercari += 1;

        if raspuns < secret {
            println!("Prea mic.");
        } else if raspuns > secret {
            println!("Prea mare.");
        } else {
            println!("Corect! Din {} incercari.", incercari);
            break;
        }
    }
}

8. cargo run și joacă o rundă.

Ghid de lectură, pe scurt — comparațiile sunt cu versiunile tale din Python și C++:

• loop + break țin locul lui while raspuns != secret: buclă infinită din care ieși explicit la victorie.
• let mut la incercari și text — tot ce se schimbă trebuie declarat schimbabil; ce ai pățit la pasul 4, aplicat.
• Blocul match ... Ok/Err e răspunsul Rust la problema pe care Python-ul tău o avea din laboratorul 1: utilizatorul tastează „abc". Rust te obligă să spui ce se întâmplă și în cazul bun (Ok) și în cel rău (Err) — aici, mesaj politicos și continue la următoarea încercare. Jocul tău în Rust e din prima mai robust decât era în Python.
• 1..=100 e intervalul închis 1-100; fără =, capătul din dreapta ar fi exclus.

Dacă nu merge

• cargo: command not found după instalare: terminal nou sau repornește VS Code — PATH-ul se încarcă la deschidere.
• use of undeclared crate or module rand: cargo add rand nu a rulat sau a rulat în alt proiect. Verifică în Cargo.toml că rand există la [dependencies] și că ești în folderul ghiceste-rust.
• Eroare la gen_range: sintaxa intervalului — corect e gen_range(1..=100). Dacă mesajul pomenește de versiuni și metode, spune-i profesorului: pachetul rand și-a mai schimbat API-ul de-a lungul versiunilor, iar mesajul compilatorului indică forma cerută de versiunea ta.
• Compilarea pare blocată la prima rulare: descarcă și compilează dependențele o singură dată — poate dura 1-2 minute pe calculatoarele de la școală. Următoarele rulări sunt rapide.
• Erori misterioase după modificări: citește mesajul până la capăt înainte să chemi ajutor — la Rust, spre deosebire de aproape orice alt limbaj, răspunsul chiar e în mesaj, de obicei la secțiunea help:.

Misiunea ta

Nivel de bază (obligatoriu): ambele proiecte compilează și rulează: salutul personalizat și jocul complet, cu protecția la text invalid demonstrată.

Extindere: limitează jocul la 7 încercări — după a șaptea greșeală, jocul anunță înfrângerea și dezvăluie secretul. Îți ajunge un if incercari >= 7 cu break la locul potrivit.

Provocare: scrie un mini-eseu de programator, direct în cod: comentarii (//) în main.rs care compară, în 5-6 rânduri, cele trei versiuni ale jocului — Python, C++ (dacă ai făcut laboratorul 4) și Rust. Ce a fost cel mai ușor de scris? Care versiune rezistă cel mai bine la utilizatori răuvoitori? Pe care ai putea-o da unui coleg fără instrucțiuni de instalare?

Ai terminat când:

• cargo run pornește jocul din folderul proiectului, fără erori și fără avertismente;
• „abc", „", „3.14" și „999" primesc toate un răspuns rezonabil, nu un crash — testat de colegul de bancă;
• ai reparat cel puțin două erori de compilare folosind doar sugestiile compilatorului, fără ajutor extern;
• poți numi două diferențe concrete Rust vs Python văzute pe propriul cod.