সরাসরি পর্বে যান
পর্ব ৭৬ · ৮৬-এর মধ্যে · মডিউল ১৩

Memory safety আর ownership — Rust-এর borrow checker

Memory Safety and Ownership — Rust's Borrow Checker

Taught in Bangla, this lesson starts from real C and C++ memory bugs such as use-after-free and double free, compares garbage collection, RAII and ownership, and explains Rust's move semantics, shared and mutable borrows, aliasing XOR mutability, non-lexical lifetimes and lifetime errors using real rustc messages. It builds a move checker and a borrow checker as dataflow analyses over an extended Haat, compares their verdicts with rustc 1.82 on 17 programs, and discusses the unsafe boundary.

এই পর্বে যা শিখবেন

  • Memory safety-র ভুলের পরিবার, আর সত্যিকারের GCC আর sanitizer সেগুলো কতটা ধরে
  • GC, RAII আর ownership: কোনটি কখন memory ফেরত দেয়, আর কোন ভুল কে আটকায়
  • Rust-এর move, &, &mut, NLL আর lifetime, আসল rustc 1.82-এর error বার্তা পড়ে
  • AST-এর ওপর ownership আর borrow-এর dataflow analysis লিখে নিজের checker বানানো, আর আসল compiler-এর সঙ্গে differential test
  • unsafe-এর সীমানা, আর Swift, Cyclone, Vale ও Hylo কোন পথে হাঁটছে

১ · Memory safety — পাঁচ রকম ভুল, দুটি প্রশ্ন

বাজারঘরের গুদামে প্রতিটি তাকের একটি নম্বর, আর কর্মীদের হাতে চিরকুট: “তাক ৪২-এ ১০৪০ টাকার অর্ডার”. পাঁচ রকম গোলমাল হতে পারে। তাক খালি করে অন্য অর্ডার রাখা হয়েছে, কিন্তু পুরোনো চিরকুট হাতে কেউ সেখান থেকে মাল তুলছে। একই তাক দুবার “খালি” ঘোষণা হয়েছে, তাই হিসাবের খাতা গুলিয়ে গেছে। কেউ ৪২ নম্বরের জায়গায় ৪৩ নম্বরে গিয়ে অন্যের মাল সরিয়েছে। দুজন একসঙ্গে একই তাকে লিখছেন, কারও লেখা টিকছে না। আর একটি চিরকুটে কোনো তাক নম্বরই নেই।

এই পাঁচটিই program-এর memory safety-র প্রধান ভুল: use-after-free (ফেরত দেওয়া ঘরে পড়া বা লেখা), double free, buffer overflow (সীমার বাইরে লেখা), data race, আর null-এর ভেতরে ঢোকা। প্রথম দুটি সময়ের প্রশ্ন (ঘরটি কি এখনও জীবিত?), তৃতীয়টি জায়গার প্রশ্ন (ঘরটি কি আমার সীমায়?), চতুর্থটি একসঙ্গে-চলার প্রশ্ন। Pointer, alias, dangling pointer আর null-এর ভাষাগত দিক পর্ব ২৩-এ (Pointer আর reference), আর stack, heap ও lifetime পর্ব ১৬-এ দেখেছেন। নিরাপত্তার দিক (কেন এই bug-গুলো হামলার দরজা হয়, কোন mitigation আছে) আছে Cybersecurity কোর্সের পর্ব ৪৭-এ। এই পর্বের প্রশ্ন ভাষা-নকশাকারের: এই ভুলগুলো ভাষা নিজে কীভাবে অসম্ভব করতে পারে।

প্রথমে দেখা যাক C আজ কতটা সাহায্য করে। লেখকের lab-এ Wandbox-এর GCC 13.2.0 দিয়ে সত্যিকারের run:

#include <stdio.h>
#include <stdlib.h>

int main(void) {
    long *order = malloc(2 * sizeof *order);
    if (order == NULL) return 1;
    order[0] = 520;
    order[1] = 520;
    long *first = order;          /* a second name for the same box */
    free(order);                  /* the owner gives the box back */
    printf("%ld\n", first[0]);    /* use-after-free through the alias */
    return 0;
}
$ gcc -Wall -Wextra -O0 uaf.c && ./a.out
prog.c: In function 'main':
prog.c:11:5: warning: pointer 'first' used after 'free' [-Wuse-after-free]
   11 |     printf("%ld\n", first[0]);    /* use-after-free through the alias */
      |     ^~~~~~~~~~~~~~~~~~~~~~~~~
prog.c:10:5: note: call to 'free' here
233442

GCC ১২ থেকে আসা -Wuse-after-free ঠিক লাইনটি ধরেছে, কিন্তু এটি warning, error নয়: program compile হয়ে চলেছে আর ছেপেছে 233442, যা 520 নয়। মানটি এই এক run-এর; এটি undefined behavior, তাই অন্য দিনে অন্য সংখ্যা, crash বা “ঠিক” 520 আসতে পারে। একই দিনে free দুবার ডাকা (dfree.c, নিচে) চালালে glibc-এর নিজের পরীক্ষা থামিয়ে দেয়: আউটপুটে freed once, তারপর free(): double free detected in tcache 2 আর exit status 134 (SIGABRT). এটি allocator-এর সৌভাগ্যজনক পাহারা, ভাষার নিশ্চয়তা নয়।

/* dfree.c থেকে */
    long *copy = order;           /* two owners? nobody decided */
    free(order);
    printf("freed once\n");
    fflush(stdout);
    free(copy);                   /* double free */

/* bounds.c থেকে */
    long cart[2] = {520, 520};
    long total = 0;
    for (int i = 0; i <= 2; i++)  /* off by one: i == 2 is outside */
        total += cart[i];

$ gcc -fsanitize=undefined -g -O0 bounds.c && ./a.out
prog.c:7:22: runtime error: index 2 out of bounds for type 'long int [2]'

শেষ লাইনটি UBSan (-fsanitize=undefined, GCC 13.2.0, Wandbox) থেকে: সীমার বাইরের index চলার সময় ধরা পড়েছে, কারণ array-র আকার compiler জানত। Heap-এর use-after-free ধরার কাজ AddressSanitizer-এর, কিন্তু Wandbox-এ -fsanitize=address দিলে program শুরুতেই থামে (ReserveShadowMemoryRange failed: সার্ভারের memory-সীমায় ASan-এর shadow memory বসানো যায়নি), আর পর্ব ২৩-এ দেখেছেন এই Windows machine-এর Zig build-এ ASan-এর runtime নেই। তাই ASan-এর আউটপুট এখানে দেখানো হলো না। মূল কথা বদলায় না: sanitizer শুধু যে পথটি চলল সেটি পরীক্ষা করে, আর static warning শুধু সহজ ক্ষেত্র ধরে। কোনোটিই প্রমাণ করে না যে program-এ এমন ভুল নেই।

২ · তিনটি পথ — GC, RAII আর ownership

ভাষা নিজে memory-র দায় নিতে চাইলে তিনটি বড় পথ আছে। পার্থক্য তিনটি প্রশ্নে: memory কখন ফেরত যায়, কে সিদ্ধান্ত নেয়, আর ভুল ব্যবহার কখন ধরা পড়ে।

পথকখন ফেরতUse-after-freeদাম
Garbage collection (Java, Python, Go, JavaScript)Runtime যখন দেখে কেউ আর পৌঁছাতে পারে নাঅসম্ভব: পৌঁছানো গেলে ঘর জীবিতচলার সময় খরচ, ফেরতের মুহূর্ত অনির্দিষ্ট; ফাইল বা lock-এর মতো রিসোর্সে আলাদা ব্যবস্থা লাগে
RAII + smart pointer (C++)মালিক object-এর scope শেষে, destructor-এসম্ভব: raw pointer, move করা unique_ptr, পুরোনো referenceপ্রায় শূন্য runtime খরচ; নিয়ম মানা প্রোগ্রামারের ইচ্ছার ওপর
Ownership + borrow (Rust)মালিকের scope শেষে (RAII-র মতো)নিরাপদ অংশে compile-এর সময় অসম্ভবপ্রায় শূন্য runtime খরচ; কিছু সঠিক program-ও বাতিল, শেখার কষ্ট

GC-র ভেতরের কাজ (reference counting, mark-sweep, copying, generational) পর্ব ৭৫-এর (Garbage collection) বিষয়; JVM-এর বাস্তব দিক Java কোর্সের পর্ব ৪৪-এ। RAII আর smart pointer C++ কোর্সের পর্ব ১৭-এ, আর move semantics পর্ব ৩৬-এ হাতে-কলমে আছে। এখানে শুধু দেখা যাক RAII কোথায় থামে। C++20, GCC 13.2.0, -Wall -Wextra, সত্যিকারের run:

#include <iostream>
#include <memory>
#include <utility>

int main() {
    auto order = std::make_unique<long>(1040);
    auto taken = std::move(order);              // order is null now
    std::cout << "taken: " << *taken << std::endl;
    std::cout << "order: " << *order << std::endl;   // use after move: compiles
}
$ g++ -std=c++20 -Wall -Wextra uderef.cpp && ./a.out
taken: 1040
(exit status 139: Segmentation fault)

একটিও warning নেই। std::move-এর পরে order একটি খালি unique_ptr, standard অনুযায়ী null; তার ভেতরে ঢোকা undefined behavior, আর এই run-এ সেটি segmentation fault (139 = 128 + signal 11). একই ধাঁচের Rust কোডে (let taken = order; তারপর order পড়া) compile-ই হয় না, অংশ ৩-এ দেখবেন। C++-এ move হলো একটি রীতি: পুরোনো object “বৈধ কিন্তু অনির্দিষ্ট” অবস্থায় থাকে, আর compiler পরে তার ব্যবহার নিষেধ করে না। Clang-tidy-র মতো আলাদা tool-এ use-after-move-এর check আছে, কিন্তু সেটি ভাষার নিয়ম নয়।

৩ · Ownership আর move — Rust-এর তিন নিয়ম

Rust (১.০ সংস্করণ মে ২০১৫) RAII-র “scope শেষে ফেরত” ধারণা রেখে একটি বড় জিনিস যোগ করেছে: নিয়মগুলো compiler যাচাই করে। মূল নিয়ম তিনটি, The Rust Programming Language বইয়ের ভাষায় প্রায় এভাবে:

নিয়ম ৭৬.১ — ownership

(ক) প্রতিটি মানের একজন মালিক (owner), যা একটি variable.

(খ) একই সময়ে মালিক একজনই। let taken = order; বা function-এ পাঠানো মানে মালিকানা move; পুরোনো নাম তারপর অচল।

(গ) মালিক scope-এর বাইরে গেলে মান drop হয়: destructor চলে, heap-এর memory ফেরত যায়।

নিয়ম (খ) পর্ব ৩৯-এর affine type: মান সর্বোচ্চ একবার “খরচ” হয়; সেখানকার ছোট checker আর type-তত্ত্ব আবার বলা হবে না। তবে সব type move হয় না। i64, bool-এর মতো ছোট মান Copy type: assignment-এ বিট ধরে কপি হয়, পুরোনো নাম চালু থাকে। Box<i64> (heap-এ রাখা একটি সংখ্যা, stack-এ শুধু তার ঠিকানা) বা String Copy নয়, কারণ দুই মালিক মানে দুবার drop, অর্থাৎ double free. Move-এর পরে পুরোনো নামটি অচল করাই double free আর use-after-free দুটিকেই একসঙ্গে বন্ধ করে। Wandbox-এর rust-1.82.0 (--edition=2021), সত্যিকারের run:

fn ship(order: Box<i64>) {
    println!("shipped {}", order);
}

fn main() {
    let order = Box::new(1040);
    ship(order);
    println!("{}", order);
}
error[E0382]: borrow of moved value: `order`
 --> prog.rs:8:20
  |
6 |     let order = Box::new(1040);
  |         ----- move occurs because `order` has type `Box<i64>`, which does not implement the `Copy` trait
7 |     ship(order);
  |          ----- value moved here
8 |     println!("{}", order);
  |                    ^^^^^ value borrowed here after move

