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

Scope — static বনাম dynamic scoping আর nested scope

Scope Rules — Static (Lexical) vs Dynamic Scoping, Nested Scopes, Shadowing, Block vs Function Scope and Declaration-Before-Use

Taught in Bangla, this lesson treats scope as the rule for finding which declaration a name means. The same program prints 50, 50 in Haat under static scope and 50, 200 in bash under dynamic scope, both real runs, with a Perl version too, and an in-page interpreter runs both rules. It walks scope chains and shadowing, argues why static scope won and proves renaming preserves meaning, then compares block and function scope, hoisting, let's TDZ and Python's global and nonlocal.

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

  • Static আর dynamic scope-এর সংজ্ঞা দেওয়া, আর একই program-এর দুই নিয়মে আউটপুট হাতে হিসাব করা (পরীক্ষার সবচেয়ে পরিচিত প্রশ্ন)
  • Nested scope, shadowing আর scope chain ধরে একটি নাম ধাপে ধাপে খুঁজে বের করা
  • Block scope, function scope, hoisting আর ঘোষণার আগে ব্যবহারের নিয়ম Haat, C, JavaScript, Rust আর Python-এ তুলনা করা
  • Python-এর global, nonlocal আর UnboundLocalError-এর পেছনের নিয়ম বোঝা
  • একটি ছোট name-resolution pass লিখে দেখা, কেন static scope-এ compiler প্রতিটি নামের ঠিকানা আগেই জানে

১ · Scope কী — একটি নাম, কোন ঘোষণা?

পর্ব ১৪-এ (নাম, variable আর binding) দেখেছেন, একটি নাম একটি জিনিসের সঙ্গে বাঁধা থাকে, আর সেই বাঁধন কখন তৈরি হয় তাকে বলে binding time. বড় program-এ কিন্তু একই নাম বহু জায়গায় ঘোষিত হয়। বাজারঘরের কোডে rate হয়তো তিন জায়গায় আছে: সাধারণ ছাড়ের হার, উৎসবের হার, আর একটি function-এর নিজের হিসাব। কোনো লাইনে rate লেখা থাকলে সেটি কোন rate? এই প্রশ্নের উত্তর দেয় ভাষার scope-এর নিয়ম।

বাজারঘরের ঢাকা আর রাজশাহী শাখায় দুজন আলাদা ম্যানেজার। ঢাকা শাখায় লেখা একটি চিরকুটে আছে: “ম্যানেজারের সই নিন।” চিরকুটটি এক কর্মী রাজশাহীতে নিয়ে গেলেন। এখন কার সই লাগবে? এক নিয়মে উত্তর: যে শাখায় চিরকুট লেখা হয়েছে, সেই ঢাকার ম্যানেজার। আরেক নিয়মে: চিরকুট যেখানে পড়া হচ্ছে, সেই রাজশাহীর ম্যানেজার। প্রথমটি static scope, দ্বিতীয়টি dynamic scope. দুটিই যুক্তিসঙ্গত শোনায়, কিন্তু ফল আলাদা; আর প্রোগ্রামিং ভাষাকে একটি বেছে নিতেই হয়।

সংজ্ঞা ১৫.১ — scope আর referencing environment

একটি ঘোষণার (binding-এর) scope হলো program-এর সেই অংশ, যেখানে ওই নাম লিখলে এই ঘোষণাটিকেই বোঝায়। উল্টো দিক থেকে, একটি statement-এর referencing environment হলো সেই জায়গা থেকে দেখা যায় এমন সব নামের সংগ্রহ। কোন নাম কোন ঘোষণাকে বোঝায়, তা খুঁজে বের করার কাজটিকে compiler-এর ভাষায় বলে name resolution; এটি পর্ব ০৫-এর semantic analysis ধাপের প্রথম অংশ।

একটি সূক্ষ্ম পার্থক্য মনে রাখুন: scope একটি জায়গার ধারণা (program-এর কোন অংশে নামটি দেখা যায়), আর lifetime একটি সময়ের ধারণা (চলার সময় variable কতক্ষণ বেঁচে থাকে)। দুটি প্রায়ই মেলে, কিন্তু সবসময় নয়; সেই গল্প পর্ব ১৬-এ (Lifetime আর storage). এই পর্বের প্রশ্ন শুধু একটি: লেখা নামটি কোন ঘোষণা?

প্রায় সব ভাষায় কয়েকটি নিয়ম একই রকম। একটি function বা block নিজের নাম ঘোষণা করতে পারে; সেগুলো তার local variable. সবার বাইরে ঘোষিত নাম global variable. আর নাম খোঁজা হয় ভেতর থেকে বাইরে। মূল পার্থক্য আসে “বাইরে” শব্দের মানে নিয়ে: লেখার দিক থেকে যে scope ঘিরে রেখেছে (static), নাকি চলার সময় যে function ডেকেছে (dynamic).

📍 Static (lexical) scope

নাম খোঁজা হয় কোড যেখানে লেখা, সেখান থেকে বাইরে। Compile-এর আগেই জানা যায়।

C, Java, Python, JS, Rust, Haat

📞 Dynamic scope

নাম খোঁজা হয় চলার সময়ের call-এর শিকল ধরে: যে ডেকেছে, তার কাছে।

প্রথম দিকের LISP, bash, Perl-এর local

🧱 Block scope

প্রতিটি { } একটি নতুন scope; ভেতরের নাম বাইরে অচেনা।

C, Java, JS-এর let/const, Haat

📦 Function scope

Function-এর ভেতরে যেকোনো জায়গায় ঘোষিত নাম পুরো function-এ দেখা যায়।

JS-এর var, Python

২ · Static scope — nested block, shadowing আর scope chain

ALGOL 60 (১৯৬০) block structure নিয়ে আসে: একটি block-এর ভেতরে আরেকটি block, আর প্রতিটি block নিজের নাম ঘোষণা করতে পারে। তখন থেকে মূলধারার প্রায় সব ভাষা static scope মানে। নিয়মটি এক বাক্যে বলা যায়।

সংজ্ঞা ১৫.২ — static (lexical) scope-এর নিয়ম

একটি নাম x-এর ব্যবহার সেই ঘোষণাকে বোঝায়, যা লেখার দিক থেকে x-কে ঘিরে থাকা সবচেয়ে ভেতরের scope-এ আছে। নিজের scope-এ না পেলে ঠিক বাইরের (ঘিরে থাকা) scope-এ, তারপর তার বাইরে, এভাবে global পর্যন্ত খোঁজা হয়; কোথাও না পেলে নামটি অচেনা, অর্থাৎ error. খোঁজার এই পথটিকে বলে scope chain.

ভেতরের scope-এ বাইরের একটি নামের সমান নাম ঘোষণা করলে ভেতরে বাইরেরটি দেখা যায় না, যদিও বাইরেরটি বহাল থাকে। একে বলে shadowing, বাংলায় “আড়াল করা”। নিচের Haat program-এ তিনটি স্তর: global, function order_total, আর তার ভেতরের function discount. discount তিনটি নাম ব্যবহার করে, আর তিনটি তিন স্তর থেকে আসে।

// বাজারঘর: scope chain
let limit = 1000;
let rate = 5;
fn order_total(qty: Int, unit: Int) -> Int {
    let rate = 10;
    fn discount(t: Int) -> Int {
        if t >= limit { return t * rate / 100; }
        return 0;
    }
    let t = qty * unit;
    return t - discount(t);
}
print(order_total(2, 520));
print(order_total(3, 120));
print(rate);
~/haat $ python haat.py run chain.haat
936
360
5

সত্যিকারের run, কোর্সের Haat reference বাস্তবায়নে (CPython 3.14.4; haat.py vm-ও একই তিন লাইন দেয়)। order_total(2, 520)-এ t = 1040, যা limit-এর সমান বা বেশি, তাই ছাড় 1040 × 10 / 100 = 104 আর ফল 936. এখানে rate হলো order_total-এর 10, global-এর 5 নয়। দ্বিতীয় call-এ t = 360, ছাড় নেই। শেষ লাইনে global rate এখনো 5: ভেতরের let rate = 10; তাকে শুধু আড়াল করেছিল, বদলায়নি।

ছবি ১৫.১ — chain.haat-এর তিনটি scope, একটির ভেতরে আরেকটি

discount-এর ভেতরের প্রতিটি নাম যে রঙে লেখা, সেই রঙের বাক্সে পাওয়া যায়।

Nested scopes of chain.haat: global contains order_total, which contains discount; t is found locally, rate one level out, limit two levels out global scope limit = 1000 rate = 5 order_total order_total(qty, unit) qty unit rate = 10 discount t discount(t) নিজের নাম: t = 1040 t → এখানেই, ০ স্তর rate → ১ স্তর বাইরে → 10 limit → ২ স্তর বাইরে → 1000 খোঁজা চলে ভেতর থেকে বাইরে global-এর rate = 5 আড়ালে (shadowed)
ছবি ১৫.১ — static scope-এ scope-গুলো লেখার কাঠামো মেনে একটির ভেতরে আরেকটি বসে। discount-এর ভেতর থেকে rate খুঁজলে প্রথম মিল পাওয়া যায় বেগুনি বাক্সে (10); তাই global-এর rate = 5 কাটা দাগে দেখানো: এই জায়গা থেকে সেটি আড়ালে।

এবার খোঁজার কাজটি ধাপে ধাপে দেখুন। কোড সংক্ষেপে (type বাদ দিয়ে) দেখানো হয়েছে; পুরো ফাইল উপরের chain.haat, শুধু order_total(3, 120)-এর লাইনটি বাদ। এই সংক্ষিপ্ত রূপও reference-এ চালিয়ে 936 আর 5 মেলানো হয়েছে।

