آموزش زبان راست (Rust) از صفر با تمرین در مرورگر

fn main() {
    let scores = [("Sara", 18.5), ("Reza", 12.0), ("Mina", 19.75), ("Ali", 9.5), ("Nima", 15.25)];
 
    // زنجیرهٔ iterator: نه حلقهٔ دستی لازم است و نه متغیر شمارنده
    let passed: Vec<_> = scores.iter().filter(|(_, s)| *s >= 10.0).collect();
    let average = scores.iter().map(|(_, s)| s).sum::<f64>() / scores.len() as f64;
    let best = scores.iter().max_by(|a, b| a.1.total_cmp(&b.1)).unwrap();
 
    for (name, score) in &scores {
        let bar = "#".repeat((*score / 2.0) as usize);
        println!("{:<5} {:>6.2} {}", name, score, bar);
    }
    println!("passed: {} of {}", passed.len(), scores.len());
    println!("average: {:.2}", average);
    println!("best: {} ({})", best.0, best.1);
}

// هر مقدار یک صاحب دارد. با & فقط قرض می‌دهید و با &mut اجازهٔ تغییر هم می‌دهید
fn total(prices: &[u32]) -> u32 {
    prices.iter().sum() // فقط می‌خواند؛ مالکیت نزد صدازننده می‌ماند
}
 
fn add_tax(prices: &mut Vec<u32>) {
    for p in prices.iter_mut() {
        *p += *p / 10; // ده درصد مالیات، روی همان داده
    }
}
 
fn archive(prices: Vec<u32>) -> String {
    // این تابع صاحب prices می‌شود و در پایانش حافظهٔ آن آزاد می‌شود
    format!("archived {} prices, max {}", prices.len(), prices.iter().max().unwrap())
}
 
fn main() {
    let mut prices = vec![1000, 2500, 4000];
    println!("total before tax: {}", total(&prices));
 
    add_tax(&mut prices);
    println!("after tax: {:?}", prices);
 
    let backup = prices.clone(); // یک کپی مستقل
    println!("{}", archive(prices)); // مالکیت prices به تابع منتقل شد
    println!("backup: {:?}", backup);
 
    // println!("{:?}", prices);
    // کامپایلر خط بالا را نمی‌پذیرد: prices منتقل شده و دیگر در دسترس نیست
}

use std::io::{self, BufRead};
 
// هر فرمان یکی از این سه حالت است و هر حالت دادهٔ خودش را دارد
enum Command {
    Deposit(u32),
    Withdraw(u32),
    Balance,
}
 
fn parse(line: &str) -> Result<Command, String> {
    let parts: Vec<&str> = line.split_whitespace().collect();
    match parts.as_slice() {
        ["deposit", n] => n.parse().map(Command::Deposit).map_err(|_| format!("bad amount: {}", n)),
        ["withdraw", n] => n.parse().map(Command::Withdraw).map_err(|_| format!("bad amount: {}", n)),
        ["balance"] => Ok(Command::Balance),
        _ => Err(format!("unknown command: {}", line)),
    }
}
 
fn main() {
    let mut balance: u32 = 0;
    for line in io::stdin().lock().lines() {
        let line = line.unwrap();
        // match باید همهٔ حالت‌ها را پوشش دهد، وگرنه کامپایل نمی‌شود
        match parse(&line) {
            Ok(Command::Deposit(n)) => balance += n,
            Ok(Command::Withdraw(n)) if n > balance => println!("refused: balance is {}", balance),
            Ok(Command::Withdraw(n)) => balance -= n,
            Ok(Command::Balance) => println!("balance: {}", balance),
            Err(e) => println!("error: {}", e),
        }
    }
}

use std::fmt;
 
// trait یک قرارداد است: هر نوعی که آن را پیاده کند، مساحت دارد و چاپ می‌شود
trait Shape: fmt::Display {
    fn area(&self) -> f64;
}
 
struct Circle { r: f64 }
struct Rect { w: f64, h: f64 }
 
impl Shape for Circle {
    fn area(&self) -> f64 { std::f64::consts::PI * self.r * self.r }
}
impl Shape for Rect {
    fn area(&self) -> f64 { self.w * self.h }
}
impl fmt::Display for Circle {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "circle r={}", self.r) }
}
impl fmt::Display for Rect {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "rect {}x{}", self.w, self.h) }
}
 
fn main() {
    // نوع‌های مختلف در یک فهرست، با Box<dyn Shape>
    let mut shapes: Vec<Box<dyn Shape>> = vec![
        Box::new(Rect { w: 4.0, h: 2.5 }),
        Box::new(Circle { r: 1.5 }),
        Box::new(Rect { w: 3.0, h: 3.0 }),
        Box::new(Circle { r: 0.5 }),
    ];
    shapes.sort_by(|a, b| b.area().total_cmp(&a.area()));
 
    for s in &shapes {
        println!("{:<12} {:>6.2}", s.to_string(), s.area());
    }
    let sum: f64 = shapes.iter().map(|s| s.area()).sum();
    println!("{:<12} {:>6.2}", "total", sum);
}

use std::sync::mpsc;
use std::thread;
 
// طول دنبالهٔ کولاتز: عدد زوج نصف می‌شود و عدد فرد سه برابر به‌علاوهٔ یک
fn steps(mut n: u64) -> u32 {
    let mut count = 0;
    while n != 1 {
        n = if n % 2 == 0 { n / 2 } else { 3 * n + 1 };
        count += 1;
    }
    count
}
 
fn main() {
    let (tx, rx) = mpsc::channel();
    for part in 0..4u64 {
        let tx = tx.clone();
        // هر thread یک بازه را بررسی می‌کند و نتیجه را از کانال می‌فرستد
        thread::spawn(move || {
            let range = part * 250_000 + 1..=(part + 1) * 250_000;
            let best = range.map(|n| (steps(n), n)).max().unwrap();
            tx.send((part, best)).unwrap();
        });
    }
    drop(tx);
 
    // نتیجه‌ها به هر ترتیبی برسند، مرتب‌شده چاپ می‌شوند
    let mut results: Vec<_> = rx.iter().collect();
    results.sort();
    for (part, (len, n)) in &results {
        println!("part {}: longest chain starts at {:>6} ({} steps)", part + 1, n, len);
    }
    let (len, n) = results.iter().map(|r| r.1).max().unwrap();
    println!("winner: {} with {} steps", n, len);
}