বার্তার গঠন লক্ষ করুন: মূল error ভুলের জায়গায় (8:20), আর একটি “note” move-এর জায়গায় (7:10). এরপর rustc একটি পরামর্শও দেয়: ship(order.clone()), অর্থাৎ খরচ মেনে একটি নতুন মালিকানাধীন কপি। এবার এই ধারণা Haat-এ আনা যাক।

Haat-এর বর্ধিত রূপ (এই পর্বের জন্য, spec v1-এ নেই)। নতুন type Box: heap-এ রাখা একটি Int-এর মালিক; তৈরি box(e) দিয়ে। নতুন expression &x (শুধু পড়ার ধার, type &Box) আর &mut x (বদলানোর ধার, type &mut Box, x-কে var হতে হবে)। Built-in: get(x) ভেতরের Int পড়ে, put(x, e) লেখে, drop(x) মানটি নিয়ে ফেরত দেয়। Box-এর নাম মান হিসেবে ব্যবহার হলে (let-এর ডান দিক, function-এর argument, return, drop) move হয়; get আর put শুধু সাময়িক ব্যবহার। Int, Bool আর Str আগের মতো কপি হয়। Reference implementation এগুলো চেনে না: সত্যিকারের run-এ haat.py check বলে 2:12: error: unexpected character '&', আর fn ship(order: Box)-এ 1:16: error: unknown type 'Box' (spec decision 6: type-এর জায়গায় শুধু চারটি নাম)।

1fn ship(order: Box) {2    print(get(order));3}4let order = box(1040);5ship(order);6print(get(order));
Checker-এর অবস্থা
নামের type
moved
ঘটনা
  1. Function আলাদা করে। ship-এর দেহ নিজের ফাঁকা অবস্থা নিয়ে যাচাই হয়: parameter order-এর মালিক এখন ship, আর get(order) শুধু পড়ে। কোনো ভুল নেই।
  2. নতুন মালিক। box(1040) একটি Box বানায়, মালিক top-level-এর order. Moved-তালিকা ফাঁকা।
  3. Move. ship(order)-এ Box নামটি argument, তাই মালিকানা চলে যায়। Checker তালিকায় লেখে order, সঙ্গে জায়গাটি 5:6, যাতে পরে note দিতে পারে।
  4. Use-after-move. get(order) পড়তে চায়, কিন্তু order তালিকায় আছে। Checker program চালায় না; শুধু তালিকা দেখে error দেয় ব্যবহারের জায়গায় 6:11, আর note দেয় move-এর জায়গায়, reference-এর line:col: error: ধাঁচে।
  5. আসল compiler-এর সঙ্গে মিল। একই program-এর Rust রূপে rustc 1.82 দেয় E0382, মূল error ব্যবহারে আর note move-এ: একই গঠন। লাইন নম্বর আলাদা, কারণ Rust রূপে fn main-এর লাইন আছে।

৪ · Move checker বানানো — AST-এর ওপর dataflow

Move checker আসলে একটি dataflow analysis: program-এর প্রতিটি বিন্দুতে একটি তথ্য রাখে (“কোন Box নাম move হয়ে গেছে, কোথায়”), আর statement ধরে সেটি এগিয়ে নেয়। পর্ব ৫৪-এর definite assignment-এর সঙ্গে মিল লক্ষ করুন, কিন্তু একটি জায়গায় উল্টো। সেখানে প্রশ্ন ছিল “সব পথে মান বসেছে কি?”, তাই শাখা মিললে ছেদ (∩) নেওয়া হতো। এখানে প্রশ্ন “কোনো এক পথেও move হয়েছে কি?”, তাই মিলনে নেওয়া হয় সংযোগ (∪): একটি শাখায় move হলেও পরে ব্যবহার নিষেধ। Loop-এর জন্য দেহটি বারবার চালানো হয় যতক্ষণ না অবস্থা আর বদলায়, অর্থাৎ একটি fixpoint; সেটির পূর্ণ তত্ত্ব পর্ব ৬৪-এর (Dataflow analysis) বিষয়।

Checker-এর আগে একটি ছোট lexer আর parser লাগে, যা &, &mut আর Box চেনে। সেটি সহায়ক module own_front.py-তে: node-এর নাম reference-এর ast_nodes.py-র মতো (Let, Call, Block …), নতুন শুধু Ref আর Block.end (}-এর অবস্থান, lifetime-এর জন্য লাগবে)। Parser-এর কৌশল পর্ব ৪৭ আর ৪৮-এর মতো, তবে প্রথম ভুলে থামে। ১৭টি পরীক্ষার program একটি ফাইলে, own_suite.haat.

সহায়ক module own_front.py দেখুন (ব্লকগুলো এটি import করে)
# own_front.py — সহায়ক অংশ: Haat-এর বর্ধিত রূপের (Box, &, &mut) ছোট lexer আর parser.
# Node-এর নাম reference-এর ast_nodes.py-র মতো; নতুন শুধু Ref (&x, &mut x) আর Block.end ('}'-এর অবস্থান)।
# পার্থক্য: প্রথম ভুলে থামে, function type আর anonymous function নেই, type: Int Bool Str Box &Box &mut Box.
import re
from dataclasses import dataclass, field

class HaatError(Exception):
    def __init__(self, line, col, msg): super().__init__(f"{line}:{col}: error: {msg}")

def node(name, *fields):                      # প্রতিটি node-এর শেষ দুটি ঘর line, col (reference-এর মতো)
    return dataclass(type(name, (), {"__annotations__": {f: object for f in (*fields, "line", "col")}}))
Num, Str, Bool, Var = node("Num", "value"), node("Str", "value"), node("Bool", "value"), node("Var", "name")
Unary, Binary, Call = node("Unary", "op", "operand"), node("Binary", "op", "left", "right"), node("Call", "callee", "args")
Ref = node("Ref", "name", "mut")              # নতুন: &x (mut=False) বা &mut x (mut=True), অবস্থান '&'-এ
Let, Assign = node("Let", "name", "mutable", "type", "init"), node("Assign", "name", "value")
If, While, Return = node("If", "cond", "then", "else_"), node("While", "cond", "body"), node("Return", "value")
Print, ExprStmt, Param = node("Print", "value"), node("ExprStmt", "expr"), node("Param", "name", "type")
Block, FnDecl = node("Block", "stmts", "end"), node("FnDecl", "name", "params", "ret", "body")
@dataclass
class Program:
    stmts: list
    end: tuple

TOKEN = re.compile(r"\s+|//[^\n]*|(?P<t>\d+|[A-Za-z_]\w*|\"(?:[^\"\\\n]|\\.)*\"|->|==|!=|<=|>=|&&|\|\||[-+*/%<>!=(){},;:&])")
BP = {"||": 10, "&&": 20, "==": 30, "!=": 30, "<": 40, "<=": 40, ">": 40, ">=": 40,
      "+": 50, "-": 50, "*": 60, "/": 60, "%": 60}

def tokenize(src):
    toks, line, start, pos = [], 1, 0, 0
    while pos < len(src):
        m = TOKEN.match(src, pos)
        if not m: raise HaatError(line, pos - start + 1, f"unexpected character '{src[pos]}'")
        if m.group("t"): toks.append((m.group("t"), line, pos - start + 1))
        for k, ch in enumerate(m.group(0)):
            if ch == "\n": line, start = line + 1, pos + k + 1
        pos = m.end()
    return toks + [("<eof>", line, pos - start + 1)]

class Parser:
    def __init__(self, src): self.t, self.i = tokenize(src), 0
    def peek(self, k=0): return self.t[min(self.i + k, len(self.t) - 1)]
    def next(self): self.i += 1; return self.t[self.i - 1]
    def expect(self, s, what):
        if self.peek()[0] != s: raise HaatError(*self.peek()[1:], f"expected {what}")
        return self.next()
    def name(self):
        tok = self.next()
        if not re.match(r"[A-Za-z_]", tok[0]): raise HaatError(*tok[1:], "expected a name")
        return tok
    def type_(self):
        if self.peek()[0] == "&":
            self.next(); mut = self.peek()[0] == "mut" and self.next()
            return ("&mut " if mut else "&") + self.name()[0]
        return self.name()[0]
    def block(self):
        lb = self.expect("{", "'{'"); stmts = []
        while self.peek()[0] not in ("}", "<eof>"): stmts.append(self.stmt())
        rb = self.expect("}", "'}'")
        return Block(stmts, rb[1:], *lb[1:])
    def stmt(self):
        t, l, c = self.peek()
        if t in ("let", "var"):
            self.next(); n = self.name(); ty = self.next() and self.type_() if self.peek()[0] == ":" else None
            self.expect("=", "'='"); e = self.expr(); self.expect(";", "';'")
            return Let(n[0], t == "var", ty, e, *n[1:])
        if t == "fn":
            self.next(); n = self.name(); self.expect("(", "'('"); ps = []
            while self.peek()[0] != ")":
                p = self.name(); self.expect(":", "':'"); ps.append(Param(p[0], self.type_(), *p[1:]))
                if self.peek()[0] == ",": self.next()
            self.next(); ret = self.next() and self.type_() if self.peek()[0] == "->" else "Unit"
            return FnDecl(n[0], ps, ret, self.block(), *n[1:])
        if t == "if":
            self.next(); cond = self.expr(); then = self.block(); els = None
            if self.peek()[0] == "else":
                self.next(); els = self.stmt() if self.peek()[0] == "if" else self.block()
            return If(cond, then, els, l, c)
        if t == "while": self.next(); cond = self.expr(); return While(cond, self.block(), l, c)
        if t == "return":
            self.next(); e = None if self.peek()[0] == ";" else self.expr(); self.expect(";", "';'")
            return Return(e, l, c)
        if t == "print":
            self.next(); self.expect("(", "'('"); e = self.expr(); self.expect(")", "')'"); self.expect(";", "';'")
            return Print(e, l, c)
        if t == "{": return self.block()
        if self.peek(1)[0] == "=":
            self.next(); self.next(); e = self.expr(); self.expect(";", "';'"); return Assign(t, e, l, c)
        e = self.expr(); self.expect(";", "';'"); return ExprStmt(e, l, c)
    def expr(self, min_bp=0):
        t, l, c = self.next()
        if t == "(": left = self.expr(); self.expect(")", "')'")
        elif t in ("-", "!"): left = Unary(t, self.expr(70), l, c)
        elif t == "&":
            mut = self.peek()[0] == "mut" and bool(self.next())
            left = Ref(self.name()[0], mut, l, c)
        elif t.isdigit(): left = Num(int(t), l, c)
        elif t[0] == '"': left = Str(t[1:-1], l, c)
        elif t in ("true", "false"): left = Bool(t == "true", l, c)
        elif re.match(r"[A-Za-z_]", t): left = Var(t, l, c)
        else: raise HaatError(l, c, "expected an expression")
        while True:
            op, ol, oc = self.peek()
            if op == "(" and min_bp <= 80:
                self.next(); args = []
                while self.peek()[0] != ")":
                    args.append(self.expr())
                    if self.peek()[0] == ",": self.next()
                self.next(); left = Call(left, args, left.line, left.col); continue
            if op not in BP or BP[op] < min_bp: return left
            self.next(); left = Binary(op, left, self.expr(BP[op] + 1), ol, oc)

def parse(src):
    p = Parser(src); stmts = []
    while p.peek()[0] != "<eof>": stmts.append(p.stmt())
    return Program(stmts, p.peek()[1:])

def last_uses(top):                           # NLL-এর সরল রূপ: প্রতিটি নামের শেষ ব্যবহার (কার্যকর অবস্থান, আসল অবস্থান)
    found, decl = {}, {}                      # নাম ঘোষণার পরে শুরু হওয়া loop-এর ভেতরে ব্যবহার = loop-এর শেষ পর্যন্ত
    def walk(n, loops):
        if isinstance(n, Var): found.setdefault(n.name, []).append(((n.line, n.col), loops))
        if isinstance(n, (Let, Param)): decl[n.name] = (n.line, n.col)
        for v in vars(n).values():
            for c in (v if isinstance(v, list) else [v]):
                if hasattr(c, "line"): walk(c, loops + [((n.line, n.col), n.body.end)] if isinstance(n, While) and c is n.body else loops)
    walk(top, [])
    return {x: max((max([at] + [end for start, end in ls if start > decl.get(x, (0, 0))]), at) for at, ls in uses)
            for x, uses in found.items()}