1let limit = 1000;2let rate = 5;3fn order_total(qty, unit)4  let rate = 10;5  fn discount(t)6    if t >= limit7      return t * rate / 100;8  let t = qty * unit;9  return t - discount(t);10print(order_total(2, 520));11print(rate);
এই ধাপে
frame-এর শিকল
খোঁজা
মান
  1. Global scope. limit = 1000 আর rate = 5 global frame-এ বসে। order_total top-level function, তাই সেটিও global-এর একটি নাম।
  2. order_total(2, 520) ডাকা। নতুন frame তৈরি হলো: qty = 2, unit = 520, আর নিজের rate = 10. এর বাইরের (parent) frame global, কারণ order_total global-এ লেখা।
  3. discount(1040) ডাকা। t = 1040. discount লেখা হয়েছে order_total-এর ভেতরে, তাই তার frame-এর parent হলো order_total-এর frame. শিকল এখন তিন স্তরের।
  4. t খোঁজা। নিজের frame-এই আছে: ০ স্তর, মান 1040.
  5. limit খোঁজা। discount-এ নেই, order_total-এ নেই, global-এ আছে: ২ স্তর বাইরে, মান 1000. শর্ত 1040 ≥ 1000 সত্য।
  6. rate খোঁজা। discount-এ নেই; order_total-এ আছে, মান 10. খোঁজা এখানেই থামে, তাই global-এর 5 কখনো দেখা হয় না: এটিই shadowing. ছাড় = 104.
  7. ফেরা। discount-এর frame শেষ; order_total ফেরত দেয় 1040 − 104 = 936, আর সেটি ছাপা হয়।
  8. Global থেকে rate. শেষ লাইনটি global-এ লেখা, তাই সেখান থেকে খোঁজা শুরু হয়ে প্রথমেই global-এর rate পাওয়া যায়: 5. একই নাম, লেখার জায়গা আলাদা, তাই উত্তর আলাদা।

লক্ষ করুন, প্রতিটি নাম কত স্তর বাইরে পাওয়া যাবে (t: ০, rate: ১, limit: ২), তা program না চালিয়েই, শুধু কোড পড়ে বলা যায়। এই সংখ্যাটিকে compiler-এর বইয়ে বলে static distance. অংশ ৪-এ দেখবেন, এটিই static scope-এর সবচেয়ে বড় সুবিধা।

৩ · Dynamic scope — একই program, অন্য উত্তর

সংজ্ঞা ১৫.৩ — dynamic scope-এর নিয়ম

একটি নাম x-এর ব্যবহার সেই ঘোষণাকে বোঝায়, যা চলার সময় সবচেয়ে সাম্প্রতিক, এখনো শেষ না হওয়া function call-এ তৈরি হয়েছে। নিজের frame-এ না পেলে যে function এটিকে ডেকেছে তার frame-এ, তারপর তাকে যে ডেকেছে, এভাবে call stack ধরে নিচে নামা হয়। খোঁজার পথ লেখার কাঠামো নয়, call stack.

পার্থক্যটি দেখতে একটি program দরকার, যেখানে একটি function-এর free variable (যে নাম সে ব্যবহার করে কিন্তু নিজে ঘোষণা করেনি) আছে, আর function-টি দুটি আলাদা জায়গা থেকে ডাকা হয়। বাজারঘরের সাধারণ ছাড় 5%, কিন্তু উৎসবের সময় হিসাব করা function নিজের rate = 20 রাখে:

let rate = 5;
fn discount(t: Int) -> Int { return t * rate / 100; }
fn festival(t: Int) -> Int {
    let rate = 20;
    return discount(t);
}
print(discount(1000));
print(festival(1000));
~/haat $ python haat.py run festival.haat
50
50

Haat static scope মানে: discount global-এ লেখা, তাই তার rate সবসময় global-এর 5; কে ডাকল তাতে কিছু আসে যায় না। festival-এর rate = 20 একটি local, যা discount দেখতেই পায় না। Dynamic scope-এর ভাষায় একই program দ্বিতীয় লাইনে 200 ছাপত: discount-কে festival ডেকেছে, আর festival-এর frame-এ rate = 20 আছে।

1let rate = 5;2fn discount(t: Int) -> Int3  return t * rate / 100;4fn festival(t: Int) -> Int5  let rate = 20;6  return discount(t);7print(discount(1000));8print(festival(1000));
এই ধাপে
call stack
static: rate
dynamic: rate
  1. শুরু। Global frame-এ rate = 5. দুটি function-ই global-এ লেখা।
  2. discount(1000), সরাসরি। ডেকেছে global নিজেই। Static নিয়মে parent global (লেখার জায়গা), dynamic নিয়মে parent-ও global (যে ডেকেছে)। দুই নিয়মেই rate = 5, ফল 50. পার্থক্য তখনই দেখা যায়, যখন লেখার জায়গা আর ডাকার জায়গা আলাদা।
  3. festival(1000). নতুন frame, t = 1000.
  4. festival-এর local rate. festival-এর frame-এ rate = 20 তৈরি হলো। global-এর 5 যেমন ছিল তেমনই আছে।
  5. festival থেকে discount ডাকা। এখানেই দুই নিয়ম আলাদা হয়ে যায়। Static: discount-এর frame-এর parent global, কারণ discount global-এ লেখা। Dynamic: parent festival-এর frame, কারণ সে-ই ডেকেছে।
  6. rate খোঁজা। দুই নিয়মেই discount-এর নিজের frame-এ rate নেই। Static পরের ধাপে যায় global-এ, পায় 5. Dynamic যায় festival-এ, পায় 20.
  7. দুই উত্তর। Static: 50, 50 (Haat-এর আসল আউটপুট)। Dynamic: 50, 200. একই কোড, একই input; শুধু নাম খোঁজার নিয়ম আলাদা।

দুই নিয়ম, একটি ছোট interpreter

নিয়ম দুটির পার্থক্য কত ছোট, তা দেখার সবচেয়ে ভালো উপায় একটি interpreter-এ দুটিই বাস্তবায়ন করা। নিচের Python কোড (আপনার ব্রাউজারে, Pyodide) festival.haat-এর হিসাবের অংশটুকু একটি ছোট AST হিসেবে রাখে। প্রতিটি call-এ একটি নতুন environment (নাম থেকে মানের খাতা) তৈরি হয়, যার একটি parent সংযোগ আছে। পুরো পার্থক্য একটি লাইনে: নতুন frame-এর parent কে?

from dataclasses import dataclass
@dataclass
class Env:                       # one frame: its names, plus a link to a parent frame
    name: str
    vars: dict
    parent: "Env | None"
    def lookup(self, x, found):
        env = self
        while env is not None:   # walk the chain of parent links
            if x in env.vars:
                found.append(env.name); return env.vars[x]
            env = env.parent
        raise NameError(f"undefined variable '{x}'")
# function name -> (parameter, local lets, body); all functions are top level
FUNS = {"discount": ("t", {}, ("div", ("mul", ("var", "t"), ("var", "rate")), ("num", 100))),
        "festival": ("t", {"rate": ("num", 20)}, ("call", "discount", ("var", "t")))}
def ev(e, env, mode, found):
    if e[0] == "num": return e[1]
    if e[0] == "var": return env.lookup(e[1], found)
    if e[0] in ("mul", "div"):
        a, b = ev(e[1], env, mode, found), ev(e[2], env, mode, found)
        return a * b if e[0] == "mul" else a // b
    param, lets, body = FUNS[e[1]]                       # e[0] == "call"
    arg = ev(e[2], env, mode, found)
    parent = GLOBAL if mode == "static" else env         # THE only difference
    frame = Env(e[1] + " frame", {param: arg}, parent)
    for x, init in lets.items(): frame.vars[x] = ev(init, frame, mode, found)
    return ev(body, frame, mode, found)
GLOBAL = Env("global", {"rate": 5}, None)
for mode in ("static", "dynamic"):
    for f in ("discount", "festival"):
        found = []
        v = ev(("call", f, ("num", 1000)), GLOBAL, mode, found)
        print(f"{mode:7} {f}(1000) = {v:3}   'rate' found in: {found[-1]}")

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

static  discount(1000) =  50   'rate' found in: global
static  festival(1000) =  50   'rate' found in: global
dynamic discount(1000) =  50   'rate' found in: global
dynamic festival(1000) = 200   'rate' found in: festival frame

প্রথম দুই লাইন Haat reference-এর আসল আউটপুটের সঙ্গে হুবহু মেলে (50, 50). শেষ লাইনে dynamic নিয়মে rate পাওয়া গেছে festival-এর frame-এ, তাই 200. পুরো interpreter-এ পার্থক্য একটিমাত্র লাইন: parent = GLOBAL if mode == "static" else env. Static নিয়মে নতুন frame-এর parent হয় function যেখানে লেখা সেই environment (এখানে সব function top-level, তাই global); dynamic নিয়মে parent হয় ডাকার মুহূর্তের environment, অর্থাৎ caller. Nested function থাকলে static নিয়মে “যেখানে লেখা” environment-টি function মানের সঙ্গে রেখে দিতে হয়; সেটিই closure, যার পুরো গল্প পর্ব ১৭-এ (Closure). পুরো tree-walking interpreter আসবে পর্ব ৫৬-এ।

নিয়ম দুটি গণিতের ভাষায়

পর্ব ৪০-এর (Operational semantics) big-step ধাঁচে লিখলে পার্থক্যটি একটি অক্ষরে নেমে আসে। এখানে ρ (rho) একটি environment, ρ ⊢ e ⇓ v পড়ুন “environment ρ-তে e-এর মান v”, আর ρ[x ↦ v] মানে “ρ, শুধু x-এর মান v”. Static নিয়মে function মান একটি জোড়া ⟨x, e, ρd⟩, যেখানে ρd হলো সংজ্ঞার (definition) environment; dynamic নিয়মে শুধু ⟨x, e⟩.

ρ ⊢ f ⇓ ⟨x, e, ρd⟩    ρ ⊢ a ⇓ v    ρd[x ↦ v] ⊢ e ⇓ w
ρ ⊢ f(a) ⇓ w
(App-Static)
ρ ⊢ f ⇓ ⟨x, e⟩    ρ ⊢ a ⇓ v    ρ[x ↦ v] ⊢ e ⇓ w
ρ ⊢ f(a) ⇓ w
(App-Dynamic)

দুটি নিয়মে দাগের ওপরের তৃতীয় শর্তটিই আলাদা: function-এর দেহ e মূল্যায়ন হয় ρd-এ (লেখার সময়ের environment) নাকি ρ-তে (ডাকার মুহূর্তের environment). ওপরের Python কোডের parent লাইনটি এই দুই অক্ষরের হুবহু অনুবাদ।

Dynamic scope আজও আছে — bash আর Perl-এ সত্যিকারের run

