🦀 Rust Ownership এবং Borrowing

Rust প্রোগ্রামিং ল্যাঙ্গুয়েজকে বলা হয় memory-safe, fast, এবং modern। এর সবচেয়ে বড়ো বৈশিষ্ট্য হলো Ownership System। Rust-এ garbage collector নেই, আবার manual memory free করারও দরকার নেই।
👉 বরং Rust Ownership এবং Borrowing Rules দিয়ে compile-time-এ মেমোরি সেফটি নিশ্চিত করে।

আজকে আমরা শিখবো —

1. Ownership কি?

2. Borrowing কি?

3. এই সিস্টেম কেন দরকার?

4. Memory Level-এ কিভাবে কাজ করে?

5. Real-world problem কিভাবে solve হয়?

---

১. Ownership কী?

Rust-এ প্রতিটি value-এর একটি Owner থাকে। Owner বলতে বোঝো, যে variable সেই value-র মালিক।
আর Ownership rules হলো:

1. প্রতিটি value-এর একজন owner থাকবে

2. এক সময়ে একজন owner-ই থাকতে পারবে

3. Owner scope-এর বাইরে গেলে value মেমোরি থেকে ফ্রি হয়ে যাবে (Drop হয়ে যাবে)

fn main() {
    let s = String::from("Hello, Rust!");
    println!("{}", s);
}

• এখানে s হলো owner।

• যখন main() শেষ হবে, s scope-এর বাইরে চলে যাবে → memory free হবে।

👉 অর্থাৎ, Rust নিজে থেকে garbage collect করে না, কিন্তু s scope থেকে বের হলে RAII (Resource Acquisition Is Initialization) মডেলের মতো value free করে দেয়।

---

২. Move (Ownership Transfer)

যখন একটা value নতুন variable-এ assign করা হয়, তখন ownership transfer হয়।

fn main() {
    let s1 = String::from("Munna");
    let s2 = s1;  // Ownership move হয়ে গেল
    println!("{}", s2);  
    // println!("{}", s1);  ❌ Error: s1 আর owner নয়
}

• এখানে s1 থেকে s2 ownership চলে গেছে।

• এখন শুধু s2 owner।

• s1 use করলে compiler error দেবে।

👉 কেন? কারণ যদি s1 আর s2 দুজন একসাথে owner হয়ে যেতো, তাহলে double free error হতে পারতো। Rust এটাকে শুরুতেই আটকায়।

---

৩. Borrowing (ধার দেওয়া)

সবসময় ownership move করলে সমস্যা হতো। এজন্য Rust Borrowing system এনেছে।
👉 Borrowing মানে হলো owner পরিবর্তন না করে value কে ধার দেওয়া।

Immutable Borrowing

fn main() {
    let s = String::from("Rust");
    let len = calculate_length(&s);  // &s মানে borrow করলাম
    println!("Length of {} is {}", s, len);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

• &s মানে s কে borrow করা হলো।

• Ownership s-এর কাছেই থাকবে।

• calculate_length শুধু পড়তে পারবে, modify করতে পারবে না।

👉 Rule: একসাথে যত খুশি immutable borrow করা যাবে।

---

Mutable Borrowing

fn main() {
    let mut s = String::from("Hello");
    change(&mut s);   // mutable borrow
    println!("{}", s);
}

fn change(s: &mut String) {
    s.push_str(", World!");
}

• এখানে &mut s দিয়ে mutable borrow করা হয়েছে।

• এখন function value modify করতে পারবে।

👉 Rule: এক সময়ে শুধু একটাই mutable borrow করা যাবে।

---

৪. কেন এই Ownership & Borrowing দরকার?

Rust-এর এই নিয়মগুলো main তিনটা সমস্যার সমাধান করে:

1. Dangling Pointer – invalid memory reference

2. Double Free – একই memory দুইবার free হয়ে crash

3. Data Race – একাধিক thread একসাথে unsafe ভাবে memory access

---

৫. Memory Level-এ কি ঘটে?

ধরো, আমরা একটা String বানালাম:

let s = String::from("Rust");

Memory Layout

• s variable stack-এ pointer রাখে।

• String-এর আসল data heap-এ থাকে।

• Pointer + length + capacity stack-এ store হয়।

Stack:  [ ptr → heap, len = 4, capacity = 4 ]
Heap:   [ 'R', 'u', 's', 't' ]

👉 এখন যদি ownership move হয়:

let s1 = String::from("Hello");
let s2 = s1;

• s2-তে pointer copy হয়, কিন্তু ownership shift হয়ে যায়।

• s1 আর valid নয়।

👉 Borrowing হলে:

• Owner পরিবর্তন হয় না।

• শুধু reference (&) stack pointer হিসাবে যায়।

• Reference দিয়ে data access করা যায়, কিন্তু আসল owner control ধরে রাখে।

---

৬. Real World Problem Solve

ধরো তুমি একটি multi-threaded program বানাচ্ছো যেখানে একাধিক thread একই data ব্যবহার করবে।
C/C++-এ হলে manual lock দিতে হতো। ভুল করলে memory corruption হতো।

Rust-এ:

• Immutable borrow → একসাথে অনেক thread data read করতে পারে

• Mutable borrow → এক সময়ে শুধু একটি thread data write করতে পারে

ফলাফল: Data Race impossible at compile time!

---

৭. Beginner-Friendly Summary

1. Ownership – প্রতিটি value-এর একজন মালিক (owner) থাকে

2. Move – owner অন্য variable-এ চলে যায়

3. Borrowing – owner বদলায় না, শুধু reference যায়

   • Immutable Borrow → একসাথে অনেকবার

   • Mutable Borrow → এক সময়ে একবার

4. Scope শেষ হলে owner-এর value মেমোরি থেকে free হয়ে যায়

5. Rust compiler compile-time-এই এই সব check করে → runtime-এ memory bug নেই