def program(name, path="own_suite.haat"):     # পরীক্ষার program-গুলো এক ফাইলে, "### নাম" দিয়ে আলাদা
    parts = open(path, encoding="utf-8").read().split("### ")[1:]
    return {p.split("\n", 1)[0].strip(): p.split("\n", 1)[1] for p in parts}[name]

def report(chk, name):                        # checker চালিয়ে reference-এর format-এ সব error আর note
    prog = parse(program(name)); top = Block(prog.stmts, prog.end, 0, 0)
    if hasattr(chk, "prepare"): chk.prepare(top)
    chk.stmt(top, chk.state())
    out = []
    for (l, c, msg), notes in sorted(chk.errs.items()):
        out += [f"{l}:{c}: error: {msg}"] + [f"{p[0]}:{p[1]}: note: {n}" for p, n in notes]
    return out or ["ok"]
পরীক্ষার ১৭টি program, own_suite.haat দেখুন
### move_use
fn ship(order: Box) {
    print(get(order));
}
let order = box(1040);
ship(order);
print(get(order));
### if_move
let order = box(1040);
let express = true;
if express {
    drop(order);
}
print(get(order));
### loop_move
let order = box(1040);
var round = 0;
while round < 2 {
    drop(order);
    round = round + 1;
}
### reassign_ok
var order = box(1040);
drop(order);
order = box(996);
print(get(order));
### two_shared_ok
let order = box(1040);
let a = &order;
let b = &order;
print(get(a) + get(b));
### shared_mut
var order = box(1040);
let view = &order;
let edit = &mut order;
put(edit, 996);
print(get(view));
### nll_ok
var order = box(1040);
let view = &order;
print(get(view));
let edit = &mut order;
put(edit, 996);
print(get(order));
### two_mut
var total = box(996);
let a = &mut total;
let b = &mut total;
put(a, 1056);
put(b, 1116);
### not_mut
let total = box(996);
let r = &mut total;
put(r, 1056);
### move_borrowed
let order = box(1040);
let view = &order;
let taken = order;
print(get(view));
### put_borrowed
var order = box(1040);
let view = &order;
put(order, 996);
print(get(view));
### write_shared
var order = box(1040);
let view = &order;
put(view, 996);
### dangle
let first = box(520);
var r = &first;
{
    let price = box(1040);
    r = &price;
}
print(get(r));
### call_shared_ok
fn total(a: &Box, b: &Box) -> Int {
    return get(a) + get(b);
}
let order = box(1040);
print(total(&order, &order));
### call_conflict
fn add(a: &mut Box, b: &Box) {
    put(a, get(a) + get(b));
}
var order = box(1040);
add(&mut order, &order);
### loop_conflict
var order = box(1040);
let view = &order;
var i = 0;
while i < 2 {
    print(get(view));
    put(order, 996);
    i = i + 1;
}
### loop_ok
var order = box(1040);
var i = 0;
while i < 2 {
    let view = &order;
    print(get(view));
    put(order, get(order) + 60);
    i = i + 1;
}
# Ownership checker, ধাপ ১: move আর use-after-move — Haat-এর বর্ধিত রূপ (Box)
from own_front import *
class Owner:
    def __init__(self): self.errs, self.kind = {}, {}
    def err(self, at, msg, *notes): self.errs.setdefault(at + (msg,), list(notes))
    def use(self, x, at, how, st):            # how: "move" (মালিকানা যায়) বা "read" (শুধু দেখা)
        if self.kind.get(x) != "Box": return  # Int, Bool, Str আগের মতো কপি হয়
        if x in st["moved"]:
            m = st["moved"][x]; self.err(at, f"use of moved value '{x}'", (m, "value moved here" + (", in previous iteration of loop" if m == at else "")))
        elif how == "move": st["moved"][x] = at
    def expr(self, e, st, how="read"):
        if isinstance(e, Var): self.use(e.name, (e.line, e.col), how, st)
        elif isinstance(e, (Unary, Binary)): [self.expr(c, st) for c in ([e.operand] if isinstance(e, Unary) else [e.left, e.right])]
        elif isinstance(e, Call):             # get, put, box শুধু দেখে; drop আর সাধারণ function নিয়ে নেয়
            for a in e.args: self.expr(a, st, "read" if e.callee.name in ("get", "put", "box") else "move")
    def state(self, st=None): return {"moved": dict(st["moved"]) if st else {}}   # নতুন, বা কপি করা অবস্থা
    def merge(self, a, b): return {"moved": {**b["moved"], **a["moved"]}}   # কোনো এক পথে move = হয়তো move
    def stmt(self, s, st):
        if isinstance(s, Let):
            self.expr(s.init, st, "move")
            self.kind[s.name] = s.type or ("Box" if isinstance(s.init, Call) and s.init.callee.name == "box" else self.kind.get(getattr(s.init, "name", "")))
        elif isinstance(s, Assign): self.expr(s.value, st, "move"); st["moved"].pop(s.name, None)  # নতুন মান: আবার মালিক
        elif isinstance(s, (Print, ExprStmt)): self.expr(s.value if isinstance(s, Print) else s.expr, st)
        elif isinstance(s, Return) and s.value: self.expr(s.value, st, "move")
        elif isinstance(s, Block): [st := self.stmt(t, st) for t in s.stmts]
        elif isinstance(s, If):
            self.expr(s.cond, st); a = self.stmt(s.then, self.state(st))
            st = self.merge(a, self.stmt(s.else_, self.state(st)) if s.else_ else st)
        elif isinstance(s, While):            # fixpoint: অবস্থা আর না বদলানো পর্যন্ত দেহ আবার
            self.expr(s.cond, st)
            while (new := self.merge(st, self.stmt(s.body, self.state(st)))) != st: st = new
        elif isinstance(s, FnDecl):
            self.kind.update({p.name: p.type for p in s.params}); self.stmt(s.body, self.state())
        return st
for name in ("move_use", "if_move", "loop_move", "reassign_ok"): print(f"{name:12}", "\n             ".join(report(Owner(), name)))

আসল আউটপুট (ব্রাউজারের Python):

move_use     6:11: error: use of moved value 'order'
             5:6: note: value moved here
if_move      6:11: error: use of moved value 'order'
             4:10: note: value moved here
loop_move    4:10: error: use of moved value 'order'
             4:10: note: value moved here, in previous iteration of loop
reassign_ok  ok

চারটি program, চারটি আলাদা পথ। move_use stepper-এর program. if_move-এ drop(order) শুধু if-এর ভেতরে, তবু লাইন ৬-এ error, কারণ মিলনে ∪: rustc-ও একই রায় দেয় (E0382), যদিও শর্তটি সবসময় সত্য, কারণ compiler শর্তের মান দেখে না। loop_move-এ ভুলটি একটিমাত্র লাইনে, কিন্তু ধরা পড়ে দ্বিতীয় round-এ: fixpoint-এর দ্বিতীয় পাকে দেহের শুরুতেই order তালিকায়, আর move-এর জায়গা আর ব্যবহারের জায়গা একই, তাই note বলে “previous iteration”; rustc 1.82-এর বার্তাতেও হুবহু value moved here, in previous iteration of loop. reassign_ok-এ move-এর পরে order = box(996); নামটিকে আবার মালিক বানায়, তাই কোনো ভুল নেই; Rust-ও তা মানে।

কোডের মূল চাবি তিনটি method: use() একটি নামের ব্যবহারকে move বা পড়া হিসেবে ধরে, merge() দুই পথের অবস্থা মেলায়, আর stmt()-এর While অংশটি merge-এর ফল না বদলানো পর্যন্ত দেহ চালায়। এটি থামবেই, কারণ moved-তালিকা শুধু বাড়ে, আর নাম সীমিত।

৫ · Borrowing — & আর &mut, aliasing XOR mutability

শুধু move দিয়ে লেখা কষ্টকর: একটি অর্ডার দেখাতে গেলেই function সেটি নিয়ে নিত। তাই Rust-এ আছে borrowing: মালিকানা না নিয়ে সাময়িক reference. লাইব্রেরির বইয়ের মতো: অনেকে একসঙ্গে পাঠকক্ষে বসে একই বই পড়তে পারেন, কিন্তু কেউ বইয়ে দাগ দিতে চাইলে তখন বইটি শুধু তাঁর হাতে থাকবে। নিয়ম দুটি:

নিয়ম ৭৬.২ — borrow

(ক) যেকোনো মুহূর্তে একটি মানের হয় যত খুশি &T (শুধু পড়া), অথবা ঠিক একটি &mut T (পড়া ও বদলানো); দুটি একসঙ্গে কখনো নয়। একে বলা হয় aliasing XOR mutability: একাধিক নাম (aliasing) আর বদলানোর অধিকার একসঙ্গে থাকে না।

(খ) কোনো ধার তার মালিকের চেয়ে বেশি দিন বাঁচে না (lifetime-এর নিয়ম, অংশ ৭)। ধার চলাকালে মালিক মানটি move করতে বা বদলাতে পারে না।

ছবি ৭৬.১ — aliasing XOR mutability

একটি Box-এর দিকে তিন রকম ধার: অনেক পাঠক ঠিক, একজন লেখক ঠিক, পাঠক আর লেখক একসঙ্গে বাতিল

Aliasing XOR mutability: many shared borrows, or one mutable borrow, never both অনেক পাঠক ✓ a : & b : & order : Box1040 একজন লেখক ✓ edit : &mut order : Box996 পাঠক + লেখক ✗ a : & edit : &mut order : BoxE0502

কেন এই নিয়ম? কারণ “একজন বদলাচ্ছে, অন্যজন পুরোনো ছবি ধরে আছে” পরিস্থিতিই use-after-free-এর সবচেয়ে সাধারণ উৎস। সবচেয়ে পরিচিত উদাহরণ: একটি তালিকার উপাদানের reference ধরে রেখে তালিকায় নতুন উপাদান যোগ করা। যোগ করতে গিয়ে তালিকা বড় জায়গায় সরে গেলে পুরোনো reference ফেরত দেওয়া memory দেখায়, C++-এ যাকে iterator invalidation বলে। Rust এটি compile-এর সময় থামায় (rust-1.82.0, সত্যিকারের run):

fn main() {
    let mut cart = vec![520, 520];
    let first = &cart[0];
    cart.push(60);
    println!("{}", first);
}
error[E0502]: cannot borrow `cart` as mutable because it is also borrowed as immutable
 --> prog.rs:4:5
  |
3 |     let first = &cart[0];
  |                  ---- immutable borrow occurs here
4 |     cart.push(60);
  |     ^^^^^^^^^^^^^ mutable borrow occurs here
5 |     println!("{}", first);
  |                    ----- immutable borrow later used here

cart.push(60) নিজেই একটি &mut cart ধার নেয়, আর first তখনও জীবিত, কারণ লাইন ৫-এ ব্যবহার হবে। একই lab-এর অন্য সত্যিকারের run-গুলোর মূল লাইন: দুটি &mut total একসঙ্গে দিলে error[E0499]: cannot borrow `total` as mutable more than once at a time; let total-এর (mut ছাড়া) &mut চাইলে error[E0596]: cannot borrow `total` as mutable, as it is not declared as mutable; আর ধার চলাকালে মালিককে move করলে error[E0505]: cannot move out of `order` because it is borrowed.