Dynamic scope শুধু ইতিহাস নয়। GNU bash-এর manual স্পষ্ট বলে, function-এর ভেতরে local দিয়ে ঘোষিত variable dynamic scoping মানে। একই festival program bash-এ (GNU bash 5.2.37-এ সত্যিকারের run):

rate=5
discount() { echo $(( $1 * rate / 100 )); }
festival() { local rate=20; discount "$1"; }
discount 1000
festival 1000
echo "after: rate=$rate"
~/scope $ bash festival.sh
50
200
after: rate=5

200! discount-এর rate খোঁজা হয়েছে যে ডেকেছে সেই festival-এর local rate-এ। আর festival শেষ হলে global rate আবার 5. Perl আরও মজার, কারণ এক ভাষাতেই দুটি নিয়ম আছে: my দিয়ে ঘোষিত variable lexical, আর local একটি global variable-কে সাময়িকভাবে নতুন মান দেয়, যা ডাকা সব function দেখে (Perl 5.38.2-এ সত্যিকারের run):

use strict; use warnings;
our $rate = 5;
sub discount { my ($t) = @_; return $t * $rate / 100; }
sub festival_local { local $rate = 20; return discount($_[0]); }
sub festival_my    { my    $rate = 20; return discount($_[0]); }
print discount(1000), "\n";
print festival_local(1000), "\n";
print festival_my(1000), "\n";
print "after: $rate\n";
~/scope $ perl festival.pl
50
200
50
after: 5

একই কাজ, শুধু একটি শব্দ আলাদা: local দিলে 200 (dynamic), my দিলে 50 (static, Haat-এর মতো)। Perl-এ my এসেছে Perl 5 (১৯৯৪)-এ; তার আগে local variable-এর একমাত্র উপায় ছিল local. Emacs Lisp-ও বহু বছর শুধু dynamic binding দিত; Emacs 24 (২০১২) থেকে ফাইলের শুরুতে lexical-binding: t লিখে lexical scope চালু করা যায়।

৪ · কেন static scope জিতল — নাম বদল, আগেই ঠিকানা আর funarg

আজ মূলধারার প্রায় সব ভাষা static scope মানে। কারণটি রুচির নয়, যুক্তির। তিনটি যুক্তি দেখুন, প্রথমটি একটি ছোট উপপাদ্য।

যুক্তি ১: local নাম বদলালে অর্থ বদলানো উচিত নয়

ধরুন আপনি festival-এর ভেতরের rate-কে r নামে বদলালেন, কারণ নামটি ভালো লাগেনি। একটি function-এর ভেতরের নাম তার নিজস্ব ব্যাপার হওয়ার কথা; বাইরে থেকে কেউ টের পাওয়ার কথা নয়। এই ধরনের নাম বদলকে বলে α-renaming (alpha-renaming).

উপপাদ্য ১৫.১ — static scope-এ নাম বদল অর্থ রক্ষা করে

Static scope-এর একটি ভাষায় একটি ঘোষণা D-এর নাম x-কে, D আর তার scope-এর ভেতরে D-কে বোঝানো প্রতিটি ব্যবহারসহ, একটি নতুন নাম y-তে বদলানো হলো, যেখানে y program-এ আগে কোথাও নেই। তাহলে নতুন program-এর আচরণ পুরোনোটির হুবহু সমান।

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

  1. Static scope-এ প্রতিটি নাম-ব্যবহার কোন ঘোষণাকে বোঝায়, তা শুধু লেখার কাঠামো (কোন scope কাকে ঘিরে আছে) আর নামের মিল থেকে ঠিক হয় (সংজ্ঞা ১৫.২)। এই সম্পর্কটিকে বলি R: ব্যবহার → ঘোষণা।
  2. D-কে বোঝানো ব্যবহারগুলোর ক্ষেত্রে: নতুন program-এ তারা y নামে আছে, আর তাদের ঘিরে থাকা scope-গুলোর মধ্যে y নামে ঘোষণা শুধু D (y নতুন নাম, অন্য কোথাও নেই)। তাই R তাদের আবার D-তেই পাঠায়।
  3. অন্য সব ব্যবহারের ক্ষেত্রে: তাদের নাম বদলায়নি, আর কোনোটির নাম y নয় (y নতুন), তাই তারা ভুল করে D-তে যেতে পারে না। তাদের খোঁজার পথে D যদি আসল ঘোষণার আগে পড়ত, তবে তারা D-কেই বোঝাত, যা ধাপ ২-এর দল; তাই D হয় পথে নেই, নয়তো আসল ঘোষণার পরে। নাম বদলের পর প্রথম মিল তাই একই থাকে।
  4. ফলে R অপরিবর্তিত, শুধু ঘোষণাটির লেবেল বদলেছে। মূল্যায়নের নিয়ম (App-Static) মান খোঁজে R অনুযায়ী, তাই প্রতিটি ধাপে একই মান আসে, আর আউটপুটও একই। ∎

“y নতুন নাম” শর্তটি জরুরি; এটি না মানলে static scope-এও অর্থ বদলাতে পারে (অনুশীলন ২-এ সত্যিকারের উদাহরণ)। আর dynamic scope-এ উপপাদ্যটি সরাসরি ভেঙে পড়ে। festival-এর local rate=20-কে local r=20 করে bash-এ চালানো হলো (সত্যিকারের run): আউটপুট 200 থেকে হয়ে গেল 50. Dynamic scope-এ একটি function-এর local নাম আসলে তার ডাকা সব function-এর কাছে খোলা, অর্থাৎ নামটি function-এর বাইরের চুক্তির অংশ। বড় program-এ এটি প্রায় অসম্ভব একটি দায়: কোনো local-এর নাম বদলানোর আগে আপনাকে জানতে হবে, এই function থেকে কোন কোন function কোন পথে ডাকা হতে পারে।

যুক্তি ২: compiler প্রতিটি নামের ঠিকানা আগেই জানে

Static scope-এ “কত স্তর বাইরে, কোন ঘরে” প্রশ্নের উত্তর কোড পড়েই পাওয়া যায়। তাই compiler চালানোর আগেই প্রতিটি নাম-ব্যবহারকে একটি স্থির ঠিকানায় বদলে দেয়, আর চলার সময় কোনো নাম খুঁজতে হয় না। নিচের কোড একটি ছোট name-resolution pass: Haat reference-এর resolver-এর মূল নিয়মগুলো (প্রতিটি function-এর slot নম্বর, parameter আর দেহের এক scope, top-level function hoisting, ঘোষণার আগে ব্যবহার error) মেনে প্রতিটি ব্যবহারের depth (কোন function স্তরে ঘোষিত) আর slot বের করে। পুরো সংস্করণ reference-এর resolver.py-তে; এর বাস্তবায়ন বিস্তারে আসবে পর্ব ৫১-এ (Symbol table আর name resolution).

# stmt = ("let", name, [names in initializer]) | ("use", name) | ("fn", name, [params], [body])
def resolve(stmts, chain, depth, nslots, out):
    scope = {"names": {}, "later": {s[1] for s in stmts if s[0] != "use"}}
    chain = chain + [scope]
    def declare(x):
        if x not in scope["names"]:
            scope["names"][x] = (depth, nslots[0]); nslots[0] += 1
        scope["later"].discard(x)
    def find(x):
        for sc in reversed(chain):                    # innermost scope first
            if x in sc["names"]:
                d, slot = sc["names"][x]
                op = "LOAD_GLOBAL" if d == 0 else "LOAD_LOCAL" if d == depth else "LOAD_FREE"
                return out.append(f"{x:9} depth {d} slot {slot}  {depth - d} up  {op}")
            if x in sc["later"]:
                return out.append(f"{x:9} error: '{x}' is used before its declaration")
        out.append(f"{x:9} error: undefined variable '{x}'")
    for s in stmts:                                   # hoist top-level functions
        if depth == 0 and s[0] == "fn": declare(s[1])
    for s in stmts:
        if s[0] == "use": find(s[1])
        elif s[0] == "let":
            for u in s[2]: find(u)
            declare(s[1])
        else:                                         # params share the body's scope
            declare(s[1]); body = [("let", p, []) for p in s[2]] + s[3]
            resolve(body, chain, depth + 1, [0], out)
chain_haat = [("let", "limit", []), ("let", "rate", []),
    ("fn", "order_total", ["qty", "unit"], [("let", "rate", []),
        ("fn", "discount", ["t"], [("use", "t"), ("use", "limit"), ("use", "rate")]),
        ("let", "t", ["qty", "unit"]), ("use", "discount")])]
broken = [("let", "rate", []), ("use", "totl"),
    ("fn", "bill", ["t"], [("let", "cut", ["t", "rate"]), ("let", "rate", [])])]
for name, prog in (("chain.haat", chain_haat), ("broken.haat", broken)):
    out = []; resolve(prog, [], 0, [0], out); print("==", name); print("\n".join(out))

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

== chain.haat
t         depth 2 slot 0  0 up  LOAD_LOCAL
limit     depth 0 slot 1  2 up  LOAD_GLOBAL
rate      depth 1 slot 2  1 up  LOAD_FREE
qty       depth 1 slot 0  0 up  LOAD_LOCAL
unit      depth 1 slot 1  0 up  LOAD_LOCAL
discount  depth 1 slot 3  0 up  LOAD_LOCAL
== broken.haat
totl      error: undefined variable 'totl'
t         depth 1 slot 0  0 up  LOAD_LOCAL
rate      error: 'rate' is used before its declaration

প্রথম তিন লাইন stepper-এর ০, ২, ১ স্তরের হুবহু মিল, তবে এবার কিছু না চালিয়েই। এগুলো Haat reference-এর আসল bytecode-এর সঙ্গেও মেলে: python haat.py dis chain.haat চালালে discount-এর ভেতরে দেখা যায় LOAD_LOCAL 0 ; t, LOAD_GLOBAL 1 ; limit আর LOAD_FREE 0 ; rate, আর order_total-এ MAKE_CELL 2 ; rate (slot 2-এর rate একটি cell-এ রাখা হয়, কারণ ভেতরের function তাকে ধরে রাখে; LOAD_FREE-এর 0 হলো closure-এর ধরা cell-তালিকার সূচক)। broken.haat-এ দুটি error ধরা পড়েছে program চলার আগেই: একটি নাম কোথাও নেই, আর একটি নাম তার নিজের block-এ পরে ঘোষিত (অংশ ৬-এ বিস্তার)। Cell আর LOAD_FREE-এর পুরো কাহিনি পর্ব ১৭ আর পর্ব ৫৭-এ।

