রাস্ট চিটশিট

fn main() {
    println!("হ্যালো, রাস্ট!");
}

let x = 5;

let mut y = 10;
y = 15;

const MAX: i32 = 100;

let x = 42; // স্বয়ংক্রিয়ভাবে i32
let y: u32 = 42; // স্পষ্ট টাইপ

let s1 = String::from("হ্যালো");
let s2 = s1; // s1 এর মালিকানা s2-এ চলে যায়
// println!("{}", s1); // এরর: s1 ব্যবহারযোগ্য নয়

let s = String::from("হ্যালো");
let r = &s;
println!("{}", r); // হ্যালো

let mut s = String::from("হ্যালো");
let r = &mut s;
r.push_str(", রাস্ট!");
println!("{}", r); // হ্যালো, রাস্ট!

let s1 = String::from("হ্যালো");
let s2 = s1.clone(); // গভীর কপি
println!("s1: {}, s2: {}", s1, s2);

fn add(a: i32, b: i32) -> i32 {
    a + b // সেমিকোলন ছাড়া = রিটার্ন
}
 
fn main() {
    let sum = add(5, 3);
    println!("যোগফল: {}", sum);
}

let double = |x: i32| x * 2;
println!("দ্বিগুণ: {}", double(5));

let age = 20;
if age >= 18 {
    println!("প্রাপ্তবয়স্ক");
} else if age > 0 {
    println!("শিশু");
} else {
    println!("অবৈধ");
}

let status = if age >= 18 { "প্রাপ্তবয়স্ক" } else { "শিশু" };

for i in 0..3 {
    println!("গণনা: {}", i);
}

let t = (1, "হ্যালো", 3.14);
println!("প্রথম: {}", t.0);
let (x, y, z) = t; // ডিস্ট্রাকচারিং

let a = [1, 2, 3, 4];
println!("প্রথম: {}", a[0]);

let mut v = Vec::new();
v.push(1);
v.push(2);
println!("ভেক্টর: {:?}", v);
 
let v2 = vec![1, 2, 3];

struct User {
    name: String,
    age: u32,
    active: bool,
}
 
let user = User {
    name: String::from("রহিম"),
    age: 25,
    active: true,
};
 
println!("নাম: {}", user.name);

impl User {
    fn greet(&self) -> String {
        format!("হ্যালো, {}!", self.name)
    }
}
 
let greeting = user.greet();

enum Direction {
    North,
    South,
    East,
    West,
}
 
let dir = Direction::North;

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
}
 
let msg = Message::Write(String::from("হ্যালো"));

enum Coin {
    Penny,
    Nickel,
}
 
let coin = Coin::Penny;
match coin {
    Coin::Penny => println!("১ সেন্ট"),
    Coin::Nickel => println!("৫ সেন্ট"),
}

let x: Option<i32> = Some(5);
match x {
    Some(val) => println!("মান: {}", val),
    None => println!("কিছু নেই"),
}

let num = Some(10);
let result = num.unwrap_or(0); // ১০, None হলে ০

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err(String::from("শূন্য দিয়ে ভাগ করা যায় না"))
    } else {
        Ok(a / b)
    }
}
 
match divide(10, 2) {
    Ok(result) => println!("ফলাফল: {}", result),
    Err(e) => println!("এরর: {}", e),
}

fn try_divide() -> Result<i32, String> {
    let result = divide(10, 2)?;
    Ok(result)
}

trait Printable {
    fn print(&self) -> String;
}
 
struct Book {
    title: String,
}
 
impl Printable for Book {
    fn print(&self) -> String {
        format!("বই: {}", self.title)
    }
}
 
let book = Book { title: String::from("রাস্ট গাইড") };
println!("{}", book.print());

trait Describable {
    fn describe(&self) -> String {
        String::from("অজানা")
    }
}
 
impl Describable for Book {}

fn largest<T: PartialOrd>(a: T, b: T) -> T {
    if a > b { a } else { b }
}
 
let max = largest(5, 10); // ১০

use std::thread;
use std::time::Duration;
 
fn main() {
    let handle = thread::spawn(|| {
        for i in 1..5 {
            println!("থ্রেড: {}", i);
            thread::sleep(Duration::from_millis(100));
        }
    });
 
    for i in 1..3 {
        println!("মেইন: {}", i);
        thread::sleep(Duration::from_millis(100));
    }
 
    handle.join().unwrap();
}

use std::sync::mpsc;
 
fn main() {
    let (tx, rx) = mpsc::channel();
 
    thread::spawn(move || {
        tx.send(String::from("হ্যালো")).unwrap();
    });
 
    let received = rx.recv().unwrap();
    println!("পাওয়া গেছে: {}", received);
}

use std::sync::{Mutex, Arc};
 
fn main() {
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];
 
    for _ in 0..3 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }
 
    for handle in handles {
        handle.join().unwrap();
    }
 
    println!("গণনা: {}", *counter.lock().unwrap());
}

macro_rules! say_hello {
    ($name:expr) => {
        println!("হ্যালো, {}!", $name);
    };
}
 
fn main() {
    say_hello!("রহিম");
}

pub mod utils {
    pub fn add(a: i32, b: i32) -> i32 {
        a + b
    }
}

use crate::utils::add;
 
fn main() {
    println!("যোগফল: {}", add(5, 3));
}

pub fn add(a: i32, b: i32) -> i32 {
    a + b
}
 
#[cfg(test)]
mod tests {
    use super::*;
 
    #[test]
    fn test_add() {
        assert_eq!(add(2, 3), 5);
    }
}

use std::collections::HashMap;
 
#[derive(Debug)]
struct Student {
    name: String,
    grade: u32,
}
 
impl Student {
    fn new(name: &str, grade: u32) -> Self {
        Student {
            name: String::from(name),
            grade,
        }
    }
}
 
fn main() {
    let mut students: HashMap<String, Student> = HashMap::new();
 
    students.insert(
        String::from("রহিম"),
        Student::new("রহিম", 85),
    );
    students.insert(
        String::from("করিম"),
        Student::new("করিম", 90),
    );
 
    for (key, student) in &students {
        println!("{}: গ্রেড = {}", key, student.grade);
    }
 
    let rahim = students.get("রহিম").unwrap();
    println!("রহিমের তথ্য: {:?}", rahim);
}