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

Closure — lexical environment ধরে রাখা function

Closures — Free Variables, Capture by Reference vs by Value, the Funarg Problems and How Closures Are Implemented

Taught in Bangla, this lesson defines a closure as code plus the environment where it was created and computes free variables by rule. A stepper shows the frame disappearing while the cell lives on. It compares capture by reference in Python, JavaScript and Haat with C++ [=] and [&] and Java's effectively final rule, explains why three Python lambdas in a loop give [20, 20, 20], and covers the upward and downward funarg problems, flat closures, closure conversion and Haat VM's MAKE_CELL and LOAD_FREE.

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

  • Closure, free variable আর bound variable-এর নির্ভুল সংজ্ঞা দেওয়া, আর একটি function-এর free variable-এর সেট নিয়মে হিসাব করা
  • Capture by reference আর capture by value-এর পার্থক্য Python, JavaScript, C++, Java আর Haat-এ সত্যিকারের run দিয়ে দেখানো
  • Loop-এর ভেতরে বানানো closure কেন সব একই মান দেখে, তা cell আর binding-এর স্তরে ব্যাখ্যা করা, আর তিন রকম সমাধান যাচাই করা
  • Upward আর downward funarg problem চেনা, আর কোন ক্ষেত্রে variable-কে stack থেকে heap-এ তুলতে হয় তা বলা
  • Closure-এর বাস্তবায়ন (cell, flat closure, closure conversion) Haat VM আর CPython-এর সত্যিকারের bytecode পড়ে ব্যাখ্যা করা

১ · Closure কী — function, সঙ্গে জন্মস্থানের পরিবেশ

বাজারঘরের ঢাকা আর চট্টগ্রাম কাউন্টারে গ্রাহক এলে টোকেন নম্বর দেওয়া হয়: ঢাকায় 101, 102, 103; চট্টগ্রামে 501, 502. নিয়ম একই (আগের নম্বরের পরের নম্বর), কিন্তু প্রত্যেকের নিজের খাতা। এটি লিখতে এমন function লাগে, যার নিজের মনে রাখা অবস্থা আছে, অথচ সেই অবস্থা global নয়। এর নাম closure.

স্কুলে যাওয়ার সময় মা একটি টিফিন বাক্স ভরে দেন। শিশু স্কুলের বেঞ্চে বসে খায় বাড়ির রান্না, ক্যান্টিনের নয়। Closure এই শিশুর মতো: function যেখানে জন্মেছে (বাড়ি), সেখানকার জিনিস সঙ্গে নিয়ে যায়, আর অন্য যেকোনো জায়গায় (স্কুল) চললেও সেটিই ব্যবহার করে। তবে closure-এর “বাক্স” অনেক সময় খাবারের কপি নয়, বাড়ির হাঁড়িটাই; বাড়িতে কেউ হাঁড়িতে ভাত বাড়ালে স্কুলেও বেশি ভাত দেখা যায়। এই পর্বের বড় প্রশ্ন: কপি, নাকি সেই হাঁড়ি?

সংজ্ঞায় যাওয়ার আগে দুটি শব্দ দরকার। fn(x: Int) -> Int { return x + bonus; }-এ x function-এর নিজের parameter: তার অর্থ function-এর ভেতরেই ঠিক হয়, তাই সে bound. কিন্তু bonus ভেতরে কোথাও ঘোষিত নয়; তার অর্থ আসে বাইরে থেকে, তাই সে free. Free variable থাকলে function “খোলা”: কাউকে বলে দিতে হবে bonus মানে কী। Closure সেই উত্তর function-এর সঙ্গেই বেঁধে দিয়ে তাকে “বন্ধ” (closed) করে; নামটি সেখান থেকেই।

সংজ্ঞা ১৭.১ — free variable

Haat-এর একটি ছোট অংশের জন্য free variable-এর সেট FV(e) নিয়মে লেখা যায় (∪ মানে মিলন, \ মানে বাদ দেওয়া):

FV(n) = ∅ (সংখ্যা)  ·  FV(x) = {x}  ·  FV(e1 + e2) = FV(e1) ∪ FV(e2)
FV(f(e1, …, en)) = FV(f) ∪ FV(e1) ∪ … ∪ FV(en)
FV(fn(x1, …, xn) { দেহ }) = FV(দেহ) \ {x1, …, xn, দেহের ভেতরে ঘোষিত নাম}

একটি নাম-ব্যবহার free, যদি তাকে ঘিরে থাকা কোনো function বা block তাকে ঘোষণা না করে; নইলে সে bound. FV(e) = ∅ হলে e closed.

সংজ্ঞা ১৭.২ — closure

একটি closure হলো একটি জোড়া ⟨code, ρ⟩: code হলো function-এর দেহ আর parameter-এর তালিকা, আর ρ (রো, environment) হলো function তৈরির মুহূর্তে দেখা যায় এমন নামগুলোর binding, অন্তত FV(fn …)-এর প্রতিটি নামের জন্য। Closure ডাকলে দেহ চলে ρ-কে parameter দিয়ে বাড়িয়ে, ডাকার জায়গার environment দিয়ে নয়। এই নিয়মই lexical scope-কে function পাঠানো আর ফেরত দেওয়ার পরও টিকিয়ে রাখে।

এখানে “binding” মানে নাম থেকে কোথায় যাওয়া হবে: কোনো ভাষায় সরাসরি মান, কোনো ভাষায় মেমরির একটি ঘর (location). এই ছোট পার্থক্যই অংশ ৩-এর by value বনাম by reference. নাম, binding আর binding time-এর মৌলিক ধারণা আছে পর্ব ১৪-এ (নাম, variable আর binding); static আর dynamic scope-এর পুরো তুলনা পর্ব ১৫-এ (Scope — static বনাম dynamic scoping আর nested scope). Closure-এর প্রশ্ন ওঠে শুধু first-class function-এর ভাষায়, যেখানে function-কে পাঠানো আর ফেরত দেওয়া যায়। এর ব্যবহারের দিক (currying, composition) দেখেছেন পর্ব ০৯-এ; এখানে ভেতরে ঢুকব: কী ধরা হয়, কতদিন বাঁচে, যন্ত্রে কীভাবে থাকে।

এবার বাজারঘরের টোকেন কাউন্টার Python-এ, ব্রাউজারের ভেতরে (Pyodide). make_counter একটি local variable nxt বানায়, তারপর একটি ভেতরের function tick ফেরত দেয়, যা nxt বাড়ায়। nonlocal বলে দেয় nxt = … লেখাটি নতুন local নয়, বাইরের সেই variable-এ assignment. শেষ অংশে দেখব CPython ধরা variable কোন বাক্সে রাখে।

def make_counter(start):
    nxt = start                  # a local of make_counter ...
    def tick():
        nonlocal nxt             # ... that tick will change
        nxt = nxt + 1
        return nxt
    return tick

dhaka = make_counter(100)
ctg = make_counter(500)
print(dhaka(), dhaka(), ctg(), dhaka())

print("free vars of tick:", dhaka.__code__.co_freevars)
print("cell vars of make_counter:", make_counter.__code__.co_cellvars)
cell = dhaka.__closure__[0]
print(type(cell).__name__, "holds", cell.cell_contents)
print("ctg's cell holds", ctg.__closure__[0].cell_contents)
print("same cell?", dhaka.__closure__[0] is ctg.__closure__[0])

def make_pair():                 # two closures, one variable
    total = 0
    def add(x):
        nonlocal total
        total += x
    def get():
        return total
    return add, get

add, get = make_pair()
add(1040); add(180)
print("get():", get(), " shared cell?", add.__closure__[0] is get.__closure__[0])
cell.cell_contents = 0           # write into the box directly
print("after poking the cell, dhaka() ->", dhaka())

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

101 102 501 103
free vars of tick: ('nxt',)
cell vars of make_counter: ('nxt',)
cell holds 103
ctg's cell holds 501
same cell? False
get(): 1220  shared cell? True
after poking the cell, dhaka() -> 1

প্রথম লাইন কাউন্টারের আচরণ: make_counter অনেক আগেই ফিরে গেছে, তবু dhaka নিজের nxt মনে রেখে 101, 102, 103 দিয়েছে, আর ctg আলাদা খাতায় 501. পরের দুই লাইন CPython-এর compiler-এর সিদ্ধান্ত: tick-এর code object-এ nxt একটি free variable (co_freevars), আর make_counter-এর code object-এ সেই একই নাম একটি “cell variable” (co_cellvars), অর্থাৎ যে local-কে ভেতরের কেউ ধরবে, তাকে compile-এর সময়েই বাক্সে রাখার ব্যবস্থা হয়। __closure__ হলো সেই বাক্সগুলোর tuple; প্রতিটি একটি cell object, যার cell_contents-এ এখন 103. দুই কাউন্টারের cell আলাদা (False), কিন্তু make_pair-এর add আর get একই cell ভাগ করে (True), তাই get() দুটি যোগের ফল 1220 দেখে। শেষ লাইন সবচেয়ে স্পষ্ট প্রমাণ: বাইরে থেকে বাক্সে 0 লিখে দিলে dhaka() পরের বার 1 দেয়। Closure মান কপি করেনি; সে বাক্সটিই ধরে আছে। Python-এর LEGB নিয়ম আর nonlocal-এর ব্যবহারিক দিক আছে Python কোর্সের পর্ব ২০-এ.

২ · Environment frame — closure তৈরি হয়, frame চলে যায়, cell থেকে যায়

প্রতিটি call একটি environment frame বানায়: parameter আর local-এর খাতা, সঙ্গে বাইরের frame-এর দিকে একটি সংযোগ। সাধারণ function-এ frame থাকে call stack-এ, আর call শেষ হলেই মুছে যায়। কিন্তু closure-এর ধরা variable call শেষ হওয়ার পরও দরকার; তাই তাকে frame-এর বাইরে, heap-এ একটি cell-এ রাখতে হয়। নিচের stepper Haat-এ লেখা একই কাউন্টার চালায়; প্রতিটি ধাপের মান Haat reference বাস্তবায়নের VM-এর ভেতরের trace থেকে মেলানো।