Dynamic scope-এ এমন টেবিল বানানো যায় না। discount-এর rate কোন ঘোষণা, তা নির্ভর করে চলার সময় কোন পথে call এসেছে তার ওপর; একই লাইন একবার global-এর, আরেকবার festival-এর rate পড়ে। কোন call পথ আসলে ঘটবে, তা সাধারণভাবে চালানোর আগে নিশ্চিত করে বলা যায় না; program-এর আচরণ নিয়ে এই ধরনের প্রশ্নের সাধারণ সীমা দেখেছেন গণনার তত্ত্ব কোর্সের পর্ব ৫৩-এ (Rice-এর theorem). তাই dynamic scope-এর বাস্তবায়নকে চলার সময় নাম ধরে খুঁজতে হয়, আর type checker-ও আগে থেকে বলতে পারে না rate-এর type কী হবে।

যুক্তি ৩: function-কে মান হিসেবে পাঠানো (funarg)

Function যখন argument হিসেবে যায় বা অন্য function থেকে ফেরত আসে, তখন প্রশ্ন ওঠে: তার free variable কোন environment-এ খোঁজা হবে? এই প্রশ্নকে বলে funarg problem, যার সঙ্গে আপনার পরিচয় হয়েছে পর্ব ০২-এ. একে নিয়ে তিনটি সম্ভাব্য নিয়মের নাম আছে: deep binding (function যেখানে সংজ্ঞায়িত, সেখানকার environment), shallow binding (যে call আসলে function-টিকে চালায়, সেখানকার environment), আর ad hoc binding (যে call function-টিকে argument হিসেবে পাঠাল, সেখানকার)। Static scope-এ deep binding স্বাভাবিক, আর তার বাস্তব রূপই closure; dynamic scope-এর ভাষাগুলো সাধারণত shallow binding-এর দিকে যায়, আর তখন একটি “ছাড় হিসাবের function” কোথায় চলবে তার ওপর নির্ভর করে ভিন্ন হার পড়ে। পর্ব ০৯-এর currying আর composition এই কারণেই শুধু static scope-এ নির্ভরযোগ্য।

আরও গভীরে: Dynamic scope বাস্তবায়নের দুটি ক্লাসিক পদ্ধতি আছে। Deep access-এ call stack-এর frame-গুলো একে একে নিচে খোঁজা হয় (উপরের Python interpreter যা করে); shallow access-এ প্রতিটি নামের জন্য একটি কেন্দ্রীয় টেবিলে মানের একটি stack থাকে, call-এ push আর ফেরার সময় pop করা হয়, তাই খোঁজা দ্রুত কিন্তু call ধীর। Static scope-এর compiled বাস্তবায়নে প্রতিটি frame-এ একটি static link থাকে, যা লেখার দিক থেকে ঘিরে থাকা function-এর frame দেখায়; “২ স্তর বাইরে” মানে দুবার static link ধরে হাঁটা। বিকল্প পদ্ধতি display (প্রতিটি স্তরের সাম্প্রতিক frame-এর একটি ছোট array), যা সাধারণত Dijkstra-র ১৯৬০ সালের ALGOL 60 বাস্তবায়নের কাজের সঙ্গে যুক্ত করা হয়। আধুনিক compiler প্রায়ই এ দুটির বদলে closure conversion করে; activation record-এর বিস্তার পর্ব ৩০-এ।

৫ · Block scope বনাম function scope — JavaScript-এর var আর let

Static scope মানলেই সব ভাষা এক নয়। প্রশ্ন হলো, কোন কোন কাঠামো নতুন scope তৈরি করে। C, Java, Rust আর Haat-এ প্রতিটি { } block একটি scope: block scope. পুরোনো JavaScript-এর var আর Python-এ শুধু function (আর module, class) scope তৈরি করে, if বা loop-এর block নয়: function scope. JavaScript-এ দুটিই আছে, কারণ ECMAScript 2015 let আর const যোগ করেছে, কিন্তু পুরোনো কোড চালু রাখতে var রেখে দিয়েছে। আপনার ব্রাউজারে চালিয়ে দেখুন:

"use strict";
function demo() {
  console.log("1 before the if: typeof v =", typeof v, "| v =", v);
  if (true) {
    var v = 1;          // function scope: v belongs to demo()
    let w = 2;          // block scope: w belongs to this { }
    console.log("2 inside the block: v =", v, "| w =", w);
  }
  console.log("3 after the block: v =", v, "| typeof w =", typeof w);
  try { console.log(z); }
  catch (e) { console.log("4 reading z too early:", e.name); }
  let z = 3;
  console.log("5 after its declaration: z =", z);
}
demo();
const rate = 5;
function discount(t) { return t * rate / 100; }
function festival(t) { const rate = 20; return discount(t); }
console.log("6 discount(1000) =", discount(1000), "| festival(1000) =", festival(1000));
{ const rate = 10; console.log("7 inner block: rate =", rate); }
console.log("8 outer: rate =", rate);

আসল আউটপুট (ব্রাউজারের JavaScript; Node.js 24-এও একই):

1 before the if: typeof v = undefined | v = undefined
2 inside the block: v = 1 | w = 2
3 after the block: v = 1 | typeof w = undefined
4 reading z too early: ReferenceError
5 after its declaration: z = 3
6 discount(1000) = 50 | festival(1000) = 50
7 inner block: rate = 10
8 outer: rate = 5

লাইন ১: v ঘোষিত হয়েছে নিচে, if-এর ভেতরে, তবু ওপরে পড়লে error নেই, শুধু undefined: var-এর ঘোষণা function শুরু হওয়ার সময়ই নিবন্ধিত হয় (hoisting). লাইন ৩: block শেষ হলেও v = 1 বেঁচে আছে, কারণ সে পুরো function-এর; কিন্তু w block-এর বাইরে অচেনা। লাইন ৪: let z-কে ঘোষণার আগে পড়লে ReferenceError; error-এর বার্তার লেখা browser ভেদে আলাদা, তাই শুধু নাম ছাপা হয়েছে। লাইন ৬: JavaScript static scope মানে, তাই Haat-এর মতোই 50, 50; dynamic হলে 200 আসত। লাইন ৭–৮: block-এর ভেতরের const rate বাইরেরটিকে আড়াল করে, বদলায় না। JavaScript-এর দিক থেকে এই নিয়মগুলোর বিস্তার আছে JavaScript কোর্সের পর্ব ০৭-এ (let, const, var — scope, hoisting আর TDZ).

লাইন ১ আর ৪-এর পেছনের কারণ একটিই: JavaScript একটি scope-এ ঢোকার মুহূর্তে সেই scope-এর সব ঘোষণা নিবন্ধন করে। var তখনই undefined মান পায়; let আর const নিবন্ধিত হয়, কিন্তু মান পায় ঘোষণার লাইন চলার পর। মাঝের সময়টিকে বলে TDZ (temporal dead zone). নিচের stepper-এ একটি সরল সংস্করণ, যা Node.js 24-এ চালিয়ে আউটপুট মেলানো:

1function demo() {2  console.log(typeof v, v);3  if (true) {4    var v = 1;5    let w = 2;6  }7  console.log(v, typeof w);8  try { console.log(z); } catch…9  let z = 3;10  console.log(z);11}
এই ধাপে
function env
block env
নিয়ম
  1. Function-এ ঢোকা। কোনো লাইন চলার আগেই function-এর environment তৈরি হয়: var v পায় undefined, আর let z নিবন্ধিত কিন্তু TDZ-এ। w এখনো নেই, কারণ তার block-এ ঢোকা হয়নি।
  2. v পড়া। v আছে, মান undefined; তাই কোনো error নেই। ছাপা হয় “undefined undefined”. অনেক পুরোনো bug-এর উৎস এটিই: ভুল ক্রমে লেখা কোড চুপচাপ undefined নিয়ে চলতে থাকে।
  3. Block-এ ঢোকা। নতুন একটি block environment তৈরি হয়, যার parent function-এর environment. w এখানে নিবন্ধিত, TDZ-এ।
  4. দুই ঘোষণা। v = 1 লেখা হয় function-এর environment-এ (var block মানে না), আর w = 2 block-এর environment-এ।
  5. Block শেষ। Block environment সরে যায়। v এখনো 1. w কোথাও নেই, আর অঘোষিত নামে typeof error দেয় না, শুধু “undefined” বলে। ছাপা হয় “1 undefined”.
  6. TDZ-এ z. z function-এর environment-এ আছে, কিন্তু তার ঘোষণার লাইন এখনো চলেনি। তাকে পড়া নিষেধ: ReferenceError. লক্ষ করুন, এটি “নাম নেই” error নয়, “নাম আছে কিন্তু এখনো ছোঁয়া যাবে না”।
  7. ঘোষণা চলল। let z = 3; চলার পর TDZ শেষ, z = 3 ছাপা হয়। Haat এই একই নীতি মানে, তবে চলার সময় নয়, compile-এর আগেই (অংশ ৬)।

Python-এ if বা for কোনো scope তৈরি করে না: if-এর ভেতরে প্রথম assign করা নাম পুরো function-এর local (অংশ ৭-এর run দেখুন)। C-তে block scope আছে; আর C99 থেকে for (int i = 0; …)-এর i শুধু loop-এর scope-এ থাকে। C-এর scope-এর পুরো ধরন (block, file, function prototype, আর label-এর function scope) আছে C কোর্সের পর্ব ১৪-এ. Haat-এর নিয়ম (reference-এর সিদ্ধান্ত ১৪): প্রতিটি { }, অর্থাৎ if/else-এর শাখা, while-এর দেহ আর সাধারণ block, একটি নতুন scope; আর একটি function-এর parameter ও তার দেহের ওপরের স্তর একই scope ভাগ করে (C-এর মতো), তাই fn f(n: Int)-এর দেহে let n লিখলে error.