1var order = box(1040);2let a = &order;3let b = &order;4print(get(a) + get(b));5let edit = &mut order;6put(edit, 996);7print(get(a));
Checker-এর অবস্থা
জীবিত ধার
শেষ ব্যবহার
প্রশ্ন
  1. মালিক। var order: Box-এর মালিক, আর var বলে পরে &mut চাওয়া যাবে। কোনো ধার নেই।
  2. প্রথম ধার। &order একটি loan L1 বানায়, ধারক (holder) a. L1 কতক্ষণ বাঁচবে? যতক্ষণ a পরে কোথাও ব্যবহার হয়: a-এর শেষ ব্যবহার 7:11.
  3. দ্বিতীয় পাঠক। &order আবার: নিয়ম ৭৬.২ (ক) শুধু জিজ্ঞেস করে, কোনো &mut জীবিত কি না। নেই, তাই L2 (holder b) গৃহীত। b-এর শেষ ব্যবহার 4:20.
  4. দুই ধার দিয়ে পড়া। get(a) + get(b) শুধু পড়ে। এই লাইনের পরে b আর কোথাও নেই, তাই L2 এখানেই শেষ, যদিও b-এর scope program-এর শেষ পর্যন্ত।
  5. লেখক এলেন, পাঠক এখনও আছেন। &mut order চায় একমাত্র অধিকার। L1 জীবিত, কারণ a লাইন ৭-এ আবার পড়া হবে (7:11 পরে আসে 5:12-এর)। তাই error, আর দুটি note: ধার কোথায় হয়েছিল, আর কোথায় পরে ব্যবহার হবে। Rust রূপে rustc 1.82 দেয় একই E0502, একই তিনটি জায়গা দেখিয়ে।
  6. লাইন ৭ মুছে দিলে। a-এর শেষ ব্যবহার তখন 4:11, তাই লাইন ৫-এ L1 আর জীবিত নয়, আর program গৃহীত। ধার শেষ হয় শেষ ব্যবহারে, scope-এর শেষে নয়: এটিই NLL, পরের অংশের বিষয়।

৬ · Borrow checker — loan, liveness আর NLL

Stepper-এর শেষ ধাপটি বহু বছর Rust-এ সত্য ছিল না। প্রথম দিকের borrow checker ধার বাঁচিয়ে রাখত reference-এর lexical scope-এর শেষ পর্যন্ত, তাই অনেক স্পষ্টত নিরাপদ program বাতিল হতো। Non-lexical lifetimes (NLL) Rust 2018 edition-এর সঙ্গে চালু হয়; পুরোনো কোডের জন্য কিছুদিন একটি “migration mode” ছিল, যেখানে দুটি checker-ই চলত, আর Rust ব্লগের ঘোষণা অনুযায়ী Rust 1.63 (২০২২) থেকে সব কোড শুধু NLL দিয়ে যাচাই হয়। NLL প্রশ্নটি বদলে দেয়: “ধার কি scope-এর ভেতরে?”-এর বদলে “ধারক reference-টি কি এই বিন্দুর পরে আবার ব্যবহার হবে?” এটি একটি liveness প্রশ্ন, আর rustc এটি হিসাব করে নিজের মধ্যবর্তী রূপ MIR-এর control flow graph-এর ওপর। অংশ ৫-এর cart উদাহরণ থেকে শুধু println! লাইনটি push-এর আগে সরালে সত্যিকারের run-এ program চলে আর ছাপে first = 520 আর cart = [520, 520, 60].

আমাদের checker NLL-এর একটি সরল রূপ নেয়। প্রতিটি ধার একটি loan: (কোন মান, mut কি না, holder, জায়গা)। সহায়ক last_uses() প্রতিটি নামের শেষ ব্যবহারের জায়গা আগেই হিসাব করে, আর একটি loan একটি বিন্দু p-তে জীবিত যদি তার holder p-এর পরে ব্যবহার হয়। Loop-এর একটি সূক্ষ্মতা: ঘোষণা loop-এর আগে আর ব্যবহার loop-এর ভেতরে হলে, পরের round-এ আবার ব্যবহার হবে, তাই শেষ ব্যবহার ধরা হয় loop-এর শেষ। Function call-এর argument-এ &x লিখলে loan-এর holder নেই; সেটি statement শেষেই মারা যায়। Block শেষ হলে সেখানে ঘোষিত মান drop হয়; তখনও কোনো বাইরের holder-এর loan জীবিত থাকলে lifetime-এর error (অংশ ৭)।

# Ownership checker, ধাপ ২: & আর &mut, NLL-ধাঁচের liveness আর lifetime — loan = (মান, mut?, holder, অবস্থান)
class Borrow(Owner):
    def prepare(self, top): self.home, self.var, self.blocks, self.last = {}, {}, [], last_uses(top)
    def live(self, ln, at): return ln[2] is None or self.last.get(ln[2], ((0, 0),))[0] > at   # holder পরে আবার ব্যবহার হয়?
    def later(self, r): eff, at = self.last[r]; return at, "borrow later used here" + (", in later iteration of loop" if eff != at else "")
    def blame(self, at, msg, ln): self.err(at, msg, (ln[3], "borrow occurs here"), *([self.later(ln[2])] if ln[2] else []))
    def use(self, x, at, how, st):            # how: move, read, &, &mut, write (put বা x = …)
        for ln in [l for l in st["loans"] if l[0] == x and self.live(l, at)]:
            if how == "move": return self.blame(at, f"cannot move out of '{x}' because it is borrowed", ln)
            if how in ("&", "read") and ln[1]: return self.blame(at, f"cannot {'borrow' if how == '&' else 'use'} '{x}' " + ("as immutable because it is also borrowed as mutable" if how == "&" else "because it was mutably borrowed"), ln)
            if how == "&mut": return self.blame(at, f"cannot borrow '{x}' as mutable " + ("more than once at a time" if ln[1] else "because it is also borrowed as immutable"), ln)
            if how == "write": return self.blame(at, f"cannot assign to '{x}' because it is borrowed", ln)
        if how == "&mut" and not self.var.get(x): self.err(at, f"cannot borrow '{x}' as mutable, as it is not declared as mutable")
        if how == "write" and self.kind.get(x) == "&Box": self.err(at, f"cannot assign through shared reference '{x}'")
        super().use(x, at, "move" if how == "move" else "read", st)
    def expr(self, e, st, how="read"):
        if isinstance(e, Ref): self.use(e.name, (e.line, e.col), "&mut" if e.mut else "&", st); st["loans"].append((e.name, e.mut, None, (e.line, e.col)))
        elif isinstance(e, Call) and e.callee.name == "put": self.use(e.args[0].name, (e.args[0].line, e.args[0].col), "write", st); self.expr(e.args[1], st)
        else: super().expr(e, st, how)
    def state(self, st=None): return {**super().state(st), "loans": list(st["loans"]) if st else []}
    def merge(self, a, b): return {**super().merge(a, b), "loans": a["loans"] + [l for l in b["loans"] if l not in a["loans"]]}
    def stmt(self, s, st):
        if isinstance(s, Assign) and self.kind.get(s.name) == "Box": st["moved"].pop(s.name, None); self.use(s.name, (s.line, s.col), "write", st)
        if isinstance(s, (Let, Assign)): st["loans"] = [l for l in st["loans"] if l[2] != s.name]   # পুরোনো ধার শেষ
        if isinstance(s, Let): self.home[s.name], self.var[s.name] = (self.blocks or [None])[-1], s.mutable
        if isinstance(s, Block): self.blocks.append(s)
        st = super().stmt(s, st)
        holder = s.name if isinstance(getattr(s, "init", getattr(s, "value", None)), Ref) else None
        st["loans"] = [(l[0], l[1], holder, l[3]) if l[2] is None else l for l in st["loans"] if l[2] or holder]  # holder নেই: statement শেষে ধার শেষ
        if isinstance(s, Let) and isinstance(s.init, Ref): self.kind[s.name] = "&mut Box" if s.init.mut else "&Box"
        if isinstance(s, Block):              # block শেষ: এখানে জন্মানো মান drop হয়; তার ধার কি তখনও বেঁচে?
            for l in [l for l in st["loans"] if self.home.get(l[0]) is s and self.home.get(l[2]) is not s and self.live(l, s.end)]: self.err(l[3], f"'{l[0]}' does not live long enough", (s.end, f"'{l[0]}' dropped here while still borrowed"), self.later(l[2]))
            st["loans"] = [l for l in st["loans"] if self.home.get(l[0]) is not s]; self.blocks.pop()
        return st
for name in ("two_shared_ok", "shared_mut", "nll_ok", "dangle"): print(f"{name:14}", "\n               ".join(report(Borrow(), name)))

আসল আউটপুট (ব্রাউজারের Python; ব্লকটি আগের ব্লকের Owner-এর ওপর গড়া, তাই আগেরটি নিজে থেকে আগে চলে):

two_shared_ok  ok
shared_mut     3:12: error: cannot borrow 'order' as mutable because it is also borrowed as immutable
               2:12: note: borrow occurs here
               5:11: note: borrow later used here
nll_ok         ok
dangle         5:9: error: 'price' does not live long enough
               6:1: note: 'price' dropped here while still borrowed
               7:11: note: borrow later used here

two_shared_ok-এ দুই পাঠক, কোনো ভুল নেই। shared_mut-এ পাঠক জীবিত থাকতে লেখক, আর তিনটি জায়গা ঠিক rustc-এর মতো: ভুল &mut-এ, note ধারে আর পরের ব্যবহারে। nll_ok একই কাজ, শুধু পড়াটি আগে, তাই গৃহীত, rustc-ও তাই বলে। dangle-এর তিন লাইন পরের অংশের stepper. use()-এর for-loop-ই নিয়ম ৭৬.২-এর কোড: প্রতিটি জীবিত loan-এর বিরুদ্ধে move, পড়া, &, &mut আর লেখা যাচাই।

একই liveness হিসাব একটি সময়-রেখায় দেখলে নিয়মটি চোখে পড়ে। নিচের JavaScript block প্রতিটি loan-কে তার জন্মের লাইন থেকে holder-এর শেষ ব্যবহার পর্যন্ত আঁকে, আর যে লাইনে একটি &mut অন্য কোনো loan-এর সঙ্গে একসঙ্গে জীবিত, সেখানে ✗ দেয়:

// Ownership timeline: প্রতিটি ধার কোন লাইন থেকে কোন লাইন পর্যন্ত বাঁচে (শেষ ব্যবহার পর্যন্ত, NLL-এর মতো)
function timeline(title, lines) {
  const loans = [], last = {};
  lines.forEach(([code, ev], i) => ev.forEach(([k, a, b]) => {
    if (k === "&" || k === "&mut") loans.push({ holder: a, target: b, mut: k === "&mut", from: i });
    if (k === "use") last[a] = i;                 // holder-এর শেষ ব্যবহার = ধারের শেষ
  }));
  loans.forEach(l => l.to = Math.max(l.from, last[l.holder] ?? l.from));
  console.log(`== ${title}`);
  const names = loans.map(l => `${l.holder}(${l.mut ? "&mut" : "&"})`);
  console.log("লাইন " + names.map(n => n.padEnd(11)).join("") + "কোড".padEnd(24) + "ফল");
  lines.forEach(([code], i) => {
    const alive = loans.filter(l => l.from <= i && i <= l.to);
    const bad = alive.some(l => l.mut) && alive.length > 1;   // aliasing XOR mutability
    const cells = loans.map(l => (l.from <= i && i <= l.to ? (l.mut ? "███" : "░░░") : " · ").padEnd(11));
    console.log(String(i + 1).padEnd(5) + cells.join("") + code.padEnd(24) + (bad ? "✗ & আর &mut একসঙ্গে" : "✓"));
  });
}
timeline("shared_mut (বাতিল)", [
  ["var order = box(1040);", [["own", "order"]]],
  ["let view = &order;", [["&", "view", "order"]]],
  ["let edit = &mut order;", [["&mut", "edit", "order"]]],
  ["put(edit, 996);", [["use", "edit"]]],
  ["print(get(view));", [["use", "view"]]]]);
timeline("nll_ok (গৃহীত)", [
  ["var order = box(1040);", [["own", "order"]]],
  ["let view = &order;", [["&", "view", "order"]]],
  ["print(get(view));", [["use", "view"]]],
  ["let edit = &mut order;", [["&mut", "edit", "order"]]],
  ["put(edit, 996);", [["use", "edit"]]],
  ["print(get(order));", [["use", "order"]]]]);