1fn make_counter(start: Int) -> () -> Int {2    var next = start;3    return fn() -> Int {4        next = next + 1; return next; };5}6let dhaka = make_counter(100);7let ctg = make_counter(500);8print(dhaka()); print(dhaka());9print(ctg()); print(dhaka());
এই ধাপে
call stack
heap
  1. make_counter(100) চলে। Stack-এ একটি নতুন frame, তাতে start = 100. next-কে ভেতরের function ধরবে, compiler তা আগেই জানে (resolver-এর “captured” চিহ্ন), তাই next সাধারণ slot-এ নয়, heap-এর একটি নতুন বাক্সে যায়: Cell#1, মান 100.
  2. Closure তৈরি। fn() -> Int { … } expression-টি মূল্যায়নে একটি closure D তৈরি হয়: ভেতরের function-এর code-এর দিকে একটি pointer, আর ধরা cell-এর তালিকা [Cell#1]. মানটি কপি হয়নি, বাক্সের ঠিকানা কপি হয়েছে।
  3. Frame মুছে গেল, cell টিকে আছে। make_counter ফিরে গেছে, তার frame stack থেকে উঠে গেছে; start আর নেই। কিন্তু Cell#1 এখনো D-এর হাতে, তাই heap-এ বেঁচে আছে। এখানেই closure-এর মূল কথা: variable-এর lifetime তার scope-এর চেয়ে লম্বা হলো।
  4. দ্বিতীয় কাউন্টার। make_counter(500) একদম নতুন frame আর নতুন বাক্স Cell#2 = 500 বানায়; closure C সেটি ধরে। একই code, আলাদা environment: D আর C-র খাতা আলাদা।
  5. প্রথম dhaka()। D-এর জন্য একটি নতুন frame তৈরি হয় (এর নিজের কোনো local নেই)। দেহের next খোঁজা হয় D-এর cell তালিকায়: 100 পড়ে, 1 যোগ করে 101 লেখে Cell#1-এ, আর 101 ফেরত দেয়। ছাপা হয় 101.
  6. দ্বিতীয় dhaka()। আবার নতুন frame, কিন্তু একই Cell#1: এবার 101 থেকে 102. প্রতিটি call-এর frame ক্ষণস্থায়ী; অবস্থা থাকে cell-এ।
  7. ctg()। C চলে, তার cell Cell#2: 500 থেকে 501. Cell#1 এতে একটুও বদলায়নি।
  8. আবার dhaka()। Cell#1: 102 থেকে 103. Reference বাস্তবায়নে python haat.py run আর vm দুটিই ঠিক এই চারটি লাইন ছাপে: 101, 102, 501, 103, Python-এর run-এর সঙ্গে হুবহু।

নিয়মে লেখা — closure-এর big-step semantics

উপরের ছবিকে নির্ভুল করতে দুটি জিনিস আলাদা রাখি: environment ρ, যা নাম থেকে location (মেমরির ঘর) দেয়, আর store σ (সিগমা), যা location থেকে মান দেয়। ⟨e, ρ, σ⟩ ⇓ ⟨v, σ′⟩ পড়ুন: “environment ρ আর store σ-তে e মূল্যায়ন করলে মান v আসে, আর store হয়ে যায় σ′”। Operational semantics-এর পুরো পদ্ধতি আসবে পর্ব ৪০-এ; এখানে শুধু তিনটি নিয়ম:

(কোনো শর্ত নেই)
⟨fn(x) { b }, ρ, σ⟩ ⇓ ⟨⟨x, b, ρ⟩, σ⟩
(E-Fn)
ρ(x) = ℓ    σ(ℓ) = v
⟨x, ρ, σ⟩ ⇓ ⟨v, σ⟩
(E-Var)
⟨f, ρ, σ⟩ ⇓ ⟨⟨x, b, ρ′⟩, σ1⟩   ⟨a, ρ, σ1⟩ ⇓ ⟨v, σ2⟩   ℓ নতুন   ⟨b, ρ′[x ↦ ℓ], σ2[ℓ ↦ v]⟩ ⇓ ⟨r, σ3⟩
⟨f(a), ρ, σ⟩ ⇓ ⟨r, σ3⟩
(E-Call)

E-Fn: function expression শুধু code আর বর্তমান ρ জোড়া বেঁধে closure বানায়। E-Call-এর শেষ শর্তটি আসল: দেহ b চলে closure-এর ρ′-এ, parameter x-কে নতুন ঘর ℓ দিয়ে; ডাকার জায়গার ρ সেখানে নেই। Dynamic scope-এর নিয়ম হতো ⟨b, ρ[x ↦ ℓ], …⟩: একটি অক্ষরের পার্থক্য, সম্পূর্ণ আলাদা ভাষা। আর ρ দেয় ঘর, মান নয়; কেউ σ-তে সেই ঘর বদলালে closure নতুন মান দেখে: capture by reference-এর গাণিতিক রূপ।

প্রস্তাব ১৭.১ — closure-এর ফল ডাকার জায়গার নামের ওপর নির্ভর করে না

ধরি একটি closure c = ⟨x, b, ρ′⟩, আর দুটি আলাদা environment ρ1, ρ2-তে c-কে একই argument মান v আর একই store σ দিয়ে ডাকা হলো। তাহলে দুই ক্ষেত্রে ফল আর শেষ store একই।

প্রমাণের রূপরেখা.

  1. E-Call অনুযায়ী call-এর ফল শুধু এই derivation থেকে আসে: ⟨b, ρ′[x ↦ ℓ], σ[ℓ ↦ v]⟩ ⇓ ⟨r, σ′⟩.
  2. এই premise-এ ρ1 বা ρ2 নেই; আছে শুধু closure-এর ρ′, argument v আর store σ. নতুন ঘর ℓ-এর নাম আলাদা হতে পারে, কিন্তু নতুন ঘরের নাম বদলালে (renaming) ফল বদলায় না।
  3. Derivation-এর গঠন এক, তাই r আর σ′-ও এক (মূল্যায়ন নির্ধারিত, অর্থাৎ deterministic, ধরে নিয়ে)। ∎

তাই closure-কে নিশ্চিন্তে callback হিসেবে বা অন্য module-এ পাঠানো যায়: যে নিয়েছে, সে নিজের নাম দিয়ে তার আচরণ বদলাতে পারে না। Dynamic scope-এ প্রস্তাবটি মিথ্যা, আর সেটিই funarg সমস্যার মূল (অংশ ৫)।

৩ · কী ধরা হয় — variable (by reference) নাকি মান (by value)

ρ যদি নাম থেকে মেমরির ঘর দেয়, closure variable-টিকেই ধরে: তৈরির পরের বদলও দেখে, আর নিজে বদলালে বাইরেও দেখা যায় (capture by reference). যদি দেয় তৈরির মুহূর্তের মানের কপি, তাহলে capture by value: পরের বদল closure দেখে না। প্রথমটি ঘরের চাবি দেওয়া, দ্বিতীয়টি ঘরের ছবি।

ভাষাকী ধরেলক্ষ করার মতো নিয়ম
Python 3.14variable (cell)ধরা নামে assignment করতে nonlocal লাগে; নইলে নতুন local তৈরি হয়
JavaScript (ES2015+)binding (variable)for (let …) প্রতি round-এ নতুন binding; var পুরো function-এ একটি
Haat v1variable (cell)spec: “capture by reference”; while-এর দেহ প্রতি round-এ নতুন scope; top-level variable global, তাই cell লাগে না
C++ (C++11 থেকে)আপনি বেছে নেন[=] কপি, [&] reference, [x, &y] আলাদা আলাদা; কপি বদলাতে mutable
Java (8 থেকে)মান (কপি)শুধু final বা effectively final local ধরা যায়, তাই কপি আর আসলের পার্থক্য কখনো চোখে পড়ে না
Rust (stable)borrow বা moveডিফল্টে যতটুকু দরকার ততটুকু borrow, move লিখলে মালিকানা closure-এ যায়; borrow checker lifetime যাচাই করে (পর্ব ৭৬)

C++-এর পার্থক্যটি সত্যিকারের Clang-এ দেখুন। কোডটি কোর্সের lab-এ PyPI-র ziglang 0.17.1 প্যাকেজের ভেতরের Clang 22.1.8 দিয়ে compile করে চালানো হয়েছে (x86-64, -std=c++20 -Wall -Wextra, -O0 আর -O2 দুটিতেই একই আউটপুট, কোনো warning নেই)। rate বদলানোর আগে দুটি lambda তৈরি হয়, একটি কপি ধরে, একটি reference:

#include <cstdio>
#include <functional>

std::function<int()> make_counter(int start) {
    int next = start;
    // [=] copies next; mutable lets the lambda change its own copy
    return [=]() mutable { next = next + 1; return next; };
}

int main() {
    int rate = 10;
    auto by_value = [=](int t) { return t - t * rate / 100; };
    auto by_ref   = [&](int t) { return t - t * rate / 100; };
    rate = 20;
    std::printf("by value: %d\n", by_value(1040));
    std::printf("by ref:   %d\n", by_ref(1040));

    auto a = make_counter(100);
    auto b = a;                     // copies the closure and its state
    int a1 = a();
    int a2 = a();
    std::printf("a: %d %d\n", a1, a2);
    std::printf("b: %d\n", b());
    std::printf("sizeof by_value=%zu by_ref=%zu\n", sizeof(by_value), sizeof(by_ref));
    return 0;
}
~/haat $ python -m ziglang c++ -std=c++20 -Wall -Wextra capture.cpp -o capture.exe
~/haat $ ./capture.exe
by value: 936
by ref:   832
a: 101 102
b: 101
sizeof by_value=4 by_ref=8

প্রথম দুই লাইন পুরো অংশের সারকথা: by_value তৈরির সময়ের rate = 10-এর কপি রেখেছে, তাই 1040 − 104 = 936; by_ref variable-টিই ধরেছে, তাই পরে বসানো 20 দেখে 1040 − 208 = 832. তৃতীয় আর চতুর্থ লাইন: [=]-ওয়ালা closure একটি সাধারণ object, next-এর কপি তার field; auto b = a; object-টি কপি করে, তাই b-এর আলাদা খাতা, 101 থেকে শুরু। Python বা JavaScript-এ b = a একই closure-এর দ্বিতীয় নাম (aliasing) হতো, আর b() দিত 103. শেষ লাইন lambda object-এর আকার: কপি-ওয়ালাটির ভেতরে একটি int (৪ byte), reference-ওয়ালাটির ভেতরে একটি ঠিকানা (এই x86-64 Clang-এ ৮ byte). আকার মানদণ্ডে নির্দিষ্ট নয়। Lambda-র ব্যবহারিক দিক আছে C++ কোর্সের পর্ব ৩৪-এ.

Reference-এ ধরা, তারপর frame উধাও: C++-এ garbage collector নেই, তাই [&] দিয়ে একটি local ধরে closure ফেরত দিলে, function ফেরার পর reference একটি মুছে যাওয়া ঘরকে দেখায়: একটি dangling reference, আর তাকে ব্যবহার করা undefined behavior (যেকোনো ফল হতে পারে; তাই আমরা চালাইনি)। একই lab-এ শুধু compile করে দেখা গেছে: return type auto হলে Clang 22.1.8 সতর্ক করে, warning: address of stack memory associated with local variable 'next' returned [-Wreturn-stack-address]; কিন্তু হুবহু একই lambda std::function<int()> হিসেবে ফেরত দিলে কোনো warning আসেনি। Warning না আসা নিরাপত্তার প্রমাণ নয়। নিয়ম: যে closure তার function-এর চেয়ে বেশি দিন বাঁচবে, তাতে local কপি করে ধরুন ([=], বা C++14-এর [n = std::move(x)]).

Java-র পথ আলাদা। Java 8-এ lambda বা anonymous class একটি local variable ব্যবহার করলে সেটি final বা effectively final হতে হয় (ঘোষণার পর আর কখনো নতুন মান পায় না)। নিচের কোডটি উদাহরণ, এই পর্বের জন্য চালানো হয়নি; n++ লাইনটি থাকলে javac এই ধরনের বার্তা দিয়ে compile বন্ধ করে: “local variables referenced from a lambda expression must be final or effectively final”.

int n = 0;
Runnable r = () -> System.out.println(n);   // n ধরা হলো (মানের কপি)
n++;                                        // এই লাইন থাকলে compile error

নিয়মটি capture by value-কে নিরাপদ করে: কপি নেওয়া হয়, কিন্তু আসল বদলানো নিষেধ, তাই দুটি কখনো আলাদা হয় না। বদলানো অবস্থা দরকার হলে Java-য় তা একটি object-এ রাখতে হয় (যেমন AtomicInteger), যাতে কপি হয় শুধু reference-টি। বিস্তারিত Java কোর্সের পর্ব ৩৪-এ.

Interpreter-এর ভেতরে দুই কৌশলের পার্থক্য মাত্র এক লাইনের। নিচের ছোট interpreter একটি tuple-AST চালায়: Env একটি frame আর বাইরের সংযোগ, where scope chain ধরে নাম খোঁজে। "fn" মূল্যায়নের লাইনে mode “ref” হলে closure পুরো env-এর pointer রাখে; “copy” হলে তৈরির মুহূর্তের সব দৃশ্যমান নামের একটি কপি (flat())। একই দুটি program দুই mode-এ চলে:

class Env:                                   # one frame + a link outward
    def __init__(self, names, outer=None): self.names, self.outer = names, outer
    def where(self, n):
        e = self
        while n not in e.names: e = e.outer   # walk the scope chain
        return e
    def flat(self):                           # every visible name, inner wins
        return {**(self.outer.flat() if self.outer else {}), **self.names}
class Closure:
    def __init__(self, params, body, env): self.params, self.body, self.env = params, body, env
def ev(e, env, mode):
    op, *a = e
    if op == "num": return a[0]
    if op == "get": return env.where(a[0]).names[a[0]]
    if op == "add": return ev(a[0], env, mode) + ev(a[1], env, mode)
    if op == "var": env.names[a[0]] = ev(a[1], env, mode); return None
    if op == "set": v = ev(a[1], env, mode); env.where(a[0]).names[a[0]] = v; return v
    if op == "do": return [ev(s, env, mode) for s in a][-1]
    if op == "fn":                            # the ONLY place the two modes differ
        return Closure(a[0], a[1], env if mode == "ref" else Env(env.flat()))
    if op == "call":
        f, args = ev(a[0], env, mode), [ev(x, env, mode) for x in a[1:]]
        return ev(f.body, Env(dict(zip(f.params, args)), f.env), mode)

N, G = (lambda v: ("num", v)), (lambda n: ("get", n))
prog1 = ("do", ("var", "bonus", N(5)),                     # var bonus = 5;
         ("var", "f", ("fn", ["x"], ("add", G("x"), G("bonus")))),
         ("set", "bonus", N(50)), ("call", G("f"), N(1)))
prog2 = ("do", ("var", "total", N(0)),                     # add and get share total
         ("var", "add", ("fn", ["x"], ("set", "total", ("add", G("total"), G("x"))))),
         ("var", "get", ("fn", [], G("total"))),
         ("call", G("add"), N(1040)), ("call", G("add"), N(180)), ("call", G("get")))
for mode in ("ref", "copy"):
    print(f"{mode:4}: f(1) after bonus = 50 ->", ev(prog1, Env({}), mode),
          "| get() after two adds ->", ev(prog2, Env({}), mode))

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

ref : f(1) after bonus = 50 -> 51 | get() after two adds -> 1220
copy: f(1) after bonus = 50 -> 6 | get() after two adds -> 0

প্রথম program-এ f তৈরির পর bonus 50 করা হয়েছে। Reference mode-এ f সেই variable-টিই দেখে, তাই 1 + 50 = 51; copy mode-এ তৈরির মুহূর্তের 5, তাই 6 (C++-এর 832 বনাম 936-এর হুবহু ছোট রূপ)। দ্বিতীয় program-টি copy mode-এর আসল দুর্বলতা দেখায়: add আর get দুজনেই total-এর নিজস্ব কপি পেয়েছে, তাই add যতই যোগ করুক, get নিজের কপির 0 দেখায়। Reference mode-এ দুজন একই frame ভাগ করে, তাই 1040 + 180 = 1220, Python-এর make_pair-এর সঙ্গে মিলে যায়। একাধিক closure একটি অবস্থা ভাগ করতে চাইলে by value যথেষ্ট নয়। এই interpreter শুধু ধারণার জন্য; Haat-এর আসল tree-walking interpreter-এ environment আর closure-এর পূর্ণ বাস্তবায়ন আসবে পর্ব ৫৭-এ (Environment আর closure-এর বাস্তবায়ন)।

৪ · Loop-এর closure — ফাঁদটি কোথায় লুকিয়ে থাকে

Loop-এর ভেতরে closure বানালে সবগুলো শেষ মান দেখে: এই ফাঁদের ভাষাভেদে ফলের টেবিল আছে পর্ব ১৩-এ, আর নাম ব্যবহারের মুহূর্তে খোঁজার ধারণা (late binding) পর্ব ১২-এ. এখানে প্রশ্ন হলো ভেতরে কেন. উত্তর: closure variable ধরে, আর loop-এ variable কয়টি তৈরি হয় তা ভাষার নিয়ম। নিচের run-এ CPython-এর cell দিয়ে কারণটি আর তিন রকম সমাধান সরাসরি দেখা যায়।

from functools import partial

def slots_buggy():
    fs = []
    for i in range(3):                  # one variable i for the whole loop
        fs.append(lambda: i * 10)
    return fs

def slots_default():
    return [lambda i=i: i * 10 for i in range(3)]   # value copied now

def make_slot(i):                       # a new call = a new cell
    return lambda: i * 10

def slots_factory():
    return [make_slot(i) for i in range(3)]

def slots_partial():
    return [partial(lambda i: i * 10, i) for i in range(3)]

for name, maker in [("buggy", slots_buggy), ("default", slots_default),
                    ("factory", slots_factory), ("partial", slots_partial)]:
    print(f"{name:8}", [f() for f in maker()])

fs = slots_buggy()
c0, c1 = fs[0].__closure__[0], fs[1].__closure__[0]
print("buggy: one shared cell?", c0 is c1, "| it holds", c0.cell_contents)
gs = slots_factory()
print("factory: one shared cell?", gs[0].__closure__[0] is gs[1].__closure__[0])
print("default: closure =", slots_default()[0].__closure__,
      "| default value =", slots_default()[2].__defaults__)

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

buggy    [20, 20, 20]
default  [0, 10, 20]
factory  [0, 10, 20]
partial  [0, 10, 20]
buggy: one shared cell? True | it holds 2
factory: one shared cell? False
default: closure = None | default value = (2,)

Python-এ for নতুন scope বানায় না; i পুরো slots_buggy-এর একটি local. তিনটি lambda সেটি ধরে, তাই compiler i-কে একটিমাত্র cell-এ রাখে, আর তিনটি closure সেই একই cell-এর ঠিকানা পায় (True). Loop শেষে cell-এ 2, তাই তিনটিই 20. সমাধানগুলো কাজ করে আলাদা কারণে। Default argument (i=i) মোটেই closure নয় (__closure__ = None): মানটি function তৈরির মুহূর্তে __defaults__-এ কপি হয়, অর্থাৎ হাতে বানানো capture by value. Factory function প্রতিবার ডাকায় একটি নতুন frame আর নতুন cell পায় (False): by reference-ই, কিন্তু প্রতি round-এ আলাদা variable. আর partial argument-টি নিজের ভেতরে জমা রাখে, closure ছাড়াই।

ধাপে ধাপে দেখুন: তৈরির সময় কোনো lambda i পড়েনি; পড়া হয় শুধু ডাকার সময়।

1def slots_buggy():2    fs = []3    for i in range(3):4        fs.append(lambda: i * 10)5    return fs6print([f() for f in slots_buggy()])7def make_slot(i): return lambda: i * 108gs = [make_slot(i) for i in range(3)]
এই ধাপে
cell i
closure
  1. প্রথম round, i = 0. i একটি cell variable, কারণ ভেতরের lambda তাকে ধরে। Cell-এ 0. λ0 তৈরি হয়: code + এই cell-এর ঠিকানা। λ0 এখনো কিছু হিসাব করেনি।
  2. দ্বিতীয় round, i = 1. for নতুন variable বানায় না; একই cell-এ 1 লেখা হয়। λ1-ও সেই একই cell ধরে। λ0-এর দৃষ্টিতেও এখন i = 1.
  3. তৃতীয় round, i = 2. Cell-এ 2. তিনটি closure, একটি বাক্স; run-এর c0 is c1 = True ঠিক এটাই বলে।
  4. Loop শেষ, function ফিরে গেল। slots_buggy-এর frame মুছে গেছে, কিন্তু cell টিকে আছে, কারণ তিনটি closure তাকে ধরে আছে। তার শেষ মান 2 (run-এর “it holds 2”).
  5. λ0 ডাকা হলো। দেহ i * 10 এখন প্রথমবার i পড়ে: cell থেকে 2, ফল 20. “λ0 মানে i = 0” ধারণাটি ছিল আমাদের, ভাষার নয়।
  6. বাকি দুটি। λ1 আর λ2 একই cell পড়ে, একই 20. ফল [20, 20, 20].
  7. Factory দিয়ে সমাধান। make_slot(i) প্রতিবার একটি নতুন call, তাই নতুন frame আর তার parameter i-এর নতুন cell: 0, 1, 2. প্রতিটি g নিজের cell ধরে, ফল [0, 10, 20]. Capture এখনো by reference; বদলেছে শুধু variable-এর সংখ্যা।

JavaScript-এ var পুরো function-এ একটি variable দেয়। ES2015-এর for (let …)-এর জন্য মানদণ্ডে বিশেষ নিয়ম আছে: প্রতি round-এ loop variable-এর নতুন binding, আগের round-এর মান কপি করে (spec-এর CreatePerIterationEnvironment ধাপ)। একে বলা যায় per-iteration binding. কিন্তু একই round-এর ভেতরে capture এখনো by reference: নিচের run-এর দ্বিতীয় অংশ ঠিক এটি পরীক্ষা করে।

"use strict";
const withVar = [], withLet = [];
for (var i = 0; i < 3; i++) withVar.push(() => i * 10);   // one i (function scope)
for (let k = 0; k < 3; k++) withLet.push(() => k * 10);   // a new k each round
console.log("var:", JSON.stringify(withVar.map(f => f())));
console.log("let:", JSON.stringify(withLet.map(f => f())));

// Two closures made in the SAME round share that round's k
const pairs = [];
for (let k = 0; k < 3; k++) {
  pairs.push({ bump: () => ++k, peek: () => k });
}
pairs[0].bump();
pairs[0].bump();
console.log("after bumping round 0 twice:", JSON.stringify(pairs.map(p => p.peek())));

// A counter: the variable lives on after makeCounter has returned
function makeCounter(start) { let next = start; return () => ++next; }
const dhaka = makeCounter(100), ctg = makeCounter(500);
console.log("tokens:", dhaka(), dhaka(), ctg(), dhaka());

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

var: [30,30,30]
let: [0,10,20]
after bumping round 0 twice: [2,1,2]
tokens: 101 102 501 103

var-এর একটি i loop শেষে 3 (শর্ত i < 3 মিথ্যা হওয়ার মান), তাই 30, 30, 30; Python-এর 20 থেকে আলাদা, কারণ Python-এর range শেষ মান 2-তেই থামে। let-এ প্রতি round নিজের k পায়: 0, 10, 20. তৃতীয় লাইনটি সূক্ষ্ম: round 0-এর bump আর peek একই k ভাগ করে, তাই দুবার bump করার পর peek 2 দেখে; round 1 আর 2-এর k অক্ষত (1 আর 2). অর্থাৎ per-iteration binding capture-কে by value বানায় না; প্রতি round-এ শুধু একটি নতুন variable দেয়, ঠিক Python-এর factory function-এর মতো। শেষ লাইন JavaScript-এ একই টোকেন কাউন্টার: 101 102 501 103, Python আর Haat-এর সঙ্গে হুবহু। JavaScript-এর closure-এর ব্যবহারিক দিক আছে JavaScript কোর্সের পর্ব ২২-এ.

Haat কোন পথে? Reference বাস্তবায়নের নকশা-সিদ্ধান্ত ১৪ বলে, while-এর দেহ প্রতি round-এ একটি নতুন scope, তাই দেহের ভেতরে ঘোষিত let প্রতি round-এ নতুন variable; আর loop-এর বাইরের var একটিই। নিচের program দুটোই পরীক্ষা করে; first প্রথম round-এর closure, own শেষ round-এর:

// প্রতি round-এর let নতুন, কিন্তু বাইরের var একটিই
var i = 0;
var own = fn() -> Int { return 0 - 1; };
var shared = fn() -> Int { return 0 - 1; };
var first = fn() -> Int { return 0 - 1; };
while i < 3 {
    let j = i * 10;
    if i == 0 { first = fn() -> Int { return j; }; }
    own = fn() -> Int { return j; };
    shared = fn() -> Int { return i; };
    i = i + 1;
}
print(first());
print(own());
print(shared());
~/haat $ python haat.py run loop.haat
0
20
3
~/haat $ python haat.py vm loop.haat
0
20
3

প্রথম round-এর j = 0 চিরকাল 0 থাকে, কারণ পরের round-গুলো আলাদা j বানিয়েছে; শেষ round-এর j = 20. কিন্তু shared loop-এর বাইরের i ধরে, তাই loop শেষের 3 দেখে। python haat.py dis-এর আউটপুটে কারণটি পড়া যায়: loop-এর দেহে প্রতি round-এ MAKE_CELL 0 ; j চলে, অর্থাৎ প্রতি round-এ একটি নতুন বাক্স, আর first আর own-এর closure লেখা হয় MAKE_CLOSURE 6 ; <fn lambda@8:25> captures j. অথচ shared-এর দেহ হলো LOAD_GLOBAL 0 ; i: top-level variable global, তাকে ধরতে cell-ই লাগে না, সবাই সরাসরি global-এর একটি ঘর দেখে।

৫ · Funarg সমস্যা — function নিচে পাঠানো আর ওপরে ফেরত দেওয়া

“Funarg” মানে functional argument: যে function অন্য function-এ argument হিসেবে যায় বা ফেরত আসে। ইতিহাসের সারসংক্ষেপ পর্ব ০২-এ আছে: প্রথম দিকের LISP dynamic scope-এ free variable খুঁজত, ফলে পাঠানো function ভুল মান দেখত। MIT-র ১৯৭০ সালের একটি memo-তে (Joel Moses, “The Function of FUNCTION in LISP”) সমস্যাটির দুটি রূপ আলাদা করা হয়, যা আজও compiler-এর নকশায় সবচেয়ে কাজের ভাগ:

⬇️ Downward funarg

Function নিচের দিকে পাঠানো: map(f, xs)-এর মতো, f যে frame-এ জন্মেছে, সেটি f চলার পুরো সময় stack-এ আছে।

stack-এই চলে

⬆️ Upward funarg

Function ফেরত দেওয়া: make_counter-এর মতো, জন্মের frame মুছে যাওয়ার পরও closure চলে।

heap লাগে

Downward ক্ষেত্রে stack-এর নিয়ম রক্ষা পায়: f চলার পুরো সময় তার বাইরের frame নিচে নিরাপদ, তাই code pointer আর বাইরের frame-এর pointer দিলেই চলে, heap লাগে না। ALGOL 60 আর Pascal এই পথ নেয়: nested procedure-কে parameter হিসেবে পাঠানো যায়, কিন্তু Pascal-এ nested procedure-কে ফেরত দেওয়া বা variable-এ রাখা যায় না; ফলে upward সমস্যা ভাষার নিয়মেই নিষিদ্ধ। বাইরের frame খোঁজার কৌশল (static link বা display) আর activation record-এর বিন্যাস আসবে পর্ব ৩০-এ (Subprogram-এর বাস্তবায়ন)। C আরও কড়া: function nested হতেই পারে না, তাই function pointer-এর কোনো free variable নেই, আর পরিবেশ বয়ে নিতে হয় হাতে, একটি void * context দিয়ে (C কোর্সের পর্ব ২৮)।

Upward ক্ষেত্রে stack-এর নিয়ম ভাঙে। নিচের ছবিতে dhaka আর ctg তৈরির পরের অবস্থা: যে দুটি frame-এ next জন্মেছিল, সেগুলো নেই; তবু দুটি next বেঁচে আছে, heap-এ।

ছবি ১৭.১ — make_counter দুবার ফেরার পর: stack আর heap

Frame উধাও, cell টিকে আছে; প্রতিটি closure-এর নিজের cell.

After make_counter returned twice: the frames are gone, two closures on the heap each point to their own cell (103 and 501) call stack heap make_counter(100)ফিরে গেছে make_counter(500)ফিরে গেছে main frame dhakactg closure: dhaka code: lambda@4:12 cells[0] Cell · next = 103 closure: ctg code: lambda@4:12 cells[0] Cell · next = 501 frame নেই, কিন্তু cell বেঁচে আছে
ছবি ১৭.১ — দুটি make_counter call-এর frame (ডটেড) stack থেকে মুছে গেছে। দুটি closure একই code (lambda@4:12, Haat-এর disassembler-এর নাম) ভাগ করে, কিন্তু প্রত্যেকের cell আলাদা: dhaka তিনবার চলার পর 103, ctg একবার চলার পর 501. Cell-গুলো কতদিন বাঁচবে, তা আর stack ঠিক করে না; যতক্ষণ কোনো closure তাদের দিকে তাকিয়ে আছে, ততক্ষণ। সেই হিসাব রাখে garbage collector (পর্ব ৭৫)।

তাই upward funarg-এর দাম: ধরা variable-কে heap-এ তুলতে হয়, আর কখন ফেরত দেওয়া হবে, তা ঠিক করতে garbage collection লাগে (Python, JavaScript, Haat), বা প্রোগ্রামারকে কপি করে নিতে হয় (C++), বা compiler-কে lifetime প্রমাণ করতে হয় (Rust). Static, stack আর heap-এ রাখা variable-এর lifetime-এর পুরো ছক পর্ব ১৬-এ (Lifetime আর storage — static, stack আর heap).

Compiler এই দাম কমাতে পারে: বিশ্লেষণে যদি দেখা যায় closure কখনো জন্মের frame-এর বাইরে যায় না, তার environment stack-এই রাখা যায়। এর নাম escape analysis. Go-র compiler এভাবে ঠিক করে কোন variable heap-এ যাবে (-gcflags=-m সিদ্ধান্তগুলো দেখায়), আর Java-র HotSpot JIT object-এর জন্য একই ধরনের বিশ্লেষণ করে; বিশদ version-ভেদে আলাদা, তাই নিজের compiler-এর আউটপুট পড়ে নিশ্চিত হোন। Haat reference এই optimization করে না: ধরা প্রতিটি local সবসময় cell-এ যায়।

৬ · বাস্তবায়ন — cell, flat closure আর closure conversion

Closure বানাতে বাস্তবায়নকে তিনটি প্রশ্নের উত্তর দিতে হয়: (১) কোন variable ধরা হবে? (২) ধরা variable কোথায় থাকবে? (৩) closure-এর ভেতরে কী রাখা হবে? প্রথম প্রশ্নের উত্তর compile time-এ পাওয়া যায়, name resolution-এর সময়: প্রতিটি নাম-ব্যবহার কোন ঘোষণার, আর ঘোষণাটি বাইরের কোনো function-এর কি না। সংজ্ঞা ১৭.১-এর FV ঠিক এই হিসাব। Symbol table আর resolver-এর বাস্তবায়ন আসবে পর্ব ৫১-এ।

দ্বিতীয় প্রশ্নের উত্তর নির্ভর করে variable বদলায় কি না। ধরা variable কখনো assignment না পেলে (Haat-এর let, Java-র effectively final) মান কপি করলেই চলে (অনুশীলন ৪-এ প্রমাণ)। বদলানো যায় এমন হলে সবাইকে একই ঘর দেখতে হবে; তখন compiler তাকে এক-ঘরের বাক্সে (cell) রাখে, আর slot-এ রাখে বাক্সের ঠিকানা (assignment conversion বা boxing). ঠিকানা নিজে বদলায় না, তাই তার কপি নিরাপদ।

তৃতীয় প্রশ্নে দুটি প্রধান নকশা আছে:

নকশাClosure-এ কী থাকেলাভক্ষতি
Linked closurecode pointer + বাইরের পুরো environment frame-এর pointer (frame-গুলো শিকলে জোড়া)তৈরি করা সস্তা: একটি pointer কপিদূরের নাম পড়তে শিকল ধরে হাঁটা; পুরো frame বেঁচে থাকে, অদরকারি variable-ও
Flat closurecode pointer + শুধু free variable-গুলোর (বা তাদের cell-এর) একটি সমতল তালিকাপ্রতিটি পড়া এক ধাপে; শুধু দরকারি জিনিস বাঁচেতৈরির সময় প্রতিটি free variable কপি করতে হয়

অংশ ৩-এর ছোট interpreter-এর “ref” mode একটি linked closure (পুরো env-এর pointer). Haat VM আর CPython দুটিই flat closure ব্যবহার করে, প্রতিটি ঘরে একটি cell. Lua-র বাস্তবায়ন একটি চতুর মাঝামাঝি পথ নেয়: ধরা variable যতক্ষণ তার frame stack-এ আছে, closure-এর “upvalue” সরাসরি stack-এর সেই ঘরকে দেখায় (open upvalue); frame মুছে যাওয়ার মুহূর্তে মানটি upvalue-এর নিজের ভেতরে সরিয়ে নেওয়া হয় (closed upvalue). ফলে downward ব্যবহারে heap-এ কিছুই তৈরি হয় না। (বর্ণনাটি Ierusalimschy, de Figueiredo ও Celes-এর ২০০৫ সালের “The Implementation of Lua 5.0” প্রবন্ধ অনুসারে।)

সত্যিকারের CPython bytecode

অংশ ১-এর make_counter এই কম্পিউটারের CPython 3.14.4-এর dis module দিয়ে খুললে (সত্যিকারের run; code object-এর ঠিকানা আর ফাইলের path ছাঁটা হয়েছে):

~/haat $ python pydis.py
3.14.4
  --           MAKE_CELL                2 (nxt)

   4           RESUME                   0

   5           LOAD_FAST_BORROW         0 (start)
               STORE_DEREF              2 (nxt)

   6           LOAD_FAST_BORROW         2 (nxt)
               BUILD_TUPLE              1
               LOAD_CONST               0 (<code object tick …>)
               MAKE_FUNCTION
               SET_FUNCTION_ATTRIBUTE   8 (closure)
               STORE_FAST               1 (tick)

  10           LOAD_FAST_BORROW         1 (tick)
               RETURN_VALUE

Disassembly of <code object tick …>:
  --           COPY_FREE_VARS           1

   6           RESUME                   0

   8           LOAD_DEREF               0 (nxt)
               LOAD_SMALL_INT           1
               BINARY_OP                0 (+)
               STORE_DEREF              0 (nxt)

   9           LOAD_DEREF               0 (nxt)
               RETURN_VALUE

পড়ার উপায়: function শুরু হওয়ার আগেই MAKE_CELL 2 slot 2-এ একটি খালি cell বসায়। STORE_DEREF মানে “cell-এর ভেতরে লেখো”, LOAD_DEREF মানে “cell-এর ভেতর থেকে পড়ো” (deref = ঠিকানা ধরে ভেতরে যাওয়া)। Closure তৈরির সময় LOAD_FAST_BORROW 2 cell-এর ভেতরের মান নয়, cell নিজেকে তোলে; BUILD_TUPLE 1 তাকে একটি tuple বানায়, যা SET_FUNCTION_ATTRIBUTE 8 (closure) দিয়ে নতুন function-এর __closure__ হয়ে যায়। ভেতরের tick শুরুতে COPY_FREE_VARS 1 দিয়ে closure-এর cell নিজের frame-এ এনে রাখে, তারপর LOAD_DEREF/STORE_DEREF দিয়ে পড়ে-লেখে। Opcode-এর নাম CPython-এর version ভেদে বদলায়, তাই এই listing শুধু 3.14-এর; ধারণাটি বহু version ধরে একই। CPython-এর bytecode-এর বিস্তার পর্ব ৬০-এ (বাস্তব virtual machine).

Closure conversion আর lambda lifting

Native code-এর জগতে (C, assembly, LLVM IR) “free variable” বলে কিছু নেই; প্রতিটি function শুধু নিজের parameter আর global দেখে। তাই compiler closure conversion চালায়: প্রতিটি function একটি বাড়তি parameter পায় (environment record-এর pointer), free variable-এর প্রতিটি ব্যবহার হয় “env থেকে পড়া”, আর প্রতিটি closure হয় একটি record {code pointer, env}. এরপর সব function closed. টোকেন কাউন্টার এই রূপান্তরের পরে, C-তে (উদাহরণ, চালানো হয়নি):

struct cell    { long value; };                     /* the box for next  */
struct closure { long (*code)(struct cell **env);    /* code pointer      */
                 struct cell **env; };              /* flat list of cells */

long tick_code(struct cell **env) {                 /* tick, now closed  */
    env[0]->value = env[0]->value + 1;
    return env[0]->value;
}
/* calling a closure c:  c.code(c.env)                                    */

আরেকটি কৌশল lambda lifting (Thomas Johnsson, ১৯৮৫): free variable-গুলোকে সরাসরি parameter বানিয়ে nested function-কে top level-এ তুলে আনা, আর প্রতিটি call-এ সেগুলো argument হিসেবে পাঠানো। এতে কোনো heap record লাগে না, কিন্তু চলে শুধু যখন function-কে মান হিসেবে বাইরে পাঠানো হয় না, আর ধরা variable বদলায় না। বাস্তব compiler দুটি মিশিয়ে ব্যবহার করে। Haat-এ এসব বানাবেন পর্ব ৫৭ আর ৫৯-এ (Stack-based virtual machine).

৭ · Haat-এর closure — reference বাস্তবায়নের cell, VM-এর ভেতরে

Haat spec v1 বলে: function first-class, আর closure বাইরের variable “by reference (shared environment)” ধরে। Reference বাস্তবায়ন এটি করে cell দিয়ে, আর তার disassembler পুরো সিদ্ধান্তটি দেখিয়ে দেয়। অংশ ২-এর টোকেন কাউন্টার এবার পুরো ফাইল হিসেবে:

// বাজারঘর: প্রতিটি কাউন্টারের নিজের টোকেন নম্বর
fn make_counter(start: Int) -> () -> Int {
    var next = start;
    return fn() -> Int {
        next = next + 1;
        return next;
    };
}
let dhaka = make_counter(100);
let ctg = make_counter(500);
print(dhaka());
print(dhaka());
print(ctg());
print(dhaka());

সত্যিকারের run, কোর্সের Haat reference বাস্তবায়নে (CPython 3.14.4); check সব type মিলিয়ে ok বলে, interpreter আর VM হুবহু একই আউটপুট দেয়, আর dis-এর দুটি function-এর listing (<main> অংশ বাদ):

~/haat $ python haat.py check token.haat
ok
~/haat $ python haat.py run token.haat
101
102
501
103
~/haat $ python haat.py vm token.haat
101
102
501
103
~/haat $ python haat.py dis token.haat
…
== make_counter (arity 1, locals 2) ==
   0  LOAD_LOCAL     0     ; start
   1  MAKE_CELL      1     ; next
   2  MAKE_CLOSURE   0     ; <fn lambda@4:12> captures next
   3  RETURN

== lambda@4:12 (arity 0, locals 0) ==
   0  LOAD_FREE      0     ; next
   1  CONST          0     ; 1
   2  ADD
   3  STORE_FREE     0     ; next
   4  LOAD_FREE      0     ; next
   5  RETURN

লক্ষ করুন start ধরা হয়নি (ভেতরের function তাকে ব্যবহার করে না), তাই সে সাধারণ slot 0-এ থাকে; শুধু next cell পায়। এটিই flat closure: FV(ভেতরের function) = {next}, আর closure-এ ঠিক একটি cell. CPython-এর সঙ্গে মিলিয়ে দেখুন: MAKE_CELL ↔ MAKE_CELL/STORE_DEREF, LOAD_FREE/STORE_FREE ↔ LOAD_DEREF/STORE_DEREF, MAKE_CLOSURE ↔ BUILD_TUPLE + MAKE_FUNCTION. এবার VM-এর ভেতরে, একটি একটি নির্দেশ করে: প্রথমে make_counter(100), তারপর প্রথম dhaka(). প্রতিটি ধাপের stack আর slot reference VM-এর একটি trace-করা কপি থেকে নেওয়া।

1make_counter: LOAD_LOCAL 0 ; start2  MAKE_CELL 1 ; next3  MAKE_CLOSURE 0 ; captures next4  RETURN5lambda: LOAD_FREE 0 ; next6  CONST 0 ; 17  ADD8  STORE_FREE 0 ; next9  LOAD_FREE 0 ; next10  RETURN
এই ধাপে
operand stack
make_counter-এর slot
Cell (next)
  1. LOAD_LOCAL 0. make_counter(100)-এর frame-এ slot 0 = start = 100, slot 1 এখনো খালি। Slot 0-এর মান operand stack-এ ওঠে: [100].
  2. MAKE_CELL 1. Stack থেকে 100 নামিয়ে একটি নতুন Cell(100) বানানো হয়, আর slot 1-এ রাখা হয় সেই cell. var next = start; এভাবেই compile হয়েছে, কারণ resolver আগেই next-কে “captured” চিহ্ন দিয়েছে।
  3. MAKE_CLOSURE 0. Constant 0 হলো ভেতরের function-এর Code object. তার captures তালিকা বলে “parent-এর slot 1”, তাই VM slot 1-এর cell-এর reference নতুন closure-এর cells-এ কপি করে। Stack-এ এখন closure D.
  4. RETURN. make_counter-এর frame মুছে যায়; D stack-এ caller-এর জন্য থাকে, আর main তাকে dhaka নামে রাখে। Cell(100)-কে এখন শুধু D চেনে। (ctg-এর জন্য একই চার নির্দেশ আরেকবার চলে, নতুন Cell(500) নিয়ে।)
  5. dhaka(): LOAD_FREE 0. নতুন frame, কোনো local নেই। “Free 0” মানে closure-এর cells[0]: তার ভেতরের মান 100 stack-এ ওঠে।
  6. CONST 0. ভেতরের function-এর constant 0 হলো 1. Stack: [100, 1].
  7. ADD. দুটি নামিয়ে যোগফল তোলে: [101]. Haat-এর Int ৬৪-বিটে wrap করে, এখানে তার দরকার পড়েনি।
  8. STORE_FREE 0. 101 নামিয়ে cells[0]-এর ভেতরে লেখে। Cell-টি একই বস্তু, তাই এখন যে-ই এই cell দেখবে, সে 101 দেখবে: এটিই capture by reference.
  9. LOAD_FREE 0. return next;-এর জন্য cell থেকে আবার পড়া: [101].
  10. RETURN. Frame মুছে যায়, 101 caller-এর জন্য stack-এ থাকে, আর main-এর PRINT সেটি ছাপে: 101. পরের dhaka() একই cell থেকে 101 পড়ে 102 দেবে।

Reference বাস্তবায়নের README আরও তিনটি ক্ষেত্রের কথা বলে। (১) ধরা parameter function শুরুতেই cell-এ সরানো হয় (LOAD_LOCAL s; MAKE_CELL s). (২) একটি closure-এর ভেতরের closure যদি দাদার variable ধরে, তবে মাঝের closure-ও সেটি নিজের free cell হিসেবে বয়ে নেয়: captures-এর এন্ট্রি (False, i) মানে “parent-এর নিজের free cell i”. (৩) নিজেকে ডাকে এমন nested function-এর cell closure তৈরির আগে বানানো হয় (CONST (); MAKE_CELL s; MAKE_CLOSURE k; STORE_CELL s), যাতে function নিজের cell ধরে নিজেকে ডাকতে পারে (Scheme-এর letrec-এর মতো)।

৮ · Closure-এর ব্যবহার, object-এর সঙ্গে সম্পর্ক আর লুকানো খরচ

Closure দিয়ে object বানানো (গোপন অবস্থা + বার্তা) Haat-এ চালিয়ে দেখেছেন পর্ব ০৮-এ; উল্টো দিক থেকে, C++-এর lambda আসলে একটি নামহীন class-এর object, যার field হলো ধরা variable আর operator() হলো দেহ (উপরের run-এ sizeof সেটিই দেখিয়েছে)। Closure conversion-এর record আর object-এর field একই জিনিস। তাই প্রশ্নটি “closure না object” নয়, বরং কোন রূপে লেখা পরিষ্কার। প্রতিদিনের কোডে closure আসে এই রূপে:

  • Callback আর event handler: অর্ডার এলে চলার মতো function, যা নিজের প্রসঙ্গ (কোন কাউন্টার, কোন গ্রাহক) মনে রাখে।
  • Partial application আর configuration: policy(10, 1000)-এর মতো নিয়ম একবার বসিয়ে বারবার ব্যবহার (পর্ব ০৯-এর currying).
  • Memoization আর lazy মান: একটি cache dictionary ধরে রাখা function; বা একবার হিসাব করে মনে রাখা thunk, যা পর্ব ১৯-এর (Evaluation strategy) call-by-need-এর ভিত্তি।
  • গোপনীয়তা আর module: JavaScript-এ ES module আসার আগে IIFE-র ভেতরের closure দিয়ে private নাম রাখা হতো (পর্ব ১৮-এর বিষয়)।

এবার খরচ। প্রতিটি closure সাধারণত heap-এ একটি নতুন object, তাই গরম loop-এ হাজারো closure GC-র চাপ বাড়ায়, যদি না compiler inlining বা escape analysis দিয়ে সেগুলো সরায় (পর্ব ৬৭); আর closure call একটি indirect call. সবচেয়ে বিপজ্জনক memory leak: closure যতক্ষণ বেঁচে আছে, তার ধরা সবকিছুও বেঁচে থাকে। একটি event handler যদি অজান্তে একটি বড় অর্ডারের তালিকা ধরে রাখে, আর handler কখনো সরানো না হয়, তালিকাও কখনো মুক্ত হয় না।

Linked closure-এর লুকানো ফাঁদ: কিছু বাস্তবায়নে একই scope-এ তৈরি সব closure একটি environment object ভাগ করে। তখন একটি closure কোনো বড় variable ব্যবহার না করলেও, পাশের আরেকটি closure সেটি ব্যবহার করলে, দুজনেই পুরো environment বাঁচিয়ে রাখে। JavaScript engine-এ এমন leak-এর কথা অনেকবার লেখা হয়েছে; কোন engine-এর কোন version এখন কী করে, তা নিশ্চিত হতে browser-এর memory profiler-এ heap snapshot নিয়ে দেখুন। Flat closure (শুধু FV ধরা) এই সমস্যা কমায়; গবেষণায় এই গুণকে বলে “safe for space”.

আরও গভীরে: Closure-কে সম্পূর্ণ সরিয়ে দেওয়ার একটি সুন্দর কৌশল আছে: defunctionalization (John Reynolds, ১৯৭২)। Program-এ যত রকম closure তৈরি হয়, প্রতিটিকে একটি data constructor বানানো হয় (ধরা variable-গুলো তার field), আর একটি মাত্র apply function constructor দেখে ঠিক কোন দেহ চলবে তা বেছে নেয়। ফলে higher-order program first-order হয়ে যায়: কোনো function pointer নেই, শুধু data আর একটি বড় switch. কিছু whole-program compiler (যেমন MLton, Standard ML-এর জন্য) এই ধরনের রূপান্তর ব্যবহার করে বলে জানা যায়; আর ধারণাটি দেখায়, closure আর “ডেটা + একটি interpreter” একই জিনিসের দুই রূপ।

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

  • Closure কী? একটি function আর তার তৈরির সময়ের environment-এর জোড়া; free variable খোঁজা হয় জন্মস্থানের environment-এ।
  • Free আর bound variable-এর পার্থক্য? Bound নাম function বা block-এর ভেতরেই ঘোষিত (parameter, local); free নাম বাইরে থেকে আসে। λx. x + y-তে x bound, y free.
  • Python-এ [lambda: i for i in range(3)] ডাকলে সব 2 কেন? তিনটি lambda একই variable i (একই cell) ধরে; ডাকার সময় তার মান 2. সমাধান: lambda i=i: i বা factory function.
  • Upward আর downward funarg কী? Downward: function argument হিসেবে নিচে যায়, environment stack-এ থাকতে পারে। Upward: function ফেরত আসে, environment-কে frame-এর চেয়ে বেশি বাঁচতে হয়, তাই heap আর GC.
  • C++-এ [=] আর [&]-এর পার্থক্য? [=] তৈরির মুহূর্তে কপি নেয়; [&] variable-এর reference নেয়, যা function ফেরার পর dangling হতে পারে।

৯ · AI-এর যুগে closure — দাবি যাচাইয়ের অভ্যাস

Closure-এর নিয়ম ভাষাভেদে আলাদা, তাই AI assistant প্রায়ই এক ভাষার নিয়ম আরেকটিতে চাপিয়ে আত্মবিশ্বাসী কিন্তু আংশিক ভুল উত্তর দেয়। বারবার দেখা ভুল:

AI-এর ভুলকীভাবে ধরবেন
“Closure তৈরির সময়ের মান মনে রাখে” বলা, সব ভাষার জন্যতৈরির পরে variable বদলে closure ডাকুন; Python/JavaScript/Haat-এ নতুন মান আসে, C++ [=] আর Java-য় আসে না
Loop-এর ফাঁদের সমাধানে let-কে “by value capture” বলাএকই round-এ দুটি closure বানিয়ে একটি দিয়ে বদলান, অন্যটি দিয়ে পড়ুন (উপরের [2,1,2] run)
C++-এ [&] দিয়ে local ধরে closure ফেরত দেওয়া কোড, আর “এটি চলছে” বলে নিশ্চয়তাLifetime নিজে হিসাব করুন; -Wall -Wextra, AddressSanitizer চালান; warning না এলেও UB থাকতে পারে
Java-য় lambda-র ভেতরে local বদলানোর কোড, যা compile-ই হয় নাjavac-এ compile করে দেখুন; effectively final নিয়ম মিলিয়ে নিন
Bytecode বা opcode-এর নাম বানিয়ে বলা, বা পুরোনো CPython version-এর নাম দেওয়ানিজের version-এ dis চালিয়ে আসল listing পড়ুন
“Closure-এ memory leak হয় না, GC আছে” বলাকোন জিনিস closure-এর কাছে পৌঁছানো যায় তা হিসাব করুন; heap snapshot নিন

AI-কে ভালোভাবে কাজে লাগানোর উপায়: শুধু উত্তর নয়, কোন ভাষা আর version-এর নিয়ম তা জিজ্ঞেস করা, আর যাচাইয়ের run চাওয়া।

আমি closure-এর capture semantics শিখছি। নিচের প্রশ্নগুলোর উত্তর দাও, প্রতিটিতে ভাষা আর version উল্লেখ করে: ১. Python 3.14, JavaScript (ES2015+), C++20 আর Java 21-এ closure variable ধরে নাকি মান ধরে? প্রতিটির জন্য একটি ছোট program লেখো, যেখানে closure তৈরির পরে variable বদলানো হয় আর তারপর closure ডাকা হয়। ২. প্রতিটি program-এর আউটপুট কী হবে বলে তুমি মনে করো, আলাদা করে লেখো। আমি নিজে চালিয়ে মেলাব, তাই অনুমানকে "অনুমান" বলে চিহ্নিত করো। ৩. C++-এ [&] দিয়ে local ধরে closure ফেরত দিলে কী হয়? কোনো আউটপুট নিশ্চিত বলে দাবি করবে না; undefined behavior হলে স্পষ্ট বলো। ৪. JavaScript-এর for (let ...) loop-এ প্রতি round-এ নতুন binding হয় — এটি কি capture by value? একটি পরীক্ষা লেখো যা উত্তরটি প্রমাণ করে। ৫. যেখানে তুমি নিশ্চিত নও (যেমন কোনো engine-এর ভেতরের optimization), সেখানে স্পষ্ট বলো আর কোথায় যাচাই করা যায় তা জানাও।

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

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

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

প্র ০১১৯৭০ সালে LISP-এর জগতে funarg সমস্যাকে “upward” আর “downward” দুই ভাগে ভাগ করা কেন এত কাজের হলো?

প্রথম দিকের LISP বাস্তবায়নে variable-এর মান খোঁজা হতো একটি association list ধরে, যেখানে সবচেয়ে সাম্প্রতিক binding আগে থাকে; অর্থাৎ কার্যত dynamic scope. কিন্তু LISP-এ function মান হিসেবে পাঠানো যেত (mapcar-এর মতো), আর তখন পাঠানো function-এর free variable খোঁজা হতো যেখানে সে চলছে সেখানে, যেখানে লেখা হয়েছে সেখানে নয়। LISP-এ এর প্রতিকার হিসেবে FUNCTION নামের বিশেষ form ছিল, যা function-এর সঙ্গে তার পরিবেশ বেঁধে দিত।

Joel Moses-এর ১৯৭০ সালের MIT memo “The Function of FUNCTION in LISP” সমস্যাটিকে স্পষ্ট ভাষায় বর্ণনা করে, আর দুটি ক্ষেত্র আলাদা করে দেখায়। Function যখন নিচের দিকে, অর্থাৎ argument হিসেবে কোনো ডাকা function-এ যায়, তখন তার জন্মের পরিবেশ stack-এ নিরাপদ থাকে, কারণ ডাকা function শেষ না হওয়া পর্যন্ত কেউ ফেরে না। Function যখন ওপরের দিকে, অর্থাৎ ফেরত মান হিসেবে বেরিয়ে যায়, তখন তার জন্মের frame মুছে যেতে পারে, অথচ function-এর তখনো সেই পরিবেশ দরকার।

ভাগটির ব্যবহারিক মূল্য বিশাল: এটি বলে দেয় কোন ভাষার কতটুকু runtime লাগবে। শুধু downward funarg চাইলে stack আর একটি static link যথেষ্ট; ALGOL 60 আর Pascal এই পথে গেছে, আর C সমস্যাটি এড়িয়েছে nested function একেবারে নিষেধ করে। Upward funarg চাইলে পরিবেশকে heap-এ রাখতে হয়, আর তখন garbage collection প্রায় অবধারিত। Scheme (১৯৭৫) সেই দাম দিয়েছে, আর পুরো lexical closure পেয়েছে; আজকের JavaScript আর Python সেই উত্তরাধিকার বহন করে।

আজকের optimizing compiler-ও একই ভাগ ব্যবহার করে: escape analysis আসলে প্রতিটি closure সম্পর্কে একই প্রশ্ন করে: সে কি শুধু নিচে যায়, নাকি ওপরে পালায়? শুধু নিচে গেলে stack-এ রাখা যায়।

মূল উপলব্ধি: একটি ভাষা-বৈশিষ্ট্যের দাম বুঝতে হলে তার সবচেয়ে কঠিন ব্যবহারটি খুঁজে আলাদা করুন। Function ফেরত দেওয়ার ক্ষমতাই stack থেকে heap-এ যাওয়ার কারণ, আর সেখান থেকেই GC-র প্রয়োজন।

প্র ০২C# আর Go loop variable-এর নিয়ম বদলে “ভাঙা” পরিবর্তন করল, অথচ Python করেনি। কেন?

Loop-এর closure-এর ফাঁদ এতটাই সাধারণ যে দুটি বড় ভাষা পুরোনো কোডের আচরণ বদলানোর ঝুঁকি নিয়েও নিয়ম পাল্টেছে। C#-এ foreach-এর loop variable আগে পুরো loop-এ একটিই ছিল; ফলে loop-এ বানানো সব lambda শেষ মান দেখত। Microsoft-এর C# compiler দলের Eric Lippert ২০০৯ সালে “Closing over the loop variable considered harmful” নামে লেখায় সমস্যাটি ব্যাখ্যা করেন, আর C# 5 (২০১২)-এ foreach-এর variable প্রতি round-এ নতুন করা হয়। সাধারণ for loop-এর নিয়ম অবশ্য বদলানো হয়নি।

Go-তে একই ফাঁদ ছিল আরও বিপজ্জনক, কারণ loop-এর ভেতরে goroutine চালানো খুব প্রচলিত, আর সব goroutine একই variable দেখত। Go 1.22 (২০২৪ সালের শুরু)-এ for loop-এর variable প্রতি round-এ নতুন করা হয়। Go দল পরিবর্তনটি নিরাপদ করতে module-এর ঘোষিত Go version দেখে নতুন নিয়ম প্রয়োগ করে, যাতে পুরোনো module পুরোনো আচরণই পায়।

Python বদলায়নি, আর তার কারণ ভাষার কাঠামোয়। Python-এ for কোনো নতুন scope বানায় না; loop variable loop শেষেও function-এর local হিসেবে টিকে থাকে, আর অনেক কোড সেই শেষ মান ব্যবহার করে। প্রতি round-এ নতুন variable দিতে হলে loop-কে নিজস্ব scope দিতে হতো, যা Python-এর “function-ই scope-এর একক” নীতির বিরুদ্ধে যায়। তাই Python-এর পথ হলো documentation, linter-এর সতর্কতা আর default argument বা factory-র মতো স্পষ্ট কৌশল।

JavaScript-এর গল্প দুটির মাঝামাঝি: পুরোনো var-এর আচরণ বদলানো যেত না (ওয়েবের পুরোনো কোড ভাঙত), তাই ES2015 একটি নতুন keyword let এনে নতুন নিয়ম দিয়েছে, পুরোনোটি অক্ষত রেখে।

মূল উপলব্ধি: Capture semantics একই থাকলেও (সবাই by reference), loop কতগুলো variable বানায় সেই ছোট সিদ্ধান্ত ফলাফল বদলে দেয়। আর একটি জনপ্রিয় ভাষার নিয়ম বদলানো শুধু প্রযুক্তিগত প্রশ্ন নয়; পুরোনো কোড, version চিহ্ন আর ধীরে ধীরে পরিবর্তনের কৌশলও নকশার অংশ।

প্র ০৩Java কেন “effectively final” বেছে নিল, আর C++ কেন প্রোগ্রামারকে capture list লিখতে বাধ্য করে?

দুই ভাষার সিদ্ধান্তই এসেছে একটি কঠিন বাস্তবতা থেকে: local variable থাকে stack frame-এ, আর frame ফেরার সঙ্গে সঙ্গে মুছে যায়। Java-য় anonymous inner class (Java 1.1, ১৯৯৭) যখন এল, তখন সেগুলো method শেষ হওয়ার পরও বাঁচতে পারত। Local-এর reference দিতে হলে তাকে heap-এ তুলতে হতো, অথচ JVM-এ local থাকে frame-এ। সহজ সমাধান: মান কপি করে ভেতরের object-এর একটি লুকানো field-এ রাখা। কিন্তু কপি আর আসল আলাদা হয়ে গেলে প্রোগ্রামার বিভ্রান্ত হবেন, তাই নিয়ম করা হলো, ধরা variable অবশ্যই final. Java 8 (২০১৪)-এ lambda আসার সময় নিয়মটি নরম করা হয়: final লিখতে হবে না, শুধু কখনো নতুন মান না পেলেই চলবে (effectively final). ফলে Java-র capture আসলে by value, কিন্তু ভাষা এমনভাবে সাজানো যে কেউ পার্থক্য দেখতে পায় না। বাড়তি লাভ: অন্য thread-এ চলা lambda-র কপিতে data race হয় না।

C++-এর পরিস্থিতি আরও কঠিন, কারণ সেখানে garbage collector নেই, আর ভাষার মূলনীতি হলো “যা ব্যবহার করেন না, তার দাম দেন না”। Compiler নিজে থেকে variable heap-এ তুললে লুকানো খরচ আর lifetime-এর প্রশ্ন আসত। তাই C++11 (২০১১) সিদ্ধান্তটি প্রোগ্রামারের হাতে দিয়েছে: [=], [&], বা প্রতিটি নাম আলাদা করে। নিয়ন্ত্রণ পূর্ণ, ভুলের সুযোগও: [&] দিয়ে local ধরে closure ফেরত দেওয়া dangling reference তৈরি করে, আর এই পর্বের run দেখিয়েছে std::function-এ মোড়ালে Clang সতর্কও করেনি। পরে C++14-এর init-capture ([x = std::move(y)]) মালিকানা closure-এ সরানোর পথ দেয়, আর C++20 [=]-এর মাধ্যমে this-কে অন্তর্নিহিতভাবে ধরা deprecated করে, কারণ সেটি আসলে একটি pointer-এর কপি, object-এর নয়: একটি সূক্ষ্ম dangling-এর উৎস।

Rust-এর তৃতীয় পথ: borrow checker compile time-এ প্রমাণ চায় যে closure ধরা variable-এর চেয়ে বেশি বাঁচবে না, নয়তো move দিয়ে মালিকানা closure-এ দিতে হয় (পর্ব ৭৬)।

মূল উপলব্ধি: Capture-এর নিয়ম আসলে memory management-এর নীতির প্রতিফলন। GC থাকলে by reference সস্তা আর স্বাভাবিক; GC না থাকলে ভাষাকে হয় কপি চাপাতে হয়, নয় প্রোগ্রামার বা compiler-কে lifetime প্রমাণের দায় দিতে হয়।

প্র ০৪Flat আর linked closure-এর মধ্যে বেছে নেওয়া কেন শুধু গতির নয়, memory-র নিরাপত্তারও প্রশ্ন?

প্রথম দেখায় পছন্দটি গতির: linked closure তৈরি করা সস্তা (শুধু environment-এর একটি pointer), কিন্তু গভীর nesting-এ দূরের variable পড়তে শিকল ধরে কয়েক ধাপ হাঁটতে হয়। Flat closure তৈরিতে প্রতিটি free variable কপি করতে হয়, কিন্তু প্রতিটি পড়া এক ধাপ।

কিন্তু garbage collector-এর চোখে আরও বড় একটি পার্থক্য আছে। GC একটি object মুক্ত করে শুধু তখন, যখন তাকে আর কোনো পথে পৌঁছানো যায় না। Linked closure পুরো frame-এর pointer রাখে, তাই closure যতক্ষণ বাঁচে, frame-এর সব variable বাঁচে, closure তাদের কয়েকটি ব্যবহার করুক বা না করুক। ধরুন একটি function একটি দশ লাখ অর্ডারের তালিকা পড়ে, তার একটি সারাংশ বানায়, আর একটি ছোট callback ফেরত দেয় যা শুধু সারাংশ ব্যবহার করে। Linked বাস্তবায়নে callback-টি অজান্তে পুরো তালিকাও বাঁচিয়ে রাখে।

এই সমস্যার একটি নাম আছে: বাস্তবায়নটি “safe for space” কি না। Andrew Appel-এর SML/NJ compiler নিয়ে কাজ (১৯৯০-এর দশক, যেমন Shao ও Appel-এর closure-এর বিন্যাস নিয়ে গবেষণা) দেখায়, flat ধরনের closure যেখানে শুধু free variable রাখা হয়, সেখানে এই নিশ্চয়তা দেওয়া যায়। Lua-র open/closed upvalue আরেকটি সমাধান: frame stack-এ থাকা পর্যন্ত upvalue stack-এর ঘর দেখায়, frame মুছে গেলে শুধু সেই একটি মান সরিয়ে নেয়, পুরো frame নয়।

বাস্তবের engine-গুলো প্রায়ই মাঝামাঝি পথ নেয়। যেমন JavaScript engine-এ একই scope-এর কয়েকটি closure একটি context object ভাগ করতে পারে, তাতে তৈরি সস্তা হয়, কিন্তু অংশ ৮-এর সতর্কবার্তার মতো leak-এর ঝুঁকি থাকে। এর বিশদ engine আর version ভেদে বদলায়, তাই নির্দিষ্ট দাবির আগে profiler-এ মেপে দেখাই নিরাপদ।

মূল উপলব্ধি: বাস্তবায়নের একটি সিদ্ধান্ত ভাষার দৃশ্যমান আচরণ (কোন মান ছাপা হয়) বদলায় না, কিন্তু program-এর memory-র ব্যবহার বদলে দিতে পারে। “Semantics একই” আর “খরচ একই” দুটি আলাদা দাবি।

প্র ০৫“Closure গরিবের object, আর object গরিবের closure” — এই পুরোনো কথাটি কতটা সত্য, আর compiler-এর চোখে এর মানে কী?

কথাটি programming ভাষার সম্প্রদায়ে একটি পুরোনো রসিকতা হিসেবে ঘোরে; সাধারণত Scheme-চর্চাকারী Anton van Straaten-এর একটি গল্পের সঙ্গে যুক্ত করা হয়, যেখানে শিক্ষক আর শিষ্য দুজনেই শেষে বোঝেন যে দুটি ধারণা পরস্পরকে দিয়ে প্রকাশ করা যায়। উৎস নিয়ে নিশ্চিত হওয়া কঠিন, তবে ধারণাটি ঠিক।

এক দিক থেকে: একটি closure হলো code + ধরা variable. একটি object হলো method + field. শুধু একটি method-ওয়ালা object আর একটি closure প্রায় হুবহু একই জিনিস; এজন্যই Java-র functional interface (একটি abstract method-ওয়ালা interface) lambda-কে object হিসেবে প্রকাশ করতে পারে, আর C++-এর lambda আসলে operator()-ওয়ালা একটি নামহীন class. উল্টো দিক থেকে: পর্ব ০৮-এ Haat-এ class ছাড়াই closure দিয়ে cart object বানিয়েছেন, যেখানে “বার্তা” একটি সংখ্যা আর গোপন অবস্থা ধরা variable. SICP বইয়ের bank account উদাহরণও এভাবেই বানানো।

Compiler-এর চোখে দুটি ধারণা একই জায়গায় গিয়ে মেলে। Closure conversion প্রতিটি closure-কে একটি record (ধরা variable) + code pointer বানায়; OOP-এর compiler প্রতিটি object-কে একটি record (field) + vtable pointer বানায়। Defunctionalization (Reynolds, ১৯৭২) আরও এক ধাপ যায়: সব closure-কে data বানিয়ে একটি apply function দিয়ে চালায়, যা অনেকটা “একটি বড় switch দিয়ে dynamic dispatch”-এর মতো।

তবু ভাষার স্তরে পার্থক্যগুলো বাস্তব। Object-এ পরিচয় (identity), একাধিক method, inheritance আর reflection থাকে; closure-এ সাধারণত একটি মাত্র প্রবেশপথ আর সম্পূর্ণ গোপনীয়তা (ধরা variable-এ বাইরে থেকে পৌঁছানোর নিয়মিত উপায় নেই, যদিও CPython-এর cell_contents দেখিয়েছে debugging-এর জন্য দরজা খোলা থাকতে পারে)। কোনটি লিখবেন, তা পরিষ্কারতার প্রশ্ন: একটি আচরণ আর কয়েকটি মান হলে closure, অনেক আচরণ আর বড় অবস্থা হলে class.

মূল উপলব্ধি: ভাষার বৈশিষ্ট্যগুলো প্রায়ই একটি অন্যটিকে দিয়ে বানানো যায়; compiler ঠিক এই সত্যটি ব্যবহার করে বড় ভাষাকে ছোট core-এ নামায়। পার্থক্য থাকে প্রকাশের সুবিধায় আর ভুল ধরার নিশ্চয়তায়, ক্ষমতায় নয়।

অনুশীলন

প্রথমে নিজে করুন, তারপর উত্তর খুলে মেলান। Haat-এর প্রতিটি আউটপুট কোর্সের reference বাস্তবায়নে, Python-এর আউটপুট CPython 3.14-এ আর C++-এর বার্তা Clang 22.1.8-এ চালিয়ে মেলানো।

  1. বাস্তবায়ন — শুধু free variable ধরা: অংশ ৩-এর ছোট interpreter-এর “copy” mode তৈরির মুহূর্তের সব দৃশ্যমান নাম কপি করে (flat()), দরকার থাকুক বা না থাকুক। (ক) একটি function fv(e) লিখুন, যা সংজ্ঞা ১৭.১ মেনে tuple-AST-এর free variable-এর সেট দেয় (ধরে নিন function-দেহে "var" নেই)। (খ) "fn"-এর লাইন বদলে copy mode-কে flat closure বানান, যা শুধু FV ধরে। (গ) fn(y) { fn(x) { x + (y + z) } }-এর FV কত? দুটি program-এর আউটপুট কি বদলাবে?
    def fv(e):
        op, *a = e
        if op == "num": return set()
        if op == "get": return {a[0]}
        if op == "fn": return fv(a[1]) - set(a[0])     # body minus parameters
        if op == "var": return fv(a[1])                # declaring is not using
        if op == "set": return {a[0]} | fv(a[1])       # assigning uses the name
        out = set()
        for x in a:                                    # add, do, call: union
            if isinstance(x, tuple): out |= fv(x)
        return out
    
    # in ev(): the "fn" line becomes
            return Closure(a[0], a[1], env if mode == "ref"
                           else Env({n: env.where(n).names[n] for n in fv(e)}))

    CPython 3.14-এ চালানো ফল: fv দিলে f-এর জন্য ['bonus'], add-এর জন্য ['total'], আর (গ)-এর nested function-এর জন্য ['z']: ভেতরের function-এর FV {x, y, z} থেকে x বাদ, বাইরেরটি থেকে y বাদ। দুই program-এর আউটপুট হুবহু একই থাকে (ref: 51 আর 1220; copy: 6 আর 0), কারণ program শুধু free variable-ই পড়ে; বদলায় শুধু closure-এর আকার। Environment-এ দশ লাখ উপাদানের একটি big list রেখে f বানালে নতুন closure-এর env-এ শুধু {'bonus': 5} থাকে, big নয়: প্র ০৪-এর “safe for space”. set-এর নিয়মটি লক্ষ করুন: assignment-এর লক্ষ্যও free variable, কারণ closure-কে সেই ঘরটি খুঁজে পেতে হবে।

  2. ভুল খুঁজুন: একজন সহকর্মী C++20-এ লিখেছেন: std::function<int()> make_bad(int start) { int next = start; return [&]() { next = next + 1; return next; }; }, আর বলছেন, “Clang -Wall -Wextra-এ কোনো warning দেয়নি, আমার যন্ত্রে চালিয়েও ঠিক উত্তর পেয়েছি, তাই কোড ঠিক”। ভুলটি কোথায়? Return type auto হলে কী বদলায়? দুটি নিরাপদ সমাধান দিন।

    [&] next-কে reference হিসেবে ধরে, কিন্তু next make_bad-এর stack frame-এর local; function ফেরার সঙ্গে সঙ্গে তার lifetime শেষ। ফেরত দেওয়া closure তাই একটি dangling reference বয়ে বেড়ায়, আর তাকে ডাকা undefined behavior. “চালিয়ে ঠিক উত্তর পেয়েছি” প্রমাণ নয়: UB-তে আজ ঠিক দেখানো আর কাল ভুল দেখানো দুটিই বৈধ। “Warning আসেনি”-ও প্রমাণ নয়: এই পর্বের lab-এ Clang 22.1.8 হুবহু এই কোডে কোনো warning দেয়নি, কারণ lambda std::function-এর ভেতরে মোড়ানো, আর compiler সেই মোড়কের ভেতর দিয়ে lifetime অনুসরণ করেনি। Return type auto করলে lambda সরাসরি ফেরে, আর তখন Clang সতর্ক করে: warning: address of stack memory associated with local variable 'next' returned [-Wreturn-stack-address], সঙ্গে নোট “implicitly captured by reference due to use here”. সমাধান (১): কপি ধরুন আর তা বদলানোর অনুমতি দিন: return [=]() mutable { next = next + 1; return next; }; (অংশ ৩-এর run-এ 101, 102). সমাধান (২): অবস্থা heap-এ রাখুন আর ভাগ করা মালিকানা দিন: auto p = std::make_shared<int>(start); return [p]() { return ++*p; };. দ্বিতীয়টি Python-এর cell-এর C++ রূপ: closure কপি করলেও সব কপি একই বাক্স দেখে। AddressSanitizer (-fsanitize=address) দিয়ে test চালানো এমন ভুল প্রায়ই ধরে।

  3. আউটপুট অনুমান করুন: নিচের Haat program কী ছাপবে? কোন variable cell পাবে, আর pay আর refund কি একই cell ভাগ করে?
    fn make_wallet(start: Int) -> (Int) -> Int {
        var balance = start;
        let pay = fn(x: Int) -> Int { balance = balance - x; return balance; };
        let refund = fn(x: Int) -> Int { balance = balance + x; return balance; };
        print(refund(40));
        return pay;
    }
    let w = make_wallet(1000);
    print(w(300));
    let v = make_wallet(1000);
    print(v(50));
    print(w(100));

    Reference বাস্তবায়নের run আর vm দুটিতেই আউটপুট: 1040, 740, 1040, 990, 640. হিসাব: প্রথম make_wallet(1000)-এর ভেতরে refund(40) balance-কে 1040 করে ছাপে। তারপর ফেরত আসা pay (w) একই balance থেকে 300 কাটে: 740. দ্বিতীয় make_wallet(1000) সম্পূর্ণ নতুন cell বানায়, refund 1040 ছাপে, আর v সেখান থেকে 50 কাটে: 990. শেষে w আবার প্রথম cell-এ ফিরে 740 − 100 = 640; v-এর কাটা প্রথম wallet ছোঁয়নি। dis-এ make_wallet-এর listing-এ শুধু একটি MAKE_CELL 1 ; balance আর দুটি MAKE_CLOSURE … captures balance: দুটি closure একই cell পায়, start ধরা হয়নি বলে cell পায় না। refund function শেষে হারিয়ে যায়, কিন্তু তার বদল cell-এ থেকে গেছে বলে w সেটি দেখে।

  4. প্রমাণ: অংশ ২-এর semantics-এ দুটি ভাষা ভাবুন: Lref, যেখানে closure ⟨x, b, ρ⟩ environment ρ ধরে (নাম → ঘর), আর Lval, যেখানে closure তৈরির মুহূর্তে প্রতিটি free variable-এর ঘরের মান একটি নতুন ঘরে কপি করে। প্রমাণ করুন (রূপরেখা যথেষ্ট): যদি program-এ কোনো ধরা variable closure তৈরির পরে কখনো assignment না পায় (যেমন Haat-এ সব ধরা variable let), তাহলে দুই ভাষায় program-এর আউটপুট একই। কোন ধাপে শর্তটি লাগল?

    প্রমাণের রূপরেখা. দুই ভাষায় একই program-কে পাশাপাশি এক ধাপ এক ধাপ করে চালাই, আর একটি সম্পর্ক R রক্ষা করি: প্রতিটি closure-এর জন্য, Lref-এ তার ধরা প্রতিটি নাম যে ঘর দেখায় সেখানকার মান = Lval-এ তার কপি-ঘরের মান; আর বাকি সব ঘর দুই দিকে সমান।

    1. শুরু: কোনো closure নেই, store দুই দিকে সমান; R সত্য।
    2. Closure তৈরি (E-Fn): Lval এই মুহূর্তের মান কপি করে, তাই কপি-ঘরের মান = আসল ঘরের মান। R রক্ষা পায়।
    3. পড়া (E-Var): closure-এর দেহে একটি ধরা নাম পড়লে Lref আসল ঘর, Lval কপি-ঘর পড়ে; R অনুযায়ী মান সমান। অন্য সব পড়া একই ঘরে।
    4. লেখা: একটি ঘরে assignment হলে দুই দিকে একই ঘর বদলায়। কিন্তু সেই ঘর যদি কোনো closure-এর ধরা ঘর হতো, তাহলে Lref-এর closure নতুন মান দেখত আর Lval-এর কপি পুরোনো থাকত: R ভেঙে যেত। শর্তটি ঠিক এখানে লাগে: ধরা variable তৈরির পরে কখনো assignment পায় না, তাই এমন লেখা ঘটেই না, আর R রক্ষা পায়।
    5. Call (E-Call), যোগ, print: প্রতিটি নিয়ম শুধু ওপরের পড়া আর লেখা ব্যবহার করে, তাই প্রতিটি ধাপে দুই দিক একই মান পায়; print একই মান ছাপে। ধাপের সংখ্যার ওপর induction-এ পুরো run-এ R আর আউটপুট সমান। ∎

    ফলাফলের ব্যবহারিক অর্থ: Haat-এর compiler চাইলে ধরা let-কে cell ছাড়াই সরাসরি কপি করতে পারত (একটি optimization), কারণ শর্তটি let-এর জন্য ভাষাই নিশ্চিত করে; শুধু var-এর জন্য cell বাধ্যতামূলক। Java-র effectively final নিয়মও ঠিক এই উপপাদ্যের ওপর দাঁড়ানো। অংশ ৩-এর ছোট interpreter-এর prog1 শর্তটি ভাঙে (bonus পরে 50 হয়), তাই সেখানে দুই mode আলাদা ফল দিয়েছে: 51 বনাম 6.

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

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

ক্রমHaat-এর make_counter(100) একটি closure ফেরত দিয়ে পরে সেটি ডাকা হলো। VM-এ ঘটনাগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. LOAD_LOCAL 0: parameter start-এর মান 100 stack-এ তোলা
  2. MAKE_CELL 1: 100 দিয়ে next-এর নতুন cell বানানো
  3. MAKE_CLOSURE 0: ভেতরের code আর cell-এর reference জুড়ে closure বানানো
  4. RETURN: make_counter-এর frame মুছে যায়, cell টিকে থাকে
  5. পরে closure ডাকা হলে LOAD_FREE 0 দিয়ে cell থেকে next পড়া

Python 3.14-এ fs = [lambda: i * 10 for i in range(3)] লেখার পর print([f() for f in fs]) কী ছাপে, আর কেন?

  • [0, 10, 20], কারণ প্রতিটি lambda তৈরির সময়ের i মনে রাখে
  • [20, 20, 20], কারণ তিনটি lambda একই variable i ধরে, যার শেষ মান 2
  • [30, 30, 30], কারণ loop শেষে i = 3
  • NameError, কারণ comprehension শেষে i আর থাকে না

C++20-এ int rate = 10; auto a = [=](int t) { return t - t * rate / 100; }; auto b = [&](int t) { return t - t * rate / 100; }; rate = 20; এরপর a(1040) আর b(1040) যথাক্রমে কত?

  • 936 আর 936
  • 832 আর 832
  • 936 আর 832
  • 832 আর 936

কোন ক্ষেত্রে closure-এর ধরা variable-কে stack frame-এর বাইরে (যেমন heap-এ) রাখা অপরিহার্য হয়ে পড়ে?

  • Function একটি local ব্যবহার করে এমন ভেতরের function ফেরত দিলে (upward funarg)
  • ভেতরের function-কে শুধু argument হিসেবে map-এর মতো function-এ পাঠালে
  • ভেতরের function কোনো free variable ব্যবহার না করলে
  • ভেতরের function শুধু global variable পড়লে

Haat-এ fn make_counter(start: Int) -> () -> Int { var next = start; return fn() -> Int { next = next + 1; return next; }; }. Reference বাস্তবায়নের VM-এ ভেতরের function next পড়তে কোন নির্দেশ ব্যবহার করে?

  • LOAD_LOCAL
  • LOAD_GLOBAL
  • LOAD_CELL
  • LOAD_FREE

Java 21-এ একটি method-এর ভেতরে int n = 0; Runnable r = () -> System.out.println(n); লেখা হলো। কোন অতিরিক্ত লাইন যোগ করলে compile error হয়?

  • r.run();
  • int m = n + 1;
  • n++;
  • n-এর ঘোষণা final int n = 0; করে দেওয়া

Haat-এর function fn(x: Int) -> Int { let y = x * rate; return y + bonus; }-এর free variable-এর সেট কোনটি? (rate আর bonus বাইরে ঘোষিত)

  • {rate, bonus}
  • {x, rate, bonus}
  • {y, rate, bonus}
  • ∅ (function টি closed)

শব্দকোষ

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

মনে রাখুন

  1. Closure = ⟨code, ρ⟩: function আর তার জন্মের environment; দেহ চলে closure-এর ρ-তে, ডাকার জায়গার environment-এ নয় (E-Call, প্রস্তাব ১৭.১)। Free variable: যে নাম ভেতরে ঘোষিত নয়।
  2. By reference বনাম by value: Python, JavaScript, Haat variable ধরে; C++-এ [=]/[&] বেছে নিতে হয় (936 বনাম 832); Java কপি ধরে কিন্তু effectively final চায়। ধরা variable কখনো না বদলালে দুই কৌশল একই ফল দেয়।
  3. Loop-এর ফাঁদ: সমস্যা capture-এ নয়, variable-এর সংখ্যায়। Python-এর তিনটি lambda একটি cell ভাগ করে; let আর Haat-এর while প্রতি round-এ নতুন variable দেয়, কিন্তু capture তখনো by reference.
  4. Funarg: downward stack-এ চলে; upward-এ variable-কে frame-এর চেয়ে বেশি বাঁচতে হয়, তাই heap আর GC, বা কপি (C++), বা lifetime প্রমাণ (Rust). Escape analysis শুধু-নিচে-যাওয়া closure খুঁজে stack-এ রাখে।
  5. বাস্তবায়ন: বদলানো ধরা variable cell-এ; flat closure = code + FV-এর cell তালিকা; Haat-এর MAKE_CELL/MAKE_CLOSURE/LOAD_FREE আর CPython-এর LOAD_DEREF একই নকশা। Closure conversion সব function-কে closed বানিয়ে native code-এর পথ খোলে।

পরের পর্বে: Closure দিয়ে একটি function-এর অবস্থা গোপন রাখা শিখলেন। পর্ব ১৮-এ গোপনীয়তার পরিসর বড় হবে: পুরো program-কে module, package আর namespace-এ ভাগ করা, import কীভাবে নাম খোঁজে আর cache করে, আর C++-এর name mangling.

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

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