৬ · ঘোষণার আগে ব্যবহার — Haat, C, JavaScript আর Rust-এর নিয়ম

Scope-এর একটি সূক্ষ্ম প্রশ্ন: একটি ঘোষণার scope ঠিক কোথা থেকে শুরু? Block-এর শুরু থেকে, নাকি ঘোষণার লাইন থেকে? প্রশ্নটি খেলনা মনে হলেও উত্তরটি ভাষাভেদে আলাদা, আর এই পার্থক্য সত্যিকারের bug তৈরি করে। নিচের Haat ফাইলে চারটি নাম-সংক্রান্ত ভুল:

let rate = 10;
fn bill(t: Int) -> Int {
    let cut = t * rate / 100;
    let rate = 20;
    return t - cut;
}
{ let a = a + 1; }
print(totl);
let rate = 3;
~/haat $ python haat.py check before.haat
3:19: error: 'rate' is used before its declaration
7:11: error: 'a' is used before its declaration
8:7: error: undefined variable 'totl'
9:5: error: 'rate' is already declared in this scope

সত্যিকারের run (reference-এর resolver সব নাম-error একসঙ্গে জানায়, অবস্থান অনুযায়ী সাজিয়ে)। প্রথম error-টি সবচেয়ে শিক্ষণীয়। লাইন ৩-এ rate ব্যবহার হয়েছে, আর বাইরে global-এ rate = 10 আছে; তবু error. কারণ Haat-এর নিয়ম (reference-এর সিদ্ধান্ত ১৬): একটি block যদি x কোথাও ঘোষণা করে, তবে সেই block-এ (বা তার ভেতরের block বা function-এ) ঘোষণার আগে x ব্যবহার করা error, বাইরে x থাকলেও। { let a = a + 1; }-ও একই কারণে error: নতুন a-এর নিজের initializer-ও “ঘোষণার আগে”। ভাষাগুলো এখানে তিন দলে ভাগ হয়:

ভাষাভেতরের নাম কোথা থেকে দেখা যায়let cut = rate…; let rate = 20;let a = a + 1; (বাইরে a আছে)
C17ঘোষণা (declarator) শেষ হওয়ার ঠিক পর থেকে (মানদণ্ডের 6.2.1)বাইরের rate পড়েনতুন, এখনো মান-না-পাওয়া a পড়ে; মান অনির্দিষ্ট, ভরসাযোগ্য নয় (Clang-এর মতো compiler সতর্ক করতে পারে)
Rustঘোষণার statement শেষ হওয়ার পর থেকেবাইরের rate পড়েবাইরের a পড়ে (shadowing-এর স্বাভাবিক ব্যবহার)
JavaScript (let/const)পুরো block জুড়ে, কিন্তু ঘোষণা চলার আগে TDZচলার সময় ReferenceErrorচলার সময় ReferenceError
Haatপুরো block জুড়ে, JavaScript-এর let-এর মতোcompile-এর আগেই errorcompile-এর আগেই error

C আর Rust-এ এই কোড বৈধ, আর এক লাইনের দূরত্বে একই নাম দুটি আলাদা variable বোঝায়: পাঠকের জন্য বিভ্রান্তিকর। Haat (JavaScript-এর মতো) নিয়মটিকে কঠোর করেছে, কিন্তু JavaScript যেখানে চলার সময় সেই লাইনে পৌঁছালে তবেই ধরে, Haat ধরে program চালানোর আগেই। এটি পর্ব ০৩-এর static semantics-এর একটি উদাহরণ: “ব্যবহারের আগে ঘোষণা” কোনো context-free grammar দিয়ে লেখা যায় না, তাই parser নয়, resolver এটি দেখে।

Hoisting: function-এর ব্যতিক্রম

একটি নিয়মের ব্যতিক্রম আছে। Haat-এ শুধু top-level function hoisted: পুরো program-এর শুরু থেকেই দেখা যায়, তাই দুটি function একে অপরকে ডাকতে পারে (mutual recursion). কিন্তু এতে একটি ফাঁক তৈরি হয়:

print(total_with_vat(1000));
fn total_with_vat(t: Int) -> Int { return t + vat(t); }
fn vat(t: Int) -> Int { return t * 15 / 100; }
print(early());
let k = 7;
fn early() -> Int { return k; }
~/haat $ python haat.py run hoist.haat
1150
6:28: runtime error: 'k' is not initialized yet

প্রথম লাইন ঠিকঠাক চলে: total_with_vat আর vat ঘোষণার আগেই ডাকা যায়, ফল 1000 + 150 = 1150. কিন্তু early-এর দেহে k ব্যবহার বৈধ (Haat-এর নিয়মে function-এর আগে ঘোষিত top-level variable function ব্যবহার করতে পারে, সিদ্ধান্ত ১৮), তবু early() ডাকা হয়েছে let k = 7; চলার আগে। Compiler এখানে নিশ্চিত হতে পারে না কখন ডাকা হবে, তাই এই পরীক্ষাটি চলার সময় হয়, run আর vm দুটিতেই একই বার্তা দিয়ে। Scope একটি static ধারণা, কিন্তু initialization-এর সময় dynamic; Haat-এর নকশা দুটির সীমানা স্পষ্ট রাখে।

৭ · Global, local আর Python-এর global/nonlocal

Python static scope মানে, কিন্তু তার একটি নিজস্ব নিয়ম আছে, যা নতুনদের প্রায়ই অবাক করে: Python-এ নাম ঘোষণার আলাদা কোনো শব্দ নেই, তাই একটি function-এর ভেতরে কোথাও কোনো নামে assign করলেই সেই নাম পুরো function-এর local হয়ে যায়, assignment-এর আগের লাইনেও। নাম খোঁজার ক্রম LEGB: Local, Enclosing (ঘিরে থাকা function), Global (module), Built-in. বাইরের নামে assign করতে হলে স্পষ্টভাবে বলতে হয়: module-এর নামের জন্য global, ঘিরে থাকা function-এর নামের জন্য nonlocal.

rate = 5                                   # module (global) scope
def read_only():
    return rate                            # no assignment here: the global rate
def broken():
    try:
        before = rate                      # rate is LOCAL here: it is assigned below
        rate = 20
        return before
    except UnboundLocalError as e:
        return f"UnboundLocalError: {e}"
def set_global():
    global rate                            # assignments now go to the module's rate
    rate = 7
def make_counter():
    count = 0
    def tick():
        nonlocal count                     # the enclosing function's count
        count += 1
        return count
    return tick
class Shop:
    rate = 15                              # a class body is NOT an enclosing scope
    def get(self): return rate             # skips Shop.rate, finds the global
print("read_only :", read_only())
print("broken    :", broken())
set_global(); print("set_global: rate =", rate)
tick = make_counter(); tick(); print("counter   :", tick())
print("Shop().get():", Shop().get(), "  Shop.rate:", Shop.rate)
if True:
    inside_if = "visible"                  # no block scope for an if in Python
print("after if  :", inside_if)
squares = [i * i for i in range(3)]
print("comprehension variable i leaked?", "i" in globals())

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

read_only : 5
broken    : UnboundLocalError: cannot access local variable 'rate' where it is not associated with a value
set_global: rate = 7
counter   : 2
Shop().get(): 7   Shop.rate: 15
after if  : visible
comprehension variable i leaked? False

read_only শুধু পড়ে, তাই global 5. broken-এ পরের লাইনে rate = 20 থাকায় Python compile-এর সময়েই rate-কে এই function-এর local ধরেছে; প্রথম লাইনে তাই global-এ যাওয়া হয়নি, বরং মান-না-পাওয়া local পড়ার চেষ্টা: UnboundLocalError. লক্ষ করুন, এটি Haat-এর “used before its declaration” নিয়মের প্রায় হুবহু চলার-সময়ের রূপ। set_global-এর পর global rate 7, আর nonlocal দিয়ে counter-এর অবস্থা ঘিরে থাকা function-এ জমেছে (দুই call পরে 2). Shop().get() দেখায় 7, 15 নয়: class-এর দেহ method-গুলোর জন্য ঘিরে থাকা scope নয়, তাই খোঁজা সোজা global-এ যায়। if-এর ভেতরের নাম বাইরে দেখা যায় (block scope নেই), কিন্তু comprehension-এর i বাইরে আসে না (Python 3-এ comprehension-এর নিজের scope). Python-এর দিক থেকে বিস্তার Python কোর্সের পর্ব ২০-এ.

এক কথায়, প্রতিটি ভাষার নিয়ম তিনটি প্রশ্নের উত্তর: (১) কোন কাঠামো নতুন scope তৈরি করে (block, function, class, module, comprehension)? (২) একটি ঘোষণার scope কোথা থেকে শুরু (block-এর শুরু নাকি ঘোষণার লাইন)? (৩) বাইরের নামে লেখা যায় কি না, আর গেলে কীভাবে (Haat-এ var হলে সরাসরি; Python-এ global/nonlocal লাগে)? JavaScript-এ ঘোষণা ছাড়া assign করলে sloppy mode-এ চুপচাপ একটি global তৈরি হয়, আর strict mode-এ ReferenceError; এই ধরনের পার্থক্যই AI-এর ভুলের বড় উৎস। আর eval বা JavaScript-এর with-এর মতো সুবিধা চলার সময় নতুন নাম ঢুকিয়ে static scope-এর নিশ্চয়তা নষ্ট করতে পারে; সেজন্য ECMAScript 5-এর strict mode with নিষিদ্ধ করেছে (পর্ব ১২-এ eval-এর ঝুঁকি)।

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

  • Static আর dynamic scope-এর পার্থক্য কী? Static-এ free variable খোঁজা হয় function যেখানে লেখা সেখান থেকে বাইরে; dynamic-এ call stack ধরে, যে ডেকেছে তার কাছে।
  • “নিচের program static আর dynamic scope-এ কী ছাপবে?” প্রতিটি call-এর জন্য দুটি parent লিখুন: লেখার জায়গা আর caller; তারপর দুই শিকল ধরে আলাদা হিসাব করুন (অনুশীলন ৩)।
  • Referencing environment কী? একটি statement থেকে দেখা যায় এমন সব নাম; static-এ নিজের আর ঘিরে থাকা scope-এর, dynamic-এ নিজের আর সক্রিয় সব function-এর।
  • JavaScript-এ var আর let-এর পার্থক্য? var function scope, hoisted হয়ে undefined পায়; let block scope, ঘোষণার আগে TDZ.
  • Static link কী কাজে লাগে? Nested function-এর বাইরের local খুঁজতে লেখার দিক থেকে ঘিরে থাকা function-এর frame-এ যাওয়ার pointer.