আসল আউটপুট (ব্রাউজারের JavaScript):

== shared_mut (বাতিল)
লাইন view(&)    edit(&mut) কোড                     ফল
1     ·          ·         var order = box(1040);  ✓
2    ░░░         ·         let view = &order;      ✓
3    ░░░        ███        let edit = &mut order;  ✗ & আর &mut একসঙ্গে
4    ░░░        ███        put(edit, 996);         ✗ & আর &mut একসঙ্গে
5    ░░░         ·         print(get(view));       ✓
== nll_ok (গৃহীত)
লাইন view(&)    edit(&mut) কোড                     ফল
1     ·          ·         var order = box(1040);  ✓
2    ░░░         ·         let view = &order;      ✓
3    ░░░         ·         print(get(view));       ✓
4     ·         ███        let edit = &mut order;  ✓
5     ·         ███        put(edit, 996);         ✓
6     ·          ·         print(get(order));      ✓

দুটি program-এ একই চারটি কাজ, শুধু ক্রম আলাদা। প্রথমটিতে ░ (পাঠক) আর █ (লেখক) লাইন ৩–৪-এ পাশাপাশি, তাই ✗; দ্বিতীয়টিতে পাঠকের দাগ লাইন ৩-এ থামে আর লেখকের দাগ লাইন ৪-এ শুরু হয়, কখনো মেলে না। Lexical নিয়মে view-এর দাগ program-এর শেষ পর্যন্ত টানা থাকত, আর দ্বিতীয়টিও বাতিল হতো। এই visualiser শুধু ধারে-ধারে সংঘাত দেখায়; মালিকের নিজের ব্যবহার Python checker দেখে।

৭ · Lifetime — মালিকের চেয়ে বেশি দিন বাঁচা ধার

নিয়ম ৭৬.২ (খ) dangling reference-কে ধরে, পর্ব ১৬-এর “ঘর শেষ, ঠিকানা রয়ে গেল” সমস্যা। ভেতরের block-এর একটি মানের ধার বাইরের নামে রেখে block শেষ হলে মানটি drop হয়, অথচ ধারটি তখনও ব্যবহারের অপেক্ষায়।

1let first = box(520);2var r = &first;3{4    let price = box(1040);5    r = &price;6}7print(get(r));
Checker-এর অবস্থা
কোন block-এর মান
জীবিত ধার
  1. Top-level-এর মালিক। first-এর মালিক top-level block; সে program-এর শেষ পর্যন্ত বাঁচবে।
  2. প্রথম ধার। r ধরে আছে &first (L1). r-কে var রাখা হয়েছে, যাতে পরে নতুন ধার বসানো যায়।
  3. নতুন block B, নতুন মালিক। { একটি scope খোলে; price-এর ঘর B, অর্থাৎ B-এর }-এ সে drop হবে। Checker প্রতিটি নামের “ঘর-block” মনে রাখে, পর্ব ৫১-এর scope-এর মতো।
  4. ধারক বদলাল। r = &price;: r নতুন মান পেল, তাই পুরোনো L1 শেষ। নতুন L2 = &price, holder r, যার ঘর top-level.
  5. Block শেষ। B শেষে price drop হয়। Checker দেখে: L2-এর মান B-এর, holder বাইরের, আর r আবার ব্যবহার হবে 7:11-এ (6:1-এর পরে)। তাই error ধারের জায়গায়, আর দুটি note: কোথায় drop, কোথায় পরে ব্যবহার। rustc 1.82-এর E0597 বার্তায় হুবহু এই তিনটি অংশ।
  6. যা আটকানো হলো। C-তে একই কোড compile হয়ে লাইন ৭-এ ফেরত দেওয়া ঘর পড়ত: পর্ব ১৬-এর dangling reference. এখানে program চলার আগেই বাতিল।
error[E0597]: `price` does not live long enough
 --> prog.rs:6:13
  |
5 |         let price = Box::new(1040);
  |             ----- binding `price` declared here
6 |         r = &price;
  |             ^^^^^^ borrowed value does not live long enough
7 |     }
  |     - `price` dropped here while still borrowed
8 |     println!("{}", r);
  |                    - borrow later used here

Function-এর সীমানায় lifetime আরেকটি প্রশ্ন তোলে। Function দুটি reference নিয়ে একটি reference ফেরত দিলে, ফলটি কোন argument-এর ধার? Caller-কে জানতে হবে, কারণ সেই argument-কে ফলের চেয়ে বেশি দিন বাঁচতে হবে। Rust signature দেখে না বুঝলে উত্তর চায় (সত্যিকারের run):

fn bigger(a: &i64, b: &i64) -> &i64 {
    if a >= b { a } else { b }
}

error[E0106]: missing lifetime specifier
 --> prog.rs:1:32
  |