৮ · AI-এর যুগে scope

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

AI-এর ভুলকীভাবে ধরবেন
এক ভাষার নিয়ম সবখানে চাপানো: “Python-এ if block নতুন scope বানায়”, বা “C-তে int a = a + 1; বাইরের a পড়ে”নির্দিষ্ট ভাষা আর version-এ ছোট program চালিয়ে দেখা; ভাষার মানদণ্ডে scope-এর অংশ পড়া
Static/dynamic প্রশ্নে দুই উত্তর গুলিয়ে ফেলা, বা ধরে নেওয়া bash-ও JavaScript-এর মতো lexicalদুই নিয়মে হাতে হিসাব; bash বা Perl-এর local দিয়ে আসল run
“var আর let-এর পার্থক্য শুধু নতুন syntax” বা “let hoisted হয় না” (আসলে নিবন্ধিত হয়, কিন্তু TDZ-এ থাকে)ঘোষণার আগে পড়ে দেখা: var হলে undefined, let হলে ReferenceError
Refactor করার সময় একটি local-এর নাম বদলে দেওয়া, যা ভেতরের function-এর একটি বাইরের নামকে ধরে ফেলে (অনুশীলন ২-এর মতো)Refactor-এর আগে আর পরে একই test চালানো; নতুন নামটি ওই scope-এ আগে থেকে আছে কি না দেখা
Python-এ UnboundLocalError “ঠিক” করতে অপ্রয়োজনে global বসিয়ে দেওয়াআসলে কোন variable বদলানো দরকার তা ঠিক করা; প্রায়ই মান ফেরত দেওয়াই ভালো সমাধান

AI-কে ভালোভাবে কাজে লাগানোর উপায়: উত্তরের সঙ্গে যুক্তির পথ আর যাচাইয়ের program চাওয়া, তারপর নিজে চালিয়ে মেলানো।

আমি প্রোগ্রামিং ভাষার scope-এর নিয়ম শিখছি। নিচের program-টি static scope আর dynamic scope দুই নিয়মে কী ছাপবে বলো: x = 1 show() { return x } two() { local x = 2; return show() } three() { local x = 3; return two() * 10 + show() } print three(); print show() ১. প্রতিটি call-এর জন্য দুটি parent লেখো: যেখানে function লেখা আর যে ডেকেছে। ২. দুই নিয়মে প্রতিটি x কোন ঘোষণা থেকে এল, ধাপে ধাপে দেখাও। ৩. Static নিয়ম যাচাইয়ের জন্য Python বা JavaScript-এ, আর dynamic নিয়মের জন্য bash-এ (local দিয়ে) চালানো যায় এমন program লিখে দাও। ৪. কোনো আউটপুট অনুমান করে লিখবে না; কোনগুলো আমাকে চালিয়ে মেলাতে হবে, আলাদা করে বলো।

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

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

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

প্র ০১প্রথম দিকের LISP কেন dynamic scope পেল, আর John McCarthy নিজে একে কীভাবে দেখেছিলেন?

John McCarthy-র LISP (১৯৫৮–৬০) একটি অসাধারণ ছোট interpreter দিয়ে সংজ্ঞায়িত হয়েছিল: eval নামের একটি function, যা একটি expression আর একটি “association list” (নাম আর মানের জোড়ার একটি সরল তালিকা) নেয়। Function ডাকা হলে parameter-গুলোর জোড়া তালিকার সামনে বসানো হতো, আর কোনো নাম খুঁজতে তালিকার শুরু থেকে প্রথম মিল নেওয়া হতো। এই বাস্তবায়নে তালিকাটি স্বাভাবিকভাবেই call-এর ক্রম অনুসরণ করে, ফলে যে function ডেকেছে তার নামগুলো ভেতর থেকে দেখা যায়। অর্থাৎ dynamic scope কোনো সচেতন নকশা ছিল না; এটি ছিল সবচেয়ে সরল interpreter-এর স্বাভাবিক ফল, ঠিক এই পর্বের Python interpreter-এর parent = env লাইনের মতো।

সমস্যা ধরা পড়ে যখন function-কে argument হিসেবে পাঠানো শুরু হয়। McCarthy-র “History of Lisp” (১৯৭৮ সালের ইতিহাস সম্মেলনের জন্য লেখা) অনুযায়ী James Slagle একটি function লিখেছিলেন, যা ঠিক কাজ করছিল না, কারণ পাঠানো function-এর ভেতরের একটি নাম ভুল জায়গার মান পাচ্ছিল। McCarthy সেখানে স্বীকার করেন, তিনি প্রথমে একে নিছক একটি bug ভেবেছিলেন, যা Steve Russell শিগগিরই ঠিক করে দেবেন। Russell সমাধান দেন “FUNARG device” দিয়ে: function-এর সঙ্গে তার তৈরির সময়ের environment জুড়ে রাখা, যা আসলে আজকের closure-এর পূর্বসূরি।

কিন্তু LISP-এর মূল নিয়ম বহু বছর dynamic রয়ে গেল, কারণ বাস্তবায়ন সহজ, আর শুধু function-কে মান হিসেবে পাঠালেই সমস্যা দেখা যায়। ১৯৭০ সালে Joel Moses-এর “The Function of FUNCTION in LISP” লেখাটি সমস্যাটিকে স্পষ্ট নাম আর বিশ্লেষণ দেয়, আর এই সমস্যার দুই রূপ পরে “downward” (function নিচের call-এ পাঠানো) আর “upward” (function ফেরত দেওয়া) funarg নামে পরিচিত হয়। Upward funarg-এর জন্য environment-কে call শেষ হওয়ার পরও বাঁচিয়ে রাখতে হয়, যা stack-ভিত্তিক বাস্তবায়নে কঠিন; এই প্রশ্নটি পর্ব ১৬ আর ১৭-এর মূল বিষয়।

মূল উপলব্ধি: ভাষার semantics অনেক সময় প্রথম বাস্তবায়নের সুবিধা থেকে জন্ম নেয়। একটি নিয়ম “স্বাভাবিক” মনে হলেই সঠিক নয়; function-কে মান হিসেবে ব্যবহার করলে তবেই dynamic scope-এর আসল দাম বোঝা যায়।

প্র ০২Scheme কীভাবে Lisp পরিবারে lexical scope আনল, আর Emacs Lisp কেন এত দিন dynamic রয়ে গেল?

১৯৭৫ সালে MIT-তে Gerald Jay Sussman আর Guy L. Steele Jr. Carl Hewitt-এর actor মডেল বুঝতে একটি ছোট Lisp লেখেন, যার নাম হয় Scheme. তাঁদের মূল সিদ্ধান্ত ছিল ALGOL-এর মতো lexical scope, আর function মান মানেই closure (দেহ আর সংজ্ঞার environment). এতে funarg সমস্যা নীতিগতভাবেই উঠে যায়: function যেখানেই চলুক, তার free variable সংজ্ঞার environment-এ খোঁজা হয়। তাঁরা দেখান, closure আর lambda দিয়ে loop, object, এমনকি actor-ও প্রকাশ করা যায়, যা পরের “Lambda: The Ultimate …” ধারাবাহিক লেখাগুলোর বিষয়।

Scheme-এর প্রভাবে Common Lisp (মানদণ্ডের প্রথম বড় বই ১৯৮৪) lexical scope-কে ডিফল্ট করে, কিন্তু dynamic scope পুরোপুরি বাদ দেয়নি: defvar বা special ঘোষণা দিয়ে কোনো variable-কে “special” করা যায়, যা dynamic নিয়মে চলে। প্রচলিত রীতিতে এমন নাম তারকা দিয়ে লেখা হয়, যেমন *print-base*, যাতে পাঠক দেখেই বোঝেন এটি আলাদা নিয়মের।

Emacs Lisp-এর ইতিহাস আলাদা। Editor-এ প্রায়ই দরকার হয় “এই কাজটুকুর সময় একটি সেটিং বদলে নাও, তারপর আগের মানে ফিরে যাও”, যেমন একটি search-এর সময় বড়-ছোট হাতের অক্ষর আলাদা না ধরা। Dynamic binding-এ এটি এক লাইনে হয়: সেটিং-এর variable-কে let দিয়ে নতুন মান দিন, আর ভেতরে যত function ডাকা হোক সবাই সেটি দেখবে; শেষে নিজে থেকেই পুরোনো মান ফেরে। Richard Stallman-এর ১৯৮১ সালের EMACS-বিষয়ক লেখায় এই ধরনের extensibility-র জন্য dynamic scope-এর পক্ষে যুক্তি দেওয়া হয়েছে বলে উল্লেখ পাওয়া যায়। তাই Emacs 24 (২০১২)-এ এসে ফাইলভিত্তিক lexical-binding বিকল্প যোগ হয়, যাতে পুরোনো কোড না ভেঙে নতুন কোড lexical হতে পারে।

মূল উপলব্ধি: Dynamic scope-এর একটি সত্যিকারের ব্যবহার আছে: “এই কাজের সময়টুকুর জন্য একটি প্রসঙ্গ-মান”। আধুনিক ভাষাগুলো তাই নিয়মটিকে ডিফল্ট না রেখে নির্দিষ্ট, স্পষ্টভাবে চিহ্নিত variable-এর জন্য রাখে।

প্র ০৩Python-এ nested function-এর scope আর nonlocal এত দেরিতে এল কেন, আর “assign করলেই local” নিয়মের দাম কী?

প্রথম দিকের Python-এ নাম খোঁজার মাত্র তিনটি জায়গা ছিল: চলতি function-এর local, module-এর global, আর built-in. একটি function-এর ভেতরে আরেকটি function লেখা যেত, কিন্তু ভেতরেরটি বাইরের function-এর local দেখতে পেত না; সেগুলো খুঁজতে গেলে সরাসরি global-এ চলে যেত। প্রচলিত কৌশল ছিল default argument দিয়ে মান ভেতরে পাঠানো, যেমন lambda t, rate=rate: …. PEP 227 (“Statically Nested Scopes”) এটি বদলায়: Python 2.1 (২০০১)-এ from __future__ import nested_scopes দিয়ে চালু করা যেত, আর Python 2.2-তে এটি ডিফল্ট হয়। তখন থেকে নিয়মটি LEGB.

কিন্তু Python-এ ঘোষণার কোনো শব্দ নেই; একটি নাম local কি না, compiler ঠিক করে function-এর ভেতরে কোথাও তাতে assign আছে কি না দেখে। ফলে ভেতরের function বাইরের variable পড়তে পারত, কিন্তু বদলাতে পারত না: assign করলেই সেটি নতুন local হয়ে যেত। বহু বছর কৌশল ছিল একটি list-এ মান রেখে box[0] += 1 লেখা। PEP 3104 এই ফাঁক বন্ধ করে nonlocal দিয়ে, যা Python 3.0 (২০০৮)-এ আসে।

“Assign করলেই local” নিয়মের দাম এই পর্বের UnboundLocalError: function-এর শেষে একটি assignment যোগ করলে শুরুর দিকের একটি পড়ার লাইন হঠাৎ ভেঙে যায়, যদিও সেই লাইনে কিছু বদলায়নি। লাভও আছে: CPython compile-এর সময়েই জানে কোন নাম local, তাই local-গুলোকে নাম ধরে dictionary-তে না খুঁজে frame-এর একটি array-র নির্দিষ্ট ঘরে রাখে (LOAD_FAST জাতীয় bytecode). এটি ঠিক অংশ ৪-এর “static scope-এ ঠিকানা আগেই জানা”-র সুবিধা; CPython-এর bytecode বিস্তারে আসবে পর্ব ৬০-এ।

মূল উপলব্ধি: ঘোষণার শব্দ (let, var) না রাখার সরলতা বিনামূল্যে আসে না; তখন scope ঠিক করার নিয়মটি assignment-এর ওপর নির্ভর করে, আর একটি দূরের লাইন কাছের লাইনের অর্থ বদলে দিতে পারে। Haat-এর let/var এই প্রশ্নটি লেখাতেই স্পষ্ট করে।

প্র ০৪JavaScript-এ var-এর function scope কেন সমস্যা ছিল, আর ECMAScript 2015 TDZ-এর মতো জটিল নিয়ম কেন বেছে নিল?

১৯৯৫ সালে খুব অল্প সময়ে তৈরি JavaScript-এ variable ঘোষণার একটিই উপায় ছিল, var, আর তার scope পুরো function. C বা Java থেকে আসা প্রোগ্রামাররা ধরে নিতেন if বা for-এর ভেতরের var শুধু সেখানে থাকবে; বাস্তবে তা পুরো function-এ ছড়িয়ে পড়ত। সবচেয়ে বিখ্যাত ফল: একটি loop-এ বানানো কয়েকটি callback সবাই একই var i ভাগ করে, তাই loop শেষের মান দেখে। প্রতিকার হিসেবে IIFE (তৎক্ষণাৎ ডাকা function) লিখে একটি নতুন function scope বানানো হতো, শুধু একটি block-এর আলাদা variable পাওয়ার জন্য। এর বিস্তার পর্ব ১৭-এ।

ECMAScript 2015 (ES6) let আর const আনে block scope নিয়ে। নকশাকারীদের সামনে প্রশ্ন ছিল: block-এর ভেতরে ঘোষণার আগে নামটি ব্যবহার করলে কী হবে? তিনটি পথ ছিল: (১) C-এর মতো বাইরের নাম দেখা; (২) var-এর মতো undefined দেওয়া; (৩) error. প্রথমটি একই block-এ একই নামকে দুই অর্থ দিত। দ্বিতীয়টি const-এর জন্য অসম্ভব, কারণ তাহলে একটি constant-কে দুটি মানে (আগে undefined, পরে আসল মান) দেখা যেত। তাই বেছে নেওয়া হয় তৃতীয়টি: নামটি পুরো block জুড়ে আছে, কিন্তু ঘোষণার লাইন চলার আগে তাকে ছোঁয়া ReferenceError. এই সময়টুকুই TDZ. JavaScript-এ এটি চলার সময় ধরা পড়ে, কারণ function hoisting আর dynamic ক্রমের জন্য compile-এর আগে সবক্ষেত্রে নিশ্চিত হওয়া যায় না।

আরেকটি পরিবর্তন আগেই হয়েছিল: ECMAScript 5 (২০০৯)-এর strict mode with statement নিষিদ্ধ করে, যা একটি object-এর property-গুলোকে চলার সময় scope-এ ঢুকিয়ে দিত, ফলে x লিখলে সেটি local নাকি object-এর property তা আগে থেকে বলা যেত না। Strict mode ঘোষণা ছাড়া assign-কেও error বানায়। দুটিই lexical scope-কে compiler আর পাঠকের কাছে নির্ভরযোগ্য রাখার পদক্ষেপ।

মূল উপলব্ধি: একটি জনপ্রিয় ভাষা পুরোনো নিয়ম মুছতে পারে না; সে নতুন, ভালো নিয়ম পাশে যোগ করে আর পুরোনোটিকে strict mode বা lint দিয়ে নিরুৎসাহিত করে। Haat-এর মতো নতুন ভাষা প্রথম দিন থেকেই কঠোর নিয়ম বেছে নিতে পারে।

প্র ০৫Dynamic scope কি পুরোপুরি হারিয়ে গেছে? আধুনিক ভাষায় এর রূপ কোথায় দেখা যায়?

সাধারণ variable-এর জন্য dynamic scope প্রায় হারিয়ে গেছে, কিন্তু এর মূল ধারণা, “চলতি call-এর পুরো সময়টুকুর জন্য একটি প্রসঙ্গ-মান, যা ভেতরে ডাকা সব কোড দেখে”, আধুনিক ভাষায় বারবার ফিরে এসেছে, তবে নিয়ন্ত্রিত আর স্পষ্টভাবে চিহ্নিত রূপে।

সবচেয়ে পরিচিত উদাহরণ exception handler. try block-এর ভেতরে যে function-ই ডাকা হোক, কোথাও exception উঠলে কোন handler ধরবে তা ঠিক হয় call stack দেখে, কোড কোথায় লেখা তা দেখে নয়: এটি পুরোপুরি dynamic নিয়ম। পর্ব ২৮-এ (Exception handling) stack unwinding-এ এটি দেখবেন। Shell-এর environment variable-ও একই রকম: একটি process তার child process-কে নিজের পরিবেশ উত্তরাধিকার হিসেবে দেয়।

ভাষার ভেতরেও স্পষ্ট সুবিধা আছে। Racket-এর “parameter” আর parameterize একটি মানকে নির্দিষ্ট হিসাবের সময়টুকুর জন্য বদলায়; Common Lisp-এর special variable একই কাজ করে। Python 3.7-এর contextvars async কোডে প্রতিটি কাজের নিজস্ব প্রসঙ্গ-মান রাখে, যেমন অনুরোধের id বা দশমিকের নির্ভুলতা; Python-এর decimal module-এর localcontext() একটি with block-এর সময়ের জন্য হিসাবের নির্ভুলতা বদলায়। React-এর context বা অনেক web framework-এর “request-scoped” মানও একই ধারণার প্রকৌশলী রূপ।

এদের সবার মিল: dynamic আচরণ শুধু নির্দিষ্ট, নাম দেখেই চেনা যায় এমন কিছু মানের জন্য, আর সাধারণ local variable থাকে lexical. ফলে উপপাদ্য ১৫.১-এর নিশ্চয়তা বেশির ভাগ কোডে টিকে থাকে, আর যেখানে প্রসঙ্গ-মান দরকার সেখানে তা স্পষ্ট। Haat v1-এ এমন কিছু নেই; পর্ব ৭৯-এ (DSL নকশা) এমন ধারণা নিয়ে ভাবার সুযোগ পাবেন।

মূল উপলব্ধি: ভালো ভাষা-নকশা কোনো ধারণাকে পুরোপুরি বাদ দেয় না, বরং তার নিরাপদ জায়গা খুঁজে দেয়। Dynamic scope ডিফল্ট হিসেবে বিপজ্জনক, কিন্তু চিহ্নিত প্রসঙ্গ-মান হিসেবে অত্যন্ত কাজের।

অনুশীলন