1 | fn bigger(a: &i64, b: &i64) -> &i64 {
  |              ----     ----     ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but the signature does not say whether it is borrowed from `a` or `b`

rustc-এর নিজের পরামর্শ fn bigger<'a>(a: &'a i64, b: &'a i64) -> &'a i64 লিখলে program চলে আর ছাপে 1040. এখানে 'a একটি lifetime annotation: সে কোনো মানের জীবন বাড়ায় বা কমায় না, শুধু চুক্তিটি লেখে, “ফল ততক্ষণই বৈধ, যতক্ষণ a আর b দুটিই বৈধ”। Caller-এর দিকে checker তখন এই চুক্তি ধরে যাচাই করে, function-এর দেহ না খুলেই। এভাবে প্রতিটি function আলাদা করে যাচাই হয়, পর্ব ৫২-এর type checker-এর মতো। অনেক সহজ ক্ষেত্রে (একটি মাত্র reference argument, বা &self) “lifetime elision” নিয়মে annotation লিখতে হয় না। আমাদের Haat-এর বর্ধিত রূপে function reference ফেরতই দিতে পারে না, সেটি ইচ্ছাকৃত সরলতা।

৮ · মিলিয়ে দেখা — আসল rustc-এর সঙ্গে differential test

নিজের checker কতটা ঠিক, জানার সবচেয়ে সৎ উপায়: একই program আসল compiler-কে দেওয়া। own_suite.haat-এর ১৭টি program-এর প্রতিটির একটি Rust রূপ লেখকের lab-এ Wandbox-এর rust-1.82.0-তে চালানো হয়েছে, আর প্রতিটির প্রথম error code (বা ok) রাখা আছে rustc_1_82.txt-এ। নিচের block আমাদের checker-এর প্রথম বার্তাকে rustc-এর code-এ অনুবাদ করে দুই রায় পাশাপাশি রাখে:

# Differential test: আমাদের checker বনাম সত্যিকারের rustc 1.82 (লেখকের lab-এ Wandbox-এ চালানো রায়)
CODE = [("use of moved", "E0382"), ("move out of", "E0505"), ("more than once", "E0499"),
        ("not declared as mutable", "E0596"), ("also borrowed", "E0502"), ("mutably borrowed", "E0503"),
        ("does not live long", "E0597"), ("shared reference", "E0594"), ("because it is borrowed", "E0506")]
def verdict(lines):                           # প্রথম error বার্তা থেকে rustc-এর error code
    first = next((l for l in lines if ": error: " in l), None)
    return "ok" if first is None else next(c for key, c in CODE if key in first)
rustc = dict(line.split() for line in open("rustc_1_82.txt", encoding="utf-8"))
same = 0
print(f"{'program':15}{'আমাদের checker':16}{'rustc 1.82':12}মিল?")
for name, want in rustc.items():
    got = verdict(report(Borrow(), name))
    same += got == want
    print(f"{name:15}{got:16}{want:12}{'✓' if got == want else '✗'}")
print(f"\nমোট {len(rustc)}টি program: {same}টিতে রায় মিলেছে, {len(rustc) - same}টিতে মেলেনি")

আসল আউটপুট (ব্রাউজারের Python):

program        আমাদের checker  rustc 1.82  মিল?
move_use       E0382           E0382       ✓
if_move        E0382           E0382       ✓
loop_move      E0382           E0382       ✓
reassign_ok    ok              ok          ✓
two_shared_ok  ok              ok          ✓
shared_mut     E0502           E0502       ✓
nll_ok         ok              ok          ✓
two_mut        E0499           E0499       ✓
not_mut        E0596           E0596       ✓
move_borrowed  E0505           E0505       ✓
put_borrowed   E0506           E0506       ✓
write_shared   E0594           E0594       ✓
dangle         E0597           E0597       ✓
call_shared_ok ok              ok          ✓
call_conflict  E0502           E0502       ✓
loop_conflict  E0506           E0506       ✓
loop_ok        ok              ok          ✓

মোট 17টি program: 17টিতে রায় মিলেছে, 0টিতে মেলেনি

১৭টিতেই রায় এক: ৬টি গৃহীত, ১১টি বাতিল, আর বাতিলগুলোর error code-ও এক। তালিকায় আছে loop-এর দ্বিতীয় round-এর move (loop_move), loop-এর পরের round-এ ধারের পুনর্ব্যবহার (loop_conflict, E0506), একই call-এ &mut আর & (call_conflict), আর NLL-এর গৃহীত দুটি ক্ষেত্র। কিন্তু ১৭/১৭ মানে নির্ভুলতা নয়: program-গুলো লেখকের নিজের বানানো, আর checker যা জানে না তা পরীক্ষাতেও নেই। অনুশীলন ১-এ এমন একটি ছোট program পাবেন, যেখানে এই checker চুপ থাকে অথচ rustc E0506 দেয়। এর তাত্ত্বিক কারণ ToC কোর্সের পর্ব ৫৩-এর Rice-এর theorem: “এই program কখনো মুক্ত memory ছোঁবে কি না” প্রশ্নের নির্ভুল উত্তর সাধারণভাবে অসম্ভব, তাই প্রতিটি checker হয় কিছু ভুল ছেড়ে দেয়, নয় কিছু সঠিক program বাতিল করে। Rust দ্বিতীয় পথ বেছেছে; আমাদের খসড়া এখনও প্রথম ধরনের একটি ফাঁক রাখে।

৯ · unsafe-এর সীমানা আর অন্য ভাষার পথ

কিছু সঠিক কাজ borrow checker প্রমাণ করতে পারে না: দুই দিকে link-ওয়ালা তালিকা, hardware register, C library ডাকা, বা নিজের allocator. এর জন্য Rust-এ আছে unsafe block. সেখানে পাঁচ রকম বাড়তি কাজের অনুমতি, যার প্রধানটি raw pointer (*mut T)-এর ভেতরে ঢোকা। সত্যিকারের run-এ unsafe { *p += 60; }-সহ program ছাপে 1056; একই লাইন unsafe ছাড়া লিখলে:

error[E0133]: dereference of raw pointer is unsafe and requires unsafe function or block
 --> prog.rs:4:5
  |
4 |     *p += 60;
  |     ^^ dereference of raw pointer
  |
  = note: raw pointers may be null, dangling or unaligned; they can violate aliasing rules and cause data races: all of these are undefined behavior

unsafe borrow checker বন্ধ করে না: সাধারণ & আর &mut সেখানেও আগের মতো যাচাই হয়। সে শুধু বলে, “এই কয়েকটি কাজের নিরাপত্তা আমি (প্রোগ্রামার) নিশ্চিত করছি”। বাস্তবের রীতি হলো unsafe কোডকে একটি ছোট module-এ রেখে বাইরে নিরাপদ API দেওয়া, যেমন standard library-র Vec: ভেতরে raw pointer, বাইরে শুধু নিয়ম-মানা method. তখন ভুল খোঁজার জায়গা পুরো program নয়, শুধু সেই ছোট অংশ। Unsafe কোডে undefined behavior খুঁজতে Rust প্রকল্পের Miri নামের একটি interpreter আছে, যা MIR চালিয়ে aliasing-এর নিয়ম ভাঙা ধরে (সেই নিয়মের আনুষ্ঠানিক প্রস্তাব Stacked Borrows, পরে Tree Borrows). C ভাষার undefined behavior আর নিরাপদ কোডিংয়ের অভ্যাস C কোর্সের পর্ব ৪৮-এ।

ভাষাধারণা (সংক্ষেপে; বিস্তারিত সংস্করণভেদে বদলায়)
Cyclone (AT&T Labs আর Cornell, ২০০০-এর দশকের শুরু)C-এর নিরাপদ উপভাষা; region-ভিত্তিক memory, যেখানে pointer-এর type-এ লেখা থাকে সে কোন region-এর। Rust Reference-এর “influences” তালিকায় ML Kit আর Cyclone-এর region-ভিত্তিক memory-র নাম আছে।
Swiftপ্রধানত automatic reference counting; “law of exclusivity” একই চলকে একসঙ্গে বদলানো আর পড়া নিষেধ করে, যতটা পারে compile-এর সময়, বাকিটা চলার সময়। পরের সংস্করণে noncopyable type (~Copyable) এসেছে।
Vale (পরীক্ষামূলক)“generational reference”: প্রতিটি ঘরে একটি প্রজন্ম-নম্বর, আর reference ব্যবহারের সময় নম্বর মিলিয়ে দেখা; ভুল চলার সময় ধরা পড়ে।
Hylo, আগের নাম Val (গবেষণা পর্যায়ে)“mutable value semantics”: সাধারণ কোডে reference-ই প্রায় নেই, মান কপির মতো আচরণ করে, তাই aliasing-এর প্রশ্ন ওঠে কম।

আরও গভীরে। Ralf Jung ও সহকর্মীদের RustBelt (POPL ২০১৮) Coq-এ Iris logic দিয়ে Rust-এর একটি মূল অংশের safety প্রমাণ করে, আর দেখায় কীভাবে Rc বা Mutex-এর মতো unsafe-ভেতরের library-র জন্য “এই API নিরাপদ” দাবিটি আলাদা প্রমাণের বিষয়। Borrow checker-এর পরের প্রজন্ম Polonius (loan-এর প্রশ্নকে Datalog-ধাঁচের নিয়মে লেখা) বহু বছর ধরে উন্নয়নে, আর লেখার সময় পর্যন্ত ডিফল্ট হয়নি বলে জানা যায়; এটি NLL-এর বাতিল করা কিছু সঠিক program, বিশেষ করে শর্তসাপেক্ষে ধার ফেরত দেওয়া function, গ্রহণ করার লক্ষ্যে। ধারণাগত পূর্বসূরি Tofte আর Talpin-এর region inference (১৯৯০-এর দশক), যা ML Kit-এ GC ছাড়াই memory ফেরত দিত।

পরীক্ষা ও ইন্টারভিউতে। বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন আসে:

  • “Use-after-free আর double free কেন হয়, আর ownership কীভাবে দুটিই আটকায়?” দুই নাম একই ঘরকে নিজের ভাবে; move-এর পরে পুরোনো নাম অচল, তাই মালিক একজন আর drop একবার।
  • “Rust-এ & আর &mut-এর নিয়ম কী?” যত খুশি &, অথবা একটি &mut, একসঙ্গে নয় (aliasing XOR mutability).
  • “NLL কী বদলেছে?” ধার শেষ হয় reference-এর শেষ ব্যবহারে, lexical scope-এর শেষে নয়; তাই আগে বাতিল কিছু নিরাপদ program এখন গৃহীত।
  • “Lifetime annotation 'a কি মানের জীবন বাড়ায়?” না; শুধু argument আর ফলের ধারের সম্পর্ক লেখে, যাতে caller যাচাই করা যায়।
  • “GC আর ownership-এর আপস?” GC: সহজ লেখা, চলার সময় খরচ, ফেরত অনির্দিষ্ট; ownership: নির্দিষ্ট মুহূর্তে ফেরত, শূন্যের কাছাকাছি runtime খরচ, কিন্তু কড়া নিয়ম।

১০ · AI-এর যুগে memory safety আর borrow checker

Borrow checker-এর error-এ আটকে AI-এর কাছে যাওয়া খুব সাধারণ। AI প্রায়ই দ্রুত “সমাধান” দেয়, যা compile হয় কিন্তু নকশাটি নষ্ট করে, বা ভাষার নিয়ম ভুল বলে:

AI-এর সাধারণ ভুলকীভাবে ধরবেন
সব error-এ .clone() বা Rc<RefCell<…>> বসানো: compile হয়, কিন্তু খরচ বাড়ে আর ভুল চলার সময়ে সরে যায় (RefCell-এর panic)Error-এর তিনটি জায়গা (ধার, সংঘাত, পরের ব্যবহার) নিজে পড়া; ব্যবহারের ক্রম বদলালেই হয় কি না দেখা
Error ঢাকতে unsafe বা raw pointerপ্রতিটি unsafe-এর পাশে লিখিত যুক্তি চাওয়া; Miri-তে চালানো
“C++-এ move-এর পরে ব্যবহার compile error” বা “sanitizer চালালে program নিরাপদ প্রমাণিত” ধাঁচের দাবিআসল compiler-এ -Wall -Wextra দিয়ে চালানো (অংশ ২-এর run); sanitizer শুধু চলা পথ দেখে
পুরোনো Rust-এর (NLL-এর আগের) নিয়ম বা ভুল error code বলা, বা বানানো compiler flagrustc-এর বার্তা আর rustc --explain E0502; নির্দিষ্ট version-এ চালানো
নিজের checker-এর জন্য AI-এর লেখা নিয়ম যা শাখা মেলাতে ∩ নেয় বা loop একবারই দেখেif-এ এক শাখায় move আর loop-এ move: দুটি ছোট program; আসল rustc-এর সঙ্গে differential test

AI-কে কাজে লাগাতে আসল error বার্তাটি পুরো দিন, আর নকশা না ভেঙে সমাধান চান:

আমি Rust 1.82 (edition 2021) ব্যবহার করি। নিচে আমার কোড আর rustc-এর পুরো error বার্তা দিলাম। ১. বার্তার তিনটি জায়গা (কোথায় ধার হলো, কোথায় সংঘাত, কোথায় পরে ব্যবহার) আমার কোডের লাইন ধরে ব্যাখ্যা করো। ২. clone, Rc, RefCell বা unsafe ছাড়া সমাধান আছে কি না আগে দেখাও (যেমন ব্যবহারের ক্রম বদলানো, ছোট scope, index দিয়ে কাজ)। না থাকলে কারণ বলো। ৩. প্রতিটি পরিবর্তনের পরে rustc কী বলবে বলে তোমার ধারণা, আলাদা করে লেখো; আমি নিজে চালিয়ে মেলাব। ৪. কোনো নিয়ম Rust-এর version বা edition-ভেদে বদলালে (যেমন NLL) স্পষ্ট বলো, আর অনিশ্চিত হলে তা-ও বলো।

AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট

ভাবনার প্রশ্ন

প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।

প্র ০১Rust-এ দুই দিকে link-ওয়ালা তালিকা বা চক্রওয়ালা graph লেখা কুখ্যাতভাবে কঠিন। এটি কি borrow checker-এর ভুল, নাকি নকশার অনিবার্য ফল?

দুই দিকে link-ওয়ালা তালিকায় প্রতিটি node-কে দুজন দেখায়: আগের node আর পরের node. Ownership-এর নিয়ম ৭৬.১ বলে মালিক একজন, আর নিয়ম ৭৬.২ বলে কাউকে বদলাতে হলে তখন অন্য কোনো পথ থাকা চলবে না। তালিকা থেকে একটি node সরাতে দুই প্রতিবেশীকেই একসঙ্গে বদলাতে হয়, অথচ দুজনেই তৃতীয় node-কে দেখাচ্ছে। নিরাপদ Rust-এর নিয়মে এই ছবি সরাসরি লেখা যায় না, কারণ ঠিক এই ধরনের ভাগাভাগি করা, বদলানো কাঠামোই use-after-free-এর জন্মস্থান।

এটি অংশ ৮-এর Rice-এর theorem-এর বাস্তব রূপ। কোনো checker সব নিরাপদ program চিনতে পারে না; Rust-এর নকশাকারেরা বেছেছেন সন্দেহ হলে বাতিল করা। তাই এখানে “ভুল” শব্দটি ঠিক নয়: checker তার প্রতিশ্রুতি রাখছে, শুধু প্রমাণের ভাষাটি সরল, আর graph-এর মতো কাঠামোর নিরাপত্তা সেই ভাষায় সহজে বলা যায় না।

বাস্তবে তিনটি পথ চালু। এক, Rc (reference counting) আর Weak দিয়ে ভাগ করা মালিকানা, সঙ্গে RefCell, যা ধারের নিয়ম চলার সময় যাচাই করে; দাম গণনার খরচ আর চলার সময়ের panic-এর সম্ভাবনা, আর চক্র থাকলে memory ফেরত না যাওয়া। দুই, সব node একটি Vec-এ রেখে pointer-এর বদলে index ব্যবহার, যাকে arena বলা হয়: মালিক একটাই (Vec), আর index নিছক সংখ্যা, তাই borrow checker খুশি; কিন্তু মুছে ফেলা node-এর index ব্যবহারের ভুল তখন যুক্তির ভুল হয়ে ফিরে আসে, memory-র ভুল হিসেবে নয়। তিন, standard library-র LinkedList-এর মতো unsafe ভেতরে রেখে নিরাপদ API, যার নিরাপত্তা প্রোগ্রামার আর পর্যালোচকেরা প্রমাণ করেন।

মজার ব্যাপার, GC-ভাষায় এই সমস্যাই নেই: Java-তে graph লেখা সহজ, কারণ runtime চক্রসহ পুরো graph-এর পৌঁছানোর হিসাব রাখে। প্রতিটি পথ একই প্রশ্নের দাম অন্য জায়গায় শোধ করে।

মূল উপলব্ধি: ownership-এর নিয়ম গাছের মতো কাঠামো সহজে প্রমাণ করে কিন্তু ভাগ করা চক্র নয়; সমাধান হয় চলার সময়ের যাচাই (Rc/RefCell), নয় index-এর মতো ভিন্ন উপস্থাপনা, নয় সীমিত unsafe.

প্র ০২GC থাকলে memory safety প্রায় বিনামূল্যে মেলে। তাহলে systems-এর কাজে ownership কেন বেছে নেওয়া হয়, আর কোন কাজে GC-ই ভালো?

GC memory safety দেয় একটি সরল যুক্তিতে: যে ঘরে পৌঁছানো যায়, সেটি জীবিত। ফলে use-after-free আর double free অসম্ভব, আর প্রোগ্রামারকে মালিকানা নিয়ে ভাবতে হয় না। কিন্তু তিনটি জিনিস সে দেয় না। প্রথমত, কখন memory ফেরত যাবে তা অনির্দিষ্ট; collector-এর কাজের সময় program থামতে বা ধীর হতে পারে, আধুনিক collector এই বিরতি অনেক ছোট করলেও শূন্য নয়। Kernel, audio বা নির্দিষ্ট সময়ের মধ্যে সাড়া দেওয়ার কোডে এটি সমস্যা। দ্বিতীয়ত, ফাইল, socket বা lock-এর মতো রিসোর্স memory নয়; GC সেগুলো সময়মতো বন্ধ করে না, তাই Java-তে try-with-resources আর Python-এ with লাগে, যা আসলে RAII-র আরেক রূপ। তৃতীয়ত, collector-এর নিজের runtime আর বাড়তি memory লাগে, যা ছোট embedded যন্ত্রে বা অন্য ভাষার library হিসেবে বসানোর সময় ভারী।

Ownership এই তিনটি সমস্যা সমাধান করে: drop-এর মুহূর্ত কোড দেখেই বলা যায়, একই নিয়মে ফাইল আর lock বন্ধ হয়, আর কোনো runtime লাগে না, তাই Rust-এ লেখা অংশ C program-এর ভেতরে বসানো যায়। দাম হলো লেখার কষ্ট আর কিছু সঠিক কাঠামো সরাসরি লিখতে না পারা (প্রশ্ন ০১)।

তবে উল্টো দিকেও যুক্তি জোরালো। বেশিরভাগ ব্যবসায়িক software, web backend বা data-র কাজে collector-এর বিরতি অদৃশ্য, আর ডেভেলপারের সময় অনেক দামি। সেখানে GC-ভাষা (Java, Go, C#, Python) প্রায়ই সঠিক পছন্দ। একটি মাঝামাঝি সত্যও আছে: Rust নিজেও Rc-এর মতো reference counting রাখে, আর Swift প্রধানত reference counting-এর ওপর চলে; পর্ব ৭৫-এ দেখবেন reference counting নিজেই একধরনের GC, যার নিজস্ব দুর্বলতা (চক্র) আছে।

মূল উপলব্ধি: GC আর ownership দুটিই memory safety দেয়; পার্থক্য হলো খরচ কোথায় পড়ে, চলার সময়ে (GC) না লেখার সময়ে (ownership), আর কোন কাজে কোন খরচ সহনীয়, সেটিই বাছাইয়ের মাপকাঠি।

প্র ০৩NLL আসার আগে Rust কেন lexical scope ধরে ধার বাঁচিয়ে রাখত, আর NLL-এর পরেও কোন সঠিক program বাতিল হয়?

Lexical নিয়মের সুবিধা ছিল সরলতা। একটি reference যে block-এ ঘোষিত, ধার সেই block-এর শেষ পর্যন্ত: এটি AST দেখেই বলা যায়, control flow বিশ্লেষণ লাগে না, আর প্রোগ্রামারও সহজে অনুমান করতে পারেন। অসুবিধা ছিল অংশ ৬-এর মতো উদাহরণ: একটি তালিকার প্রথম উপাদান পড়ে ছেপে দেওয়ার পরে আর কোনো ব্যবহার নেই, তবু তালিকায় যোগ করা নিষেধ, কারণ reference-এর নাম তখনও scope-এ। প্রোগ্রামারেরা বাড়তি { } বসিয়ে ধার ছোট করতেন, যা কোডকে অকারণে জটিল করত।

NLL ধারকে liveness-এর প্রশ্ন বানায়: reference-টি এই বিন্দু থেকে কোনো পথে আবার ব্যবহার হবে কি না। এর জন্য compiler-এর দরকার ছিল একটি সঠিক control flow graph, যা rustc-তে আসে MIR (mid-level IR) দিয়ে; borrow checker তাই AST থেকে MIR-এ সরে যায়। আমাদের খসড়ায় একই প্রশ্নের সরল রূপ দেখেছেন: শেষ ব্যবহারের অবস্থান, loop-এ পরের round বিবেচনা করে।

NLL-এর পরেও কিছু সঠিক program বাতিল হয়। সবচেয়ে পরিচিত ধাঁচ: একটি function একটি map থেকে শর্তসাপেক্ষে একটি ধার ফেরত দেয়; না পেলে একই map-এ নতুন মান ঢুকিয়ে সেটির ধার দেয়। মানুষের চোখে দুই পথ আলাদা, কিন্তু NLL-এর হিসাবে প্রথম ধারটি function-এর ফলের lifetime জুড়ে বাঁচে, তাই দ্বিতীয় পথেও সংঘাত দেখায়। Rust সম্প্রদায়ে এটি NLL-এর “problem case #3” নামে আলোচিত, আর Polonius এরকম ক্ষেত্র গ্রহণের লক্ষ্যে তৈরি হচ্ছে বলে জানানো হয়েছে। আরেকটি পরিচিত সূক্ষ্মতা “two-phase borrow”: v.push(v.len())-এ &mut v নেওয়ার পরে argument-এ v.len() পড়া, যা compiler বিশেষ নিয়মে অনুমতি দেয়।

মূল উপলব্ধি: borrow checker-এর ইতিহাস মানে নিরাপত্তা না কমিয়ে বাতিল-হওয়া সঠিক program-এর সংখ্যা কমানোর ইতিহাস; প্রতিটি ধাপে বিশ্লেষণ আরও সূক্ষ্ম হয়েছে (scope → liveness → Polonius), আর প্রতিটি ধাপে compiler-এর ভেতরের রূপ (AST → MIR) বদলেছে।

প্র ০৪unsafe থাকলে কি Rust আসলে C-এর চেয়ে বেশি নিরাপদ নয়? কোনো library-র ভেতরে একটি ভুল unsafe পুরো program-কে ঝুঁকিতে ফেলতে পারে।

প্রশ্নটির অর্ধেক সত্য। একটি ভুল unsafe block পুরো program-এ undefined behavior আনতে পারে, আর তখন তার ফল C-এর মতোই অনির্দিষ্ট: Rust compiler-ও ধরে নেয় নিয়ম ভাঙা হয়নি, আর সেই ধারণায় optimize করে। তাই “Rust-এ লেখা” কথাটি একা কোনো নিশ্চয়তা নয়।

পার্থক্যটি হলো ঝুঁকির ঠিকানা। C program-এ প্রতিটি pointer-এর ব্যবহার সম্ভাব্য ভুলের জায়গা, তাই পর্যালোচনা বা audit করতে হয় সব কোড। Rust-এ নিরাপদ অংশে memory-র ভুল compiler প্রমাণ করে অসম্ভব রাখে, তাই memory-র ভুল খুঁজতে শুধু unsafe শব্দ খুঁজলেই হয়। এটি একটি সীমানা: unsafe কোডের লেখক একটি চুক্তি দেন যে তাঁর নিরাপদ API যেকোনো নিরাপদ ব্যবহারে নিয়ম ভাঙবে না। চুক্তি ঠিক থাকলে বাকি কোড, যত বড়ই হোক, নিরাপদ।

এই চুক্তি কি প্রমাণ করা যায়? RustBelt প্রকল্প ঠিক এটিই করেছে Rust-এর একটি মূল অংশ আর কয়েকটি গুরুত্বপূর্ণ library-র জন্য, Coq-এর ভেতরে Iris logic দিয়ে। বাস্তবে আরও কয়েকটি স্তর আছে: Miri unsafe কোড চালিয়ে aliasing-এর নিয়ম ভাঙা খোঁজে, fuzzing (Software Testing কোর্সে) আর sanitizer অচেনা input-এ ভুল খোঁজে, আর অনেক প্রকল্প প্রতিটি unsafe block-এর পাশে “SAFETY:” মন্তব্যে যুক্তি লিখতে বলে।

তুলনাটা তাই এমন: C-তে নিরাপত্তা ছড়ানো দায়িত্ব, Rust-এ ঘন একটি দায়িত্ব। ছোট, চিহ্নিত জায়গা যাচাই করা বড়, অচিহ্নিত পুরো কোড যাচাইয়ের চেয়ে অনেক সহজ, তবে অসম্ভব নয় যে সেখানেও ভুল থাকবে।

মূল উপলব্ধি: unsafe নিরাপত্তা বন্ধ করে না, দায় সরিয়ে একটি ছোট, খোঁজা যায় এমন জায়গায় আনে; Rust-এর নিশ্চয়তা হলো “unsafe অংশ ঠিক হলে বাকি সব নিরাপদ”, আর সেই অংশের জন্য প্রমাণ, Miri আর পর্যালোচনা লাগে।

প্র ০৫Haat-এর পরের version-এ সত্যিই ownership যোগ করতে হলে compiler-এর কোন কোন ধাপ বদলাবে, আর Haat-এর closure-এর নিয়ম কোথায় বাধা দেবে?

Front end-এ বদল ছোট: lexer-এ & token আর mut-এর ব্যবহার, parser-এ Ref node আর type-এর নতুন রূপ, যেমন এই পর্বের own_front.py-তে দেখেছেন। Resolver আগের মতোই নাম খোঁজে, তবে প্রতিটি নামের “ঘর-block” মনে রাখতে হবে, যা আমাদের checker-এর home. Type checker-কে জানতে হবে কোন type Copy আর কোনটি move হয়, আর &Box ও &mut Box আলাদা type. তারপর একটি নতুন pass: এই পর্বের ownership আর borrow checker, যা type checker-এর পরে চলে কারণ তার type-এর তথ্য লাগে।

Back end-এ সবচেয়ে বড় বদল drop. Interpreter আর VM-কে block শেষে, প্রতিটি return-এ আর প্রতিটি পথে ঠিক জায়গায় memory ফেরত দিতে হবে, আর move হওয়া মান drop করা চলবে না। যেখানে move শুধু একটি শাখায় হয়, rustc সেখানে চলার সময়ের একটি ছোট পতাকা (drop flag) রাখে। Reference-এর spec decision 26-এর মতো, interpreter আর VM-কে এখানেও হুবহু একই আচরণ দেখাতে হবে।

সবচেয়ে কঠিন বাধা closure. Haat-এর spec বলে closure বাইরের variable “capture by reference” করে, একটি ভাগ করা environment-এ (পর্ব ৫৭-এর cell). Ownership-এর ভাষায় এটি একটি ধার, যা closure যতদিন বাঁচে ততদিন জীবিত; আর Haat-এর closure function থেকে ফেরত দেওয়া যায়, অর্থাৎ ধারটি মালিকের scope ছাড়িয়ে যেতে পারে, ঠিক অংশ ৭-এর ভুল। Rust এর সমাধানে move closure রেখেছে (capture করা মানের মালিকানা closure নেয়), আর closure-কে তিন ভাগে ভাগ করেছে: Fn, FnMut, FnOnce. Haat-এ এটি আনলে spec v1-এর একটি মূল সিদ্ধান্ত বদলাতে হবে, আর পুরোনো program-গুলো (যেমন counter-এর উদাহরণ) আর চলবে না।

একটি নরম পথও আছে: শুধু Box-এর মতো নতুন type-এ ownership-এর নিয়ম, আর পুরোনো Int, Bool, Str আর closure আগের মতো। এই পর্বের বর্ধিত রূপ ঠিক তাই, আর পর্ব ৭৫-এর GC বাকি অংশের দেখাশোনা করত।

মূল উপলব্ধি: ownership একটি আলাদা analysis pass হিসেবে যোগ করা সহজ, কিন্তু back end-এর drop আর ভাষার closure-এর নিয়মে সেটি গভীর বদল আনে; ভাষা-নকশায় memory-র নীতি শুরু থেকে ঠিক করা পরে বদলানোর চেয়ে অনেক সস্তা।

অনুশীলন

প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর checker চালিয়ে আর দরকারে আসল rustc-এ যাচাই করা।

  1. বাস্তবায়ন — reference কপির ফাঁক বন্ধ করুন: অংশ ৬-এর Borrow checker নিচের program গ্রহণ করে (ok), অথচ এর Rust রূপে rustc 1.82 দেয় E0506. ফাঁকটি কোথায়? Checker-এ কয়েক লাইন যোগ করে ঠিক করুন, আর বলুন লাইন ৪ আর ৫ অদলবদল করলে কী হওয়া উচিত।
    var order = box(1040);
    let a = &order;
    let b = a;
    put(order, 996);
    print(get(b));

    Loan-এর holder শুধু a. লাইন ৩-এ let b = a; একটি reference-এর কপি, কিন্তু checker loan-টিকে b-এর নামে তোলে না। a-এর শেষ ব্যবহার লাইন ৩, তাই লাইন ৪-এ loan “মৃত” আর put গৃহীত, যদিও b দিয়ে লাইন ৫-এ একই ধার পড়া হবে। সমাধান: কোনো reference নাম থেকে নতুন নাম বানালে, পুরোনো holder-এর প্রতিটি loan-এর একটি কপি নতুন holder-এর নামে রাখা:

    class Borrow2(Borrow):
        def stmt(self, s, st):
            st = super().stmt(s, st)
            if isinstance(s, Let) and isinstance(s.init, Var) and self.kind.get(s.init.name, "").startswith("&"):
                st["loans"] += [(l[0], l[1], s.name, l[3]) for l in st["loans"] if l[2] == s.init.name]
            return st

    লেখকের lab-এ চালানো (CPython 3.14.4): এখন বার্তা 4:5: error: cannot assign to 'order' because it is borrowed, note 2:9: borrow occurs here আর 5:11: borrow later used here, rustc-এর E0506-এর মতো। লাইন ৪ আর ৫ অদলবদল করলে (আগে পড়া, পরে লেখা) Borrow2 বলে ok, আর সেই রূপের Rust কোড rustc 1.82-এ সত্যিকারের run-এ compile হয়ে ছাপে 1040. পুরো ১৭টি program-এর suite Borrow2 দিয়েও ১৭/১৭ মেলে, অর্থাৎ পরিবর্তনটি পুরোনো কিছু ভাঙেনি। শিক্ষা: differential test-এর suite যত ভালোই হোক, একটি নতুন ধাঁচের program নতুন ফাঁক দেখাতে পারে; ভালো অভ্যাস হলো প্রতিটি পাওয়া ফাঁককে suite-এ যোগ করা।

  2. ভুল খুঁজুন: একজন যুক্তি দিলেন: “পর্ব ৫৪-এর definite assignment-এ শাখা মিলনে ∩ নেওয়া হয়, তাই move checker-এও merge-এ ∩ নেওয়া উচিত: দুটি শাখাতেই move হলে তবেই ‘moved’.” এই বদলে move checker-এর আচরণ কী হবে? if_move আর loop_move দিয়ে যুক্তি দিন।

    যুক্তিটি প্রশ্ন উল্টে ফেলেছে। Definite assignment জিজ্ঞেস করে “সব পথে মান বসেছে কি?”, তাই নিশ্চিত তথ্য পেতে ∩. Move checker জিজ্ঞেস করে “কোনো পথে move হয়েছে কি?”, কারণ একটি পথেও move হলে পরের ব্যবহার সেই পথে use-after-move; তাই ∪. লেখকের lab-এ merge-কে ∩ বানিয়ে চালানো হয়েছে: if_move দেয় ok (else শাখা নেই, সেখানে move নেই, ছেদ ফাঁকা), আর loop_move-ও দেয় ok, কারণ loop-এর আগের অবস্থা (move নেই) আর দেহের পরের অবস্থার ছেদ ফাঁকা, তাই দ্বিতীয় round কখনো দেখা হয় না। দুটিই rustc-এ E0382, অর্থাৎ ∩ নিলে checker unsound: সত্যিকারের ভুল ছেড়ে দেয়। নিয়মটি মনে রাখার উপায়: “নিষেধ”-এর প্রশ্নে (moved, live loan) ∪, “নিশ্চয়তা”-র প্রশ্নে (assigned) ∩.

  3. হিসাব — আউটপুট আগে বলুন: অংশ ৬-এর checker নিচের program-এ ঠিক কোন বার্তাগুলো (জায়গাসহ) দেবে? কোনটি দেবে না, আর কেন?
    let a = box(1);
    let b = a;
    var c = box(2);
    if get(c) > 1 { c = b; } else { drop(b); }
    print(get(c));
    print(get(b));
    print(get(a));

    লেখকের lab-এ চালানো আসল ফল:

    6:11: error: use of moved value 'b'
    4:21: note: value moved here
    7:11: error: use of moved value 'a'
    2:9: note: value moved here

    লাইন ২-এ a-এর মালিকানা b-তে গেছে (2:9-এ move). লাইন ৪-এ দুই শাখাতেই b move হয়: then-শাখায় c = b (4:21), else-শাখায় drop(b); মিলনের পরে b moved, note-এ checker then-শাখার জায়গাটি দেখায়। লাইন ৫-এ কোনো error নেই: then-শাখায় c নতুন মান পেয়েছে, else-শাখায় c কখনো move হয়নি, তাই দুই পথেই c জীবিত। পুরোনো c-এর মান c = b-এর সময় drop হয়, সেটি ভুল নয়। Rust রূপে rustc 1.82 সত্যিকারের run-এ দেয় দুটি E0382, b-এর জন্য দুটি “value moved here” (দুই শাখাতেই) আর a-এর জন্য একটি; error-এর সংখ্যা আর লাইন একই, rustc শুধু দুই শাখার জায়গাই দেখায়।

  4. প্রমাণ — move checker sound আর থামে: ধরুন program-এ কোনো reference নেই (শুধু Box, move আর পড়া)। প্রমাণ করুন: (ক) কোনো execution-এ x move হওয়ার পরে আবার মান না পেয়ে ব্যবহার হলে, অংশ ৪-এর checker সেখানে error দেয়; (খ) While-এর fixpoint loop সবসময় থামে।

    প্রমাণের রূপরেখা। প্রতিটি বিন্দু p-র জন্য দাবি I(p): “কোনো execution যদি p-তে এমন অবস্থায় পৌঁছায় যেখানে x move হয়েছে আর তারপর নতুন মান পায়নি, তাহলে checker-এর moved(p)-তে x আছে”।

    1. শুরুতে কিছু move হয়নি, moved ফাঁকা: I সত্য।
    2. সরল statement: argument, let-এর ডান দিক, return বা drop-এ move হলে checker x যোগ করে; x = e হলে execution-এ x নতুন মান পায় আর checker x সরায়। অন্য কিছু moved বদলায় না। তাই I এগোয়।
    3. if: execution একটি শাখা দিয়েই যায়। Induction-এর অনুমানে সেই শাখার শেষ অবস্থায় I সত্য, আর মিলন ∪ নেয়, তাই মিলনের অবস্থা দুই শাখার যেকোনোটির চেয়ে বড় বা সমান: I বজায় থাকে।
    4. while: fixpoint S এমন যে S ⊇ শুরুর অবস্থা আর S ⊇ (S থেকে দেহ চালানোর ফল)। k-তম round-এর শুরুর আসল অবস্থার ওপর k ধরে induction: প্রতিটি round-এর শুরুতে I-এর দাবি S-এর ভেতরে পড়ে। তাই দেহের প্রতিটি ব্যবহারের বিন্দুতেও।
    5. ব্যবহারের বিন্দুতে I বলে x ∈ moved, আর use() তখন error দেয়: (ক) প্রমাণিত।
    6. (খ): প্রতি পাকে merge(st, …)-এর ফলের নামের সেট st-এর নামের সেটের ⊇, আর সমান না হলে কঠোরভাবে বড়। নাম সীমিত (program-এর Box নামের সংখ্যা n), তাই সর্বোচ্চ n + 1 পাকে অবস্থা থেমে যায়। (একই নামের জায়গা বদলালেও সমতা ভাঙে না, কারণ মিলন আগের জায়গা রাখে।) ∎

    উল্টোটি সত্য নয়: checker এমন program-ও বাতিল করে যার কোনো execution ভুল করে না, যেমন if_move, যেখানে শর্ত সবসময় সত্য হলেও আমরা আর rustc দুজনেই শর্তের মান দেখি না। Sound কিন্তু complete নয়, পর্ব ৫৪-এর ভাষায়।

নিজেকে যাচাই করুন

ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।

ক্রমRust-ধাঁচের borrow checker নিচের program যাচাই করছে: var order = box(1040); let view = &order; let edit = &mut order; put(edit, 996); print(get(view)); ঘটনাগুলো ক্রমে সাজান (▲▼ চেপে সরান)

  1. Checker order-কে একটি Box-এর মালিক হিসেবে লেখে
  2. &order একটি শুধু-পড়ার loan তৈরি করে, holder view
  3. view-এর শেষ ব্যবহার শেষ লাইনে, তাই loan সেখান পর্যন্ত জীবিত
  4. &mut order চাওয়ার সময় জীবিত loan-গুলো খোঁজা হয়
  5. জীবিত শুধু-পড়ার loan পাওয়ায় error: borrowed as immutable
  6. Note-এ ধারের জায়গা আর পরের ব্যবহারের জায়গা দেখানো হয়

Rust-এ let order = Box::new(1040); ship(order); println!("{}", order); (ship-এর parameter-এর type Box<i64>) compile করলে কী হয়?

  • compile হয়ে 1040 ছাপে, কারণ Box কপি হয়
  • compile হয়, কিন্তু চলার সময় use-after-free crash
  • compile error E0382: moved value ব্যবহার
  • compile error E0499: দুটি mutable borrow

Rust-এর borrow-নিয়মে একই মুহূর্তে একটি মানের ওপর কোন ধারের সমষ্টি বৈধ?

  • একটি &mut আর দুটি &
  • তিনটি &, কোনো &mut নেই
  • দুটি &mut
  • একটি & আর একটি &mut

Non-lexical lifetimes (NLL)-এ একটি shared borrow কখন শেষ হয়?

  • reference-এর নামের block শেষ হলে
  • মালিকের function শেষ হলে
  • ধার নেওয়ার ঠিক পরের statement-এ
  • reference-টির শেষ ব্যবহারের পরে

একটি move checker if-এর দুই শাখার অবস্থা মেলাতে moved-নামের সেটে কোন কাজটি করবে, যাতে কোনো use-after-move না ফসকায়?

  • সংযোগ (∪): যেকোনো শাখায় move হলে moved
  • ছেদ (∩): দুই শাখাতেই move হলে তবেই moved
  • শুধু then-শাখার অবস্থা
  • শাখার আগের অবস্থা, শাখার বদল বাদ

Rust-এর fn bigger<'a>(a: &'a i64, b: &'a i64) -> &'a i64-এ lifetime annotation 'a কী বলে?

  • a আর b-এর মান program-এর শেষ পর্যন্ত বাঁচবে
  • চলার সময় ফলের বৈধতা পরীক্ষা হবে
  • ফলটি ততক্ষণই বৈধ, যতক্ষণ a আর b দুটিই বৈধ
  • ফলটি একটি নতুন মালিকানাধীন কপি

C++20-এ auto taken = std::move(order); (order একটি std::unique_ptr<long>) লেখার পরে *order পড়া সম্পর্কে কোনটি সঠিক?

  • compile error, Rust-এর E0382-এর মতো
  • compile হয়; এটি undefined behavior, কারণ order তখন null
  • নিরাপদে 1040 পড়া যায়, কারণ move আসলে কপি
  • std::bad_alloc exception ছোড়ে

শব্দকোষ

লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:

মনে রাখুন

  1. ভুলের পরিবার: use-after-free, double free, dangling (সময়), buffer overflow (জায়গা), data race (একসঙ্গে চলা)। C-তে এগুলো UB; GCC-র warning আর sanitizer সাহায্য করে, প্রমাণ করে না।
  2. তিন পথ: GC (পৌঁছানো গেলে জীবিত, খরচ চলার সময়), RAII (scope শেষে ফেরত, নিয়ম ভাঙা আটকায় না), ownership (একই ফেরত, নিয়ম compile-এর সময় প্রমাণিত)।
  3. Ownership আর borrow: একজন মালিক, move-এর পরে পুরোনো নাম অচল (E0382); যত খুশি & অথবা একটি &mut (E0502, E0499); ধার মালিকের চেয়ে বেশি বাঁচে না (E0597).
  4. Checker মানে dataflow: moved-সেট শাখায় ∪, loop-এ fixpoint; loan জীবিত যতক্ষণ holder পরে ব্যবহার হয় (NLL); block শেষে drop-এর সময় বাইরের জীবিত ধার মানে lifetime error.
  5. সীমা আর সততা: কোনো checker নির্ভুল নয় (Rice); Rust সন্দেহে বাতিল করে, unsafe দায়কে ছোট জায়গায় আনে; নিজের checker আসল rustc-এর সঙ্গে differential test-এ মেলাতে হয়, আর নতুন ফাঁক পেলে suite-এ যোগ করতে হয়।

পরের পর্বে: পর্ব ৭৭ (ভাষার স্তরে concurrency — memory model, data race আর async runtime). এই পর্বের aliasing XOR mutability-ই সেখানে thread-এর জগতে যায়: data race আসলে দুই thread-এর মধ্যে aliasing আর বদলানো একসঙ্গে।

আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ

এই পর্বটি শেয়ার করুন:
এই পর্বে ভুল পেয়েছেন? জানান