প্রথমে নিজে করুন, তারপর উত্তর খুলে মেলান। Haat-এর প্রতিটি আউটপুট কোর্সের reference বাস্তবায়নে, আর Python, JavaScript, bash ও Perl-এর আউটপুট সত্যিকারের Python 3.14, Node.js 24, GNU bash 5.2 আর Perl 5.38-এ চালিয়ে মেলানো।

  1. বাস্তবায়ন — shadowing সতর্কবার্তা: অংশ ৪-এর resolve.py-তে এমন পরিবর্তন করুন, যাতে কোনো নাম ঘোষণার সময় বাইরের কোনো scope-এ একই নাম আগে থেকে থাকলে warning: shadows an outer 'x' লেখা হয় (GCC-এর -Wshadow-এর মতো)। chain.haat আর broken.haat-এ কোথায় কোথায় সতর্কবার্তা আসবে?

    declare-এ নতুন নাম বসানোর আগে তিন লাইন যোগ করলেই চলে:

        def declare(x):
            if x not in scope["names"]:
                if any(x in sc["names"] for sc in chain[:-1]):
                    out.append(f"{x:9} warning: shadows an outer '{x}'")
                scope["names"][x] = (depth, nslots[0]); nslots[0] += 1
            scope["later"].discard(x)

    চালানো ফল: chain.haat-এ প্রথম লাইনেই rate warning: shadows an outer 'rate' (order_total-এর rate global-এর rate আড়াল করে), বাকি লাইন আগের মতো। broken.haat-এর শেষে আবার rate warning: shadows an outer 'rate', bill-এর ভেতরের rate-এর জন্য। লক্ষ করুন, discount-এর parameter t-এর জন্য কোনো সতর্কবার্তা আসেনি, যদিও order_total-এ পরে একটি t ঘোষিত; কারণ discount ঘোষণার মুহূর্তে বাইরের t এখনো "later" তালিকায়, "names"-এ নয়। এটি একটি নকশাগত সিদ্ধান্ত: চাইলে "later"-ও দেখতে পারেন। Shadowing বৈধ, তাই এটি error নয়, শুধু সতর্কবার্তা; অনেক দল code review-তে একে চালু রাখে, কারণ অনিচ্ছাকৃত shadowing অংশ ৬-এর মতো bug আনে।

  2. ভুল খুঁজুন — “নাম বদলে কিছু হয় না”: একজন chain.haat-এ order_total-এর let rate = 10;-কে let limit = 10; বানালেন, আর discount-এর t * rate / 100-কে t * limit / 100. তাঁর যুক্তি: “উপপাদ্য ১৫.১ বলে static scope-এ নাম বদলালে অর্থ বদলায় না।” order_total(2, 520) আর order_total(3, 120) এখন কত? ভুলটি কোথায়?

    Haat reference-এ চালানো ফল: 936 আর 324 (আগে ছিল 936 আর 360). নতুন নাম limit “নতুন” নয়: program-এ global limit = 1000 আগে থেকেই আছে, আর discount-এর শর্ত t >= limit সেটিই পড়ত। নাম বদলের পর এই limit ধরা পড়ে গেল order_total-এর নতুন limit = 10-এর হাতে (একে বলে variable capture). ফলে 360 ≥ 10 সত্য হয়ে 36 টাকা ছাড় পড়ল: 360 − 36 = 324. উপপাদ্যের শর্ত ছিল “y program-এ আগে কোথাও নেই”; সেটি ভাঙায় প্রমাণের ধাপ ৩ খাটে না। একই বদল pct নামে করলে (যা কোথাও নেই) reference-এ ফল আবার 936 আর 360. IDE-র “rename” সুবিধা ঠিক এই পরীক্ষা করে, আর সংঘর্ষ থাকলে সতর্ক করে।

  3. আউটপুট অনুমান করুন: (ক) নিচের Haat program static scope-এ কী ছাপবে? একই গঠনের program dynamic scope-এ কী ছাপত?
    let x = 1;
    fn show() -> Int { return x; }
    fn two() -> Int { let x = 2; return show(); }
    fn three() -> Int { let x = 3; return two() * 10 + show(); }
    print(three());
    print(show());
    (খ) JavaScript-এ var a = 1; { var a = 2; } let b = 1; { let b = 2; } console.log(a, b); কী ছাপবে?

    (ক) Static: show global-এ লেখা, তাই তার x সবসময় global-এর 1. two() = 1; three() = 1 × 10 + 1 = 11; শেষে show() = 1. Haat reference-এর আসল আউটপুট 11 আর 1.

    Dynamic: two() থেকে show() ডাকলে caller two, যার x = 2, তাই two() = 2. three()-এর ভেতরে two() = 2, আর three() থেকে সরাসরি show() ডাকলে caller three, যার x = 3. তাই three() = 2 × 10 + 3 = 23. শেষে global থেকে show() = 1. একই গঠন bash-এ (local x=2, local x=3) আর Perl-এ (local $x) চালানো ফল: 23 আর 1. লক্ষ করুন, dynamic নিয়মে একই show() একটি program-এ তিনটি আলাদা মান (2, 3, 1) দিল।

    (খ) Node.js-এ চালানো ফল: 2 1. var block মানে না, তাই ভেতরের var a = 2 একই global a-কে বদলায়। let b = 2 block-এর নিজস্ব নতুন b, যা বাইরের b-কে শুধু আড়াল করে।

  4. Trace — Python-এর global আর nonlocal: নিচের Python 3.14 program কী ছাপবে? প্রতিটি assignment কোন scope-এর x বদলায়, বলুন।
    x = "global"
    def outer():
        x = "outer"
        def inner():
            nonlocal x
            x = "changed"
        def other():
            global x
            x = "g-changed"
        inner(); other()
        return x
    print(outer(), x)

    চালানো ফল: changed g-changed. outer-এর x = "outer" outer-এর নিজের local (assign আছে, তাই local). inner-এর nonlocal x নিকটতম ঘিরে থাকা function-এর x, অর্থাৎ outer-এর x-কে বদলে "changed" করে। other-এর global x outer-কে টপকে সরাসরি module-এর x-কে "g-changed" করে; outer-এর x-এ হাত দেয় না। তাই outer ফেরত দেয় নিজের x, "changed", আর print-এর দ্বিতীয় argument module-এর x, "g-changed". দুই শব্দই LEGB-র নির্দিষ্ট স্তরে লেখার অনুমতি; কোনোটিই dynamic নয়, কারণ কোন x বদলাবে তা কোড পড়েই ঠিক।

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

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

ক্রমHaat reference-এ একটি program যে ক্রমে প্রক্রিয়া হয়, আর কোন ধাপে কোন নাম-সংক্রান্ত ভুল ধরা পড়ে, সেই ক্রমে সাজান (▲▼ চেপে সরান)

  1. Lexer লেখাকে token-এ ভাঙে; নাম তখনো শুধু IDENT token
  2. Parser token থেকে AST বানায়; scope-এর কোনো যাচাই এখনো হয়নি
  3. Resolver প্রতিটি নাম-ব্যবহারকে ঘোষণার সঙ্গে জোড়ে: undefined variable আর used before its declaration এখানে ধরা পড়ে
  4. Type checker প্রতিটি নামের পাওয়া ঘোষণা থেকে type মেলায়
  5. Interpreter বা VM চালায়: hoisted function আগে ডাকলে 'k' is not initialized yet এখানে ধরা পড়ে

নিচের program-এ rate = 5 global, discount(t) ফেরত দেয় t * rate / 100, আর festival(t)-এর ভেতরে local rate = 20 রেখে discount(t) ফেরত দেওয়া হয়। দুটি function-ই top-level-এ লেখা। Dynamic scope-এ festival(1000) কত?

  • 50
  • 200
  • 250
  • Error, কারণ rate দুবার ঘোষিত

JavaScript (strict mode)-এ একটি function-এর ভেতরে console.log(typeof v, v); if (true) { var v = 1; let w = 2; } console.log(v, typeof w); চালালে দুই লাইনে কী ছাপা হয়?

  • প্রথম লাইনেই ReferenceError
  • undefined undefined, তারপর 1 2
  • undefined undefined, তারপর 1 undefined
  • undefined undefined, তারপর undefined undefined

Python 3-এ rate = 5 global থাকার পর def f(): print(rate); rate = 20 লিখে f() ডাকলে UnboundLocalError আসে কেন?

  • f-এর ভেতরে কোথাও rate-এ assign আছে, তাই rate পুরো f-এর local; print-এর সময় সেটি এখনো মান পায়নি
  • Python dynamic scope মানে, তাই caller-এর rate খোঁজা হয়
  • Python-এ function থেকে কখনো global পড়া যায় না
  • print-এর ভেতরে assignment নিষেধ

বাইরে a ঘোষিত থাকা অবস্থায় একটি block-এর ভেতরে let a = a + 1; লিখলে Haat (কোর্সের reference) কী করে?

  • বাইরের a পড়ে, নতুন a = বাইরের a + 1
  • নতুন, মান-না-পাওয়া a পড়ে
  • চলার সময় ReferenceError দেয়
  • চালানোর আগেই error দেয়: 'a' is used before its declaration

Static scope-এর একটি ভাষায় একটি function-এর ভেতরের একটি statement-এর referencing environment-এ কোন নামগুলো থাকে?

  • নিজের local আর call stack-এর সব সক্রিয় function-এর দেখা যায় এমন নাম
  • নিজের local আর লেখার দিক থেকে ঘিরে থাকা সব scope-এর, আড়াল না হওয়া নাম
  • শুধু নিজের local নাম
  • Program-এ ঘোষিত সব নাম

কেন static scope-এর ভাষায় compiler একটি nested function-এর বাইরের variable-এর জন্য “২ স্তর বাইরে, slot 1”-এর মতো স্থির ঠিকানা আগে থেকে দিতে পারে, কিন্তু dynamic scope-এ পারে না?

  • Dynamic scope-এর ভাষা compile করা যায় না, শুধু interpret করা যায়
  • Static scope-এ variable-এর সংখ্যা কম
  • Static scope-এ নামটি কোন ঘোষণা, তা লেখার কাঠামো থেকেই ঠিক; dynamic-এ তা চলার সময়ের call পথের ওপর নির্ভর করে
  • Static scope-এ shadowing নিষিদ্ধ

শব্দকোষ

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

মনে রাখুন

  1. Scope: একটি ঘোষণা program-এর কোন অংশে দেখা যায়; referencing environment হলো একটি জায়গা থেকে দেখা যায় এমন সব নাম। Scope জায়গার ধারণা, lifetime সময়ের।
  2. Static বনাম dynamic: static-এ free variable খোঁজা হয় লেখার জায়গা থেকে বাইরে (App-Static-এ ρd), dynamic-এ caller-এর শিকল ধরে (ρ)। festival program: Haat 50, 50; bash 50, 200.
  3. Scope chain আর shadowing: ভেতর থেকে বাইরে, প্রথম মিলেই থামা; ভেতরের একই নাম বাইরেরটিকে আড়াল করে, বদলায় না। Static scope-এ প্রতিটি নামের (depth, slot) compile-এর আগেই জানা।
  4. Block বনাম function scope: JavaScript-এর var function-এর, hoisted হয়ে undefined; let/const block-এর, ঘোষণার আগে TDZ. Python-এ if/for scope নয়, কিন্তু assign করলেই local; বাইরে লিখতে global/nonlocal.
  5. Haat-এর নিয়ম: প্রতিটি { } একটি scope; ঘোষণার আগে ব্যবহার (নিজের initializer-সহ) compile-এর আগেই error; শুধু top-level function hoisted; static scope-এ নাম বদল নিরাপদ, যদি নতুন নামটি সত্যিই নতুন হয়।

পরের পর্বে: Scope বলে নাম কোথায় দেখা যায়; কিন্তু variable কতক্ষণ বাঁচে? পর্ব ১৬-এ (Lifetime আর storage) static, stack আর heap variable, dangling reference, আর কেন একটি closure তার function শেষ হওয়ার পরও variable বাঁচিয়ে রাখে।

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

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