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

Tree-walking interpreter — Haat চালানো

Tree-Walking Interpreter — Running Haat

Taught in Bangla, this lesson writes a complete tree-walking interpreter for Haat in in-page Python (Pyodide), from expressions to whole programs. It maps Haat values onto Python values while keeping 64-bit wrapping and C-style division, chains environments for blocks and calls, implements function values and return through a ReturnSignal exception, reports runtime errors with positions and enforces a call depth limit, then compares output with the reference by differential testing and measures the speed cost.

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

  • AST থেকে সরাসরি চলা একটি পূর্ণ interpreter নিজে লেখা: expression থেকে শুরু করে পুরো Haat পর্যন্ত
  • Haat-এর runtime-এর মান host ভাষায় কীভাবে রাখবেন, আর কোথায় host-এর নিয়ম ভাষার নিয়মের সঙ্গে মেলে না
  • Environment-এর শিকল, function-মান, call আর return-এর exception-ভিত্তিক বাস্তবায়ন
  • অবস্থানসহ runtime error, call-এর গভীরতার সীমা আর host-এর stack-এর সম্পর্ক
  • Golden file, oracle আর differential test দিয়ে interpreter-কে reference-এর সঙ্গে মেলানো, আর tree-walking-এর গতির দাম

১ · AST থেকে সরাসরি চলা — tree-walking interpreter কী

মডিউল ৮ আর ৯-এ আপনি Haat-এর পুরো front end বানিয়েছেন: lexer token বানায় (পর্ব ৪৬), parser AST বানায় (পর্ব ৪৭–৪৮), resolver প্রতিটি নাম তার ঘোষণার সঙ্গে জোড়ে (পর্ব ৫১), আর পর্ব ৫২-এর type checker নিশ্চিত করে যে true + 1-এর মতো কিছু নেই। এতক্ষণ program শুধু যাচাই হয়েছে, একবারও চলেনি। এই পর্বে সেটি চলবে। মডিউল ১০-এর প্রথম back end হলো tree-walking interpreter: যে interpreter AST-কে অন্য কোনো রূপে অনুবাদ না করে সরাসরি গাছের ওপর দিয়ে হেঁটে চালায়।

একজন রাঁধুনির কথা ভাবুন, হাতে একটি রেসিপির কার্ড: “বিরিয়ানি = মসলা-মাখা মাংস + আধা-সেদ্ধ চাল, দমে ২০ মিনিট।” “মসলা-মাখা মাংস” লেখার পাশে আরেকটি কার্ডের নম্বর, সেখানে আবার “আদা-রসুন বাটা”-র আলাদা কার্ড। রাঁধুনি বড় কার্ডটি পড়েন, যে উপকরণ তৈরি নেই তার কার্ডে যান, সেটি বানিয়ে ফল হাতে নিয়ে ফিরে আসেন, তারপর বড় কার্ডের পরের লাইন। রেসিপি তিনি কখনো অন্য ভাষায় নতুন করে লেখেন না; প্রতিবার রান্নার সময় কার্ড ধরে ধরে নামেন। Tree-walking interpreter ঠিক এই রাঁধুনি: AST হলো কার্ডের গাছ, আর “কার্ডে যাও, ফল নিয়ে ফেরো” হলো একটি recursive function call.

Interpreter-এর মূল দুটি function. eval(e, env) একটি expression নেয় আর একটি মান ফেরত দেয়: 2 + 3 * 4 থেকে 14. exec(s, env) একটি statement নেয় আর কিছু ফেরত দেয় না; তার কাজ পার্শ্বফল: একটি variable বসানো, কিছু ছাপা, loop ঘোরানো, বা function থেকে বেরিয়ে যাওয়া। দুটিই node-এর ধরন দেখে ঠিক করে কী করবে, আর সন্তান-node-এর জন্য নিজেকে বা অপরটিকে ডাকে। AST-এর ধরন অনুযায়ী এভাবে কাজ ভাগ করার নকশাটি পর্ব ৪৯-এর visitor pattern-এর আত্মীয়; reference সেটি isinstance-এর শিকলে লিখেছে, কারণ ছোট ভাষায় তা পড়তে সহজ।

Nodeকোন functionকী করে
Num, Str, Boolevalnode-এ রাখা মানটিই ফেরত
VarevalEnv-এর শিকলে নাম খুঁজে তার মান
Unary, Binaryevalআগে operand (বাঁ থেকে ডানে), তারপর operator; && আর || দরকার হলে তবেই ডান পাশ
Call, Lambdaevalfunction-মান বানানো, বা নতুন Env খুলে body চালানো
Let, Assign, FnDeclexecEnv-এ নাম বসানো বা বদলানো
If, While, Blockexecশর্ত হিসাব করে কোন block, কতবার; প্রতিটি block একটি নতুন Env
Return, Print, ExprStmtexecfunction থেকে বের হওয়া, ছাপা, বা মান হিসাব করে ফেলে দেওয়া

এটি নতুন কোনো তত্ত্ব নয়। পর্ব ৪০-এ big-step semantics দেখেছেন: ⟨e, ρ⟩ ⇓ v পড়া হয় “environment ρ-তে e হিসাব করলে মান v”. Tree-walking interpreter হলো সেই নিয়মগুলোর সরাসরি কোড-রূপ। দুটি নিয়ম পাশাপাশি দেখুন, প্রথমটি Binary-এর, দ্বিতীয়টি function call-এর (⊕̂ মানে Haat-এর operator, যেমন wrap-করা যোগ বা C-র ভাগ; ρf হলো function যে environment-এ তৈরি হয়েছিল; x̄ ↦ v̄ মানে parameter-গুলোতে argument বসানো):

⟨e1, ρ⟩ ⇓ v1    ⟨e2, ρ⟩ ⇓ v2    v = v1 ⊕̂ v2
⟨e1 ⊕ e2, ρ⟩ ⇓ v
(B-Op)
⟨f, ρ⟩ ⇓ ⟨fn(x̄) S, ρf⟩    ⟨ei, ρ⟩ ⇓ vi    ⟨S, ρf[x̄ ↦ v̄]⟩ ⇓ return v
⟨f(e1, …, en), ρ⟩ ⇓ v
(B-Call)

B-Op-এর ওপরের লাইনের তিনটি দাবি কোডের তিনটি লাইন: a = self.eval(e.left, env), b = self.eval(e.right, env), return arith(e.op, a, b, …). B-Call-এর ওপরের লাইন বলে কী লাগবে: function-মান, argument-এর মান, আর body চালিয়ে একটি return v. নিচের লাইনের ফল হলো সেই v. অংশ ৫-এ দেখবেন, “body চালিয়ে return v” কোডে লেখার জন্যই একটি exception লাগে।

একটি জরুরি পূর্বশর্ত। Reference-এর python haat.py run file.haat আগে সব static check চালায় (lexer, parser, resolver, type checker), আর একটিও error থাকলে interpreter শুরুই হয় না। তাই interpreter কোনো type যাচাই করে না: +-এর দুই পাশে একটি Int আর একটি Bool আসতে পারে না, checker তা আগেই আটকেছে। যা static বিশ্লেষণে ধরা অসম্ভব, শুধু সেগুলোই চলার সময়ের ভুল, অর্থাৎ runtime error: শূন্য দিয়ে ভাগ, অনেক গভীর recursion, আর একটি বিরল hoisting-এর ফাঁক (decision 26 আর 18). পর্ব ৫৪-এর বাড়তি check আর পর্ব ৫৫-এর desugaring-ও interpreter-এর কাজ ছোট করার পথ; Haat v1-এর reference অবশ্য desugar না করেই পুরো AST চালায়, যেমন else if সরাসরি।

২ · Runtime-এর মান — Haat-এর মান Python-এ কীভাবে থাকে

Interpreter যা নিয়ে কাজ করে, সেগুলো runtime-এর মান। Haat-এর প্রতিটি type-এর মানকে interpreter-এর ভাষায়, অর্থাৎ host language Python-এ, কোনো একটি রূপে রাখতে হয়। সহজতম পথ হলো Python-এর কাছাকাছি মান ধার করা:

Haat typePython-একোথায় সাবধান
IntintPython-এর int-এর সীমা নেই, Haat-এর আছে: প্রতিটি হিসাবের পরে wrap (decision 13)
BoolboolPython-এ bool আসলে int-এর উপশ্রেণি; ছাপার সময় true/false (decision 27)
Strstr+ জোড়া দেয়; == code point ধরে তুলনা (পর্ব ২১)
UnitNoneHaat-এ কোনো Unit literal নেই; return; আর শেষ পর্যন্ত চলা function দেয় (decision 22)
(Int) -> Int ইত্যাদিFunction objectparameter-এর নাম, body আর তৈরির সময়ের Env: একটি closure

ধার করা মানের সুবিধা স্পষ্ট: যোগ, তুলনা, string জোড়া Python নিজেই করে দেয়, আর মেমরির হিসাব রাখে Python-এর garbage collector. বিপদও এখানেই। Host-এর একটি operator ভাষার operator-এর মতো দেখালেও অর্থ আলাদা হতে পারে, আর তখন interpreter চুপচাপ ভুল উত্তর দেয়। Haat-এর জন্য তিনটি জায়গা:

  • Overflow. Haat-এর Int ৬৪-বিট two's complement, আর overflow হলে wrap করে। Python-এর 9223372036854775807 + 1 দেয় 9223372036854775808, একটি বৈধ Python int. তাই + - * /, unary -, সবকিছুর পরে wrap(n) = ((n + 263) mod 264) − 263, যা ফলকে [−263, 263 − 1]-এ ফিরিয়ে আনে। পর্ব ২০-এ দেখেছেন, C-তে signed overflow undefined behavior; Haat তা wrap দিয়ে সংজ্ঞায়িত করেছে, এমনকি INT_MIN / -1-ও (decision 13).
  • ভাগ. Haat-এর / C-র মতো শূন্যের দিকে কাটে, আর %-এর চিহ্ন ভাজ্যের মতো, যাতে a == (a / b) * b + a % b থাকে। Python-এর // নিচের দিকে (floor) কাটে: -7 // 2 = -4, আর -7 % 2 = 1. Haat-এ এ দুটি -3 আর -1. Python-এর / তো আরও দূরে, একটি float দেয়।
  • Bool আর int. Python-এ isinstance(True, int) সত্য, আর str(True) হলো "True". তাই ছাপার function show সবার আগে bool যাচাই করে, তারপর বাকিদের জন্য str.

এই নিয়মগুলো reference-এর runtime.py-তে, যাতে interpreter আর পর্ব ৫৯-এর VM একই function ব্যবহার করে আর কখনো দুই রকম উত্তর না দেয়। এই পাতার সহায়ক module-এ হুবহু একই আচরণের অংশটি (reference-এর c_mod ভাগফল নিজে আবার হিসাব করে, ফল একই):

# ---- runtime.py + errors.py (reference-এর মতো) ----
MAX_CALL_DEPTH = 1000                    # এর বেশি nested call হলে "stack overflow"
sys.setrecursionlimit(max(sys.getrecursionlimit(), 40 * MAX_CALL_DEPTH))   # reference-এর মতো
class HaatError(Exception):
    def __init__(self, line, col, message):
        super().__init__(f"{line}:{col}: runtime error: {message}")
def wrap(n): return ((n + 2**63) % 2**64) - 2**63
def c_div(a, b, line, col):
    if b == 0: raise HaatError(line, col, "division by zero")
    q = abs(a) // abs(b)
    return wrap(q if (a < 0) == (b < 0) else -q)
def c_mod(a, b, line, col):
    if b == 0: raise HaatError(line, col, "division by zero")
    q = abs(a) // abs(b); q = q if (a < 0) == (b < 0) else -q
    return wrap(a - b * q)
def arith(op, a, b, line, col):
    if op == "+": return a + b if isinstance(a, str) else wrap(a + b)
    if op == "-": return wrap(a - b)
    if op == "*": return wrap(a * b)
    if op == "/": return c_div(a, b, line, col)
    if op == "%": return c_mod(a, b, line, col)
    return {"==": a == b, "!=": a != b, "<": a < b, "<=": a <= b, ">": a > b, ">=": a >= b}[op]
def show(v):
    if isinstance(v, bool): return "true" if v else "false"
    return str(v)
নিয়ম ৫৬.১ — ধার করা মান, নিজের অর্থ

Host-এর মান ধার নেওয়া ভালো, host-এর অর্থ ধার নেওয়া বিপজ্জনক। প্রতিটি operator-এর জন্য নিজেকে জিজ্ঞেস করুন: সীমার বাইরে গেলে কী হয়, ঋণাত্মক সংখ্যায় কী হয়, শূন্যে কী হয়, আর host কী করে? দুটি এক না হলে ভাষার নিয়মটি নিজে লিখুন, আর সব operator-কে একটি জায়গা দিয়ে পাঠান (arith), যাতে নিয়মটি একবারই লিখতে হয়।

৩ · Expression হিসাব — eval আর Env

Expression-এ নাম থাকে (p - p / 10), তাই eval-এর সঙ্গে একটি environment লাগে: নাম থেকে মানের একটি খাতা। Reference-এর Env খুবই সরল, একটি Python dict আর বাইরের Env-এর দিকে একটি সংযোগ (parent). নাম খুঁজতে find ভেতরের Env থেকে শুরু করে বাইরের দিকে একে একে যায়, ঠিক পর্ব ১৫-এর lexical scope-এর নিয়মে। এই নকশার দাম আর বিকল্প (slot-ভিত্তিক array, resolver-এর দেওয়া সংখ্যা) পর্ব ৫৭-এর বিষয় (Environment আর closure-এর বাস্তবায়ন); এখানে dict-এর শিকলই যথেষ্ট।

নিচের প্রথম ব্লকে interpreter-এর প্রথম অংশ: Env আর expression-এর eval. সহায়ক module haat_front.py দেয় Haat-এর lexer আর parser-এর সংক্ষিপ্ত রূপ (পর্ব ৪৬–৪৮; reference-এর একই AST class আর field), আর ওপরের runtime.py-র অংশ। Module-টি পাতাতেই রাখা, খুলে পড়তে পারেন:

সহায়ক module haat_front.py দেখুন (ব্লকগুলো এটি import করে)
# haat_front.py — সহায়ক অংশ: পর্ব ৫৬-এর interpreter এর ওপর দাঁড়ায়।
# Reference-এর lexer + parser (পর্ব ৪৬–৪৮)-এর সংক্ষিপ্ত রূপ, একই AST class (পর্ব ৪৯),
# আর runtime.py + errors.py (wrap, C-র / আর %, show, HaatError) — নাম আর আউটপুট reference-এর মতো।
import re, sys
from dataclasses import dataclass, make_dataclass

@dataclass(frozen=True)
class Token:
    kind: str; text: str; line: int; col: int

KW = "let var fn if else while return true false print".split()
OPS = dict(zip("== != <= >= && || -> + - * / % < > ! = ( ) { } , ; :".split(),
    "EQ_EQ BANG_EQ LT_EQ GT_EQ AND_AND OR_OR ARROW PLUS MINUS STAR SLASH PERCENT LT GT "
    "BANG EQ LPAREN RPAREN LBRACE RBRACE COMMA SEMI COLON".split()))
SPEC = (r'(?P<skip>//[^\n]*|[ \t\r\n]+)|(?P<IDENT>[A-Za-z_][A-Za-z0-9_]*)|(?P<INT>[0-9]+)'
        r'|(?P<STRING>"(?:\\["\\n]|[^"\\\n])*")|(?P<op>==|!=|<=|>=|&&|\|\||->|[-+*/%<>!=(){},;:])|(?P<bad>.)')

def tokenize(src):                       # lexer stand-in (পর্ব ৪৬)
    toks = []
    for m in re.finditer(SPEC, src):
        g, t, at = m.lastgroup, m[0], m.start()
        line, col = src.count("\n", 0, at) + 1, at - src.rfind("\n", 0, at)
        if g == "bad": raise SyntaxError(f"{line}:{col}: error: unexpected character '{t}'")
        if g == "skip": continue
        kind = OPS[t] if g == "op" else t.upper() if g == "IDENT" and t in KW else g
        toks.append(Token(kind, t, line, col))
    return toks + [Token("EOF", "", src.count("\n") + 1, len(src) - src.rfind("\n"))]

NODES = {"Num": "value", "Str": "value", "Bool": "value", "Var": "name", "Unary": "op operand",
         "Binary": "op left right", "Call": "callee args", "Param": "name type",
         "Lambda": "params ret body", "Let": "name mutable type init", "Assign": "name value",
         "If": "cond then else_", "While": "cond body", "Return": "value", "Print": "value",
         "ExprStmt": "expr", "Block": "stmts", "FnDecl": "name params ret body"}
for _name, _fields in NODES.items():     # same class names and fields; line, col always last
    globals()[_name] = make_dataclass(_name, _fields.split() + ["line", "col"])
Program = make_dataclass("Program", ["stmts"])
INFIX = {"OR_OR": 10, "AND_AND": 20, "EQ_EQ": 30, "BANG_EQ": 30, "LT": 40, "LT_EQ": 40,
         "GT": 40, "GT_EQ": 40, "PLUS": 50, "MINUS": 50, "STAR": 60, "SLASH": 60, "PERCENT": 60}

class Parser:                            # recursive descent (পর্ব ৪৭) + Pratt (পর্ব ৪৮)
    def __init__(self, tokens): self.toks, self.pos = tokens, 0
    def peek(self, ahead=0): return self.toks[min(self.pos + ahead, len(self.toks) - 1)]
    def check(self, kind): return self.peek().kind == kind
    def advance(self):
        tok = self.peek()
        if tok.kind != "EOF": self.pos += 1
        return tok
    def match(self, kind): return self.advance() if self.check(kind) else None
    def expect(self, kind, message):
        if self.check(kind): return self.advance()
        if kind == "SEMI" and self.pos > 0:
            prev = self.toks[self.pos - 1]; self.fail(message, (prev.line, prev.col + len(prev.text)))
        self.fail(message)
    def fail(self, message, where=None):
        line, col = where or (self.peek().line, self.peek().col)
        raise SyntaxError(f"{line}:{col}: error: {message}")
    def statements_until(self, end):
        stmts = []
        while not self.check(end) and not self.check("EOF"): stmts.append(self.statement())
        return stmts
    def statement(self):
        kind = self.peek().kind
        if kind in ("LET", "VAR"):
            mutable = self.advance().kind == "VAR"; name = self.expect("IDENT", "expected variable name")
            ann = self.parse_type() if self.match("COLON") else None
            self.expect("EQ", "expected '='"); init = self.expression()
            self.expect("SEMI", "expected ';' after variable declaration")
            return Let(name.text, mutable, ann, init, name.line, name.col)
        if kind == "FN" and self.peek(1).kind == "IDENT":
            self.advance(); name = self.advance(); ps, ret, body = self.function_rest()
            return FnDecl(name.text, ps, ret, body, name.line, name.col)
        if kind == "IF": return self.if_stmt()
        if kind == "WHILE":
            kw = self.advance(); cond = self.expression(); return While(cond, self.block(), kw.line, kw.col)
        if kind == "RETURN":
            kw = self.advance(); value = None if self.check("SEMI") else self.expression()
            self.expect("SEMI", "expected ';' after return"); return Return(value, kw.line, kw.col)
        if kind == "PRINT":
            kw = self.advance(); self.expect("LPAREN", "expected '(' after 'print'"); value = self.expression()
            self.expect("RPAREN", "expected ')'"); self.expect("SEMI", "expected ';' after print statement")
            return Print(value, kw.line, kw.col)
        if kind == "LBRACE": return self.block()
        first = self.peek(); e = self.expression()
        if self.match("EQ"):
            value = self.expression(); self.expect("SEMI", "expected ';' after assignment")
            return Assign(e.name, value, e.line, e.col)
        self.expect("SEMI", "expected ';' after expression"); return ExprStmt(e, first.line, first.col)
    def block(self):
        lb = self.expect("LBRACE", "expected '{'"); stmts = self.statements_until("RBRACE")
        self.expect("RBRACE", "expected '}' at end of block"); return Block(stmts, lb.line, lb.col)
    def if_stmt(self):
        kw = self.advance(); cond = self.expression(); then = self.block(); else_ = None
        if self.match("ELSE"): else_ = self.if_stmt() if self.check("IF") else self.block()
        return If(cond, then, else_, kw.line, kw.col)
    def function_rest(self):
        self.expect("LPAREN", "expected '('"); params = []
        if not self.check("RPAREN"):
            while True:
                p = self.expect("IDENT", "expected parameter name"); self.expect("COLON", "expected ':'")
                params.append(Param(p.text, self.parse_type(), p.line, p.col))
                if not self.match("COMMA"): break
        self.expect("RPAREN", "expected ')'")
        ret = self.parse_type() if self.match("ARROW") else "Unit"
        return params, ret, self.block()
    def parse_type(self):
        if self.match("LPAREN"):
            ps = [] if self.check("RPAREN") else [self.parse_type()]
            while self.match("COMMA"): ps.append(self.parse_type())
            self.expect("RPAREN", "expected ')'"); self.expect("ARROW", "expected '->'")
            return ("fn", tuple(ps), self.parse_type())
        return self.expect("IDENT", "expected a type").text
    def expression(self, min_bp=0):
        t = self.peek()
        if t.kind not in ("INT", "STRING", "TRUE", "FALSE", "IDENT", "LPAREN", "MINUS", "BANG", "FN"):
            self.fail("expected expression")
        self.advance()
        if t.kind == "INT": left = Num(int(t.text), t.line, t.col)
        elif t.kind == "STRING":
            left = Str(re.sub(r'\\(.)', lambda m: "\n" if m[1] == "n" else m[1], t.text[1:-1]), t.line, t.col)
        elif t.kind in ("TRUE", "FALSE"): left = Bool(t.kind == "TRUE", t.line, t.col)
        elif t.kind == "IDENT": left = Var(t.text, t.line, t.col)
        elif t.kind in ("MINUS", "BANG"): left = Unary(t.text, self.expression(70), t.line, t.col)
        elif t.kind == "FN": left = Lambda(*self.function_rest(), t.line, t.col)
        else: left = self.expression(); self.expect("RPAREN", "expected ')'")
        while True:
            t = self.peek()
            if t.kind == "LPAREN":
                self.advance(); args = [] if self.check("RPAREN") else [self.expression()]
                while self.match("COMMA"): args.append(self.expression())
                self.expect("RPAREN", "expected ')' after arguments")
                s = left
                while isinstance(s, (Binary, Call)): s = s.left if isinstance(s, Binary) else s.callee
                left = Call(left, args, s.line, s.col); continue
            bp = INFIX.get(t.kind, -1)
            if bp < min_bp: return left
            self.advance(); left = Binary(t.text, left, self.expression(bp + 1), t.line, t.col)

def parse(src): return Program(Parser(tokenize(src)).statements_until("EOF"))
def parse_expr(src): return Parser(tokenize(src)).expression()

# ---- runtime.py + errors.py (reference-এর মতো) ----
MAX_CALL_DEPTH = 1000                    # এর বেশি nested call হলে "stack overflow"
sys.setrecursionlimit(max(sys.getrecursionlimit(), 40 * MAX_CALL_DEPTH))   # reference-এর মতো
class HaatError(Exception):
    def __init__(self, line, col, message):
        super().__init__(f"{line}:{col}: runtime error: {message}")
def wrap(n): return ((n + 2**63) % 2**64) - 2**63
def c_div(a, b, line, col):
    if b == 0: raise HaatError(line, col, "division by zero")
    q = abs(a) // abs(b)
    return wrap(q if (a < 0) == (b < 0) else -q)
def c_mod(a, b, line, col):
    if b == 0: raise HaatError(line, col, "division by zero")
    q = abs(a) // abs(b); q = q if (a < 0) == (b < 0) else -q
    return wrap(a - b * q)
def arith(op, a, b, line, col):
    if op == "+": return a + b if isinstance(a, str) else wrap(a + b)
    if op == "-": return wrap(a - b)
    if op == "*": return wrap(a * b)
    if op == "/": return c_div(a, b, line, col)
    if op == "%": return c_mod(a, b, line, col)
    return {"==": a == b, "!=": a != b, "<": a < b, "<=": a <= b, ">": a > b, ">=": a >= b}[op]
def show(v):
    if isinstance(v, bool): return "true" if v else "false"
    return str(v)

তিনটি Python ব্লক একই namespace ভাগ করে (পরের ব্লক আগে চালালে আগেরগুলো নিজে চলে নেবে)। দ্বিতীয় ব্লক class Interpreter(Interpreter) লিখে প্রথমটিকে বাড়াবে, যেভাবে interpreter ধাপে ধাপে বড় হয়। প্রথমবার চালালে ব্রাউজারে Python নামতে কয়েক সেকেন্ড লাগতে পারে।

from haat_front import *          # parse, parse_expr, AST classes, wrap, arith, show, HaatError

class Env:                        # one scope: a dict of names + a link to the enclosing scope
    def __init__(self, parent=None): self.vars, self.parent = {}, parent
    def find(self, name):         # the Env that holds name (None: a global not set yet)
        env = self
        while env is not None and name not in env.vars: env = env.parent
        return env

class Interpreter:                # interp.py, part 1: expressions -> values
    def home(self, node, env):
        found = env.find(node.name)
        if found is None: raise HaatError(node.line, node.col, f"'{node.name}' is not initialized yet")
        return found
    def eval(self, e, env):
        if isinstance(e, (Num, Str, Bool)): return e.value
        if isinstance(e, Var): return self.home(e, env).vars[e.name]
        if isinstance(e, Unary):
            v = self.eval(e.operand, env)
            return wrap(-v) if e.op == "-" else not v
        if e.op == "&&": return self.eval(e.left, env) and self.eval(e.right, env)
        if e.op == "||": return self.eval(e.left, env) or self.eval(e.right, env)
        a = self.eval(e.left, env)            # left before right (decision 12)
        b = self.eval(e.right, env)
        return arith(e.op, a, b, e.line, e.col)

env = Env(); env.vars.update(p=1040, name="বাজারঘর")
for src in ["p - p / 10", "-7 / 2", "-7 % 2", "9223372036854775807 + 1",
            "(-9223372036854775807 - 1) / -1", "p >= 1000 && p - p / 10 > 900",
            "p > 0 || p / 0 == 1", 'name + " ঢাকা"']:
    print(f"{src:31} => {show(Interpreter().eval(parse_expr(src), env))}")
try: Interpreter().eval(parse_expr("p + 1 / (p - 1040)"), env)
except HaatError as err: print(err)

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

p - p / 10                      => 936
-7 / 2                          => -3
-7 % 2                          => -1
9223372036854775807 + 1         => -9223372036854775808
(-9223372036854775807 - 1) / -1 => -9223372036854775808
p >= 1000 && p - p / 10 > 900   => true
p > 0 || p / 0 == 1             => true
name + " ঢাকা"                  => বাজারঘর ঢাকা
1:7: runtime error: division by zero

প্রথম লাইন বাজারঘরের ১০% ছাড়: 1040 - 1040 / 10 = 936. পরের দুটি C-ধরনের ভাগ: -3 আর -1, Python-এর -4 আর 1 নয়। চতুর্থটিতে সবচেয়ে বড় Int-এ ১ যোগ করে wrap হয়ে সবচেয়ে ছোট Int, আর পঞ্চমটি সেই কোণা যেখানে C undefined: সবচেয়ে ছোট Int-কে -1 দিয়ে ভাগ, ফল আবার সবচেয়ে ছোট Int (decision 13). ষষ্ঠটিতে দুই পাশই হিসাব হয়েছে। সপ্তমটি দেখুন: p / 0 আছে, তবু কোনো error নেই, কারণ p > 0 সত্য হওয়ায় || ডান পাশে যায়ইনি (short-circuit). শেষ লাইনে সত্যিকারের শূন্য দিয়ে ভাগ, আর error-এর অবস্থান 1:7, অর্থাৎ / operator-এর ঘর (decision 24), যোগের + নয়। Reference-এর haat.py run-এ একই expression-গুলো print(…)-এর ভেতরে চালিয়ে একই মান এসেছে (শেষটি সেখানে 10:13, কারণ লাইন ১০-এ print(-এর পরে)।

কোডের দুটি সূক্ষ্ম জায়গা। প্রথমটি && আর ||: এরা arith-এ যায় না, কারণ সেখানে পৌঁছানোর আগেই দুই পাশ হিসাব হয়ে যেত। Python-এর নিজের and আর or short-circuit করে, তাই self.eval(e.left, env) and self.eval(e.right, env) লিখলে বাঁ পাশ False হলে ডান পাশের eval ডাকাই হয় না। এখানে host-এর অর্থ আর Haat-এর অর্থ মিলে গেছে, আর মান সবসময় bool বলে Python-এর “operand-টিই ফেরত দেওয়া” আচরণও ক্ষতি করে না। দ্বিতীয়টি evaluation order: a আগে, b পরে, দুটি আলাদা লাইনে (decision 12). এখন expression-এ side effect নেই বলে ক্রম চোখে পড়ে না, কিন্তু function call আসার পরে f() + g()-এ কে আগে ছাপবে, সেটি এই দুই লাইনই ঠিক করে (পর্ব ২৬)।

গাছটি কোন ক্রমে হাঁটা হয়, চোখে দেখতে নিচের JavaScript ব্লকটি চালান। এটি একই eval-এর একটি ছোট JS রূপ, শুধু প্রতিটি node-এর শেষ হওয়ার ক্রম আর মান লিখে রাখে, তারপর p = 1040 আর p = 520 দুই ক্ষেত্রে গাছটি আঁকে:

// p >= 1000 && p - p / 10 > 900: Haat-এর AST, JS object আকারে (Binary, Var, Num)
const B = (op, l, r) => ({op, kids: [l, r]}), V = name => ({name, kids: []}), N = num => ({num, kids: []});
const ast = B("&&", B(">=", V("p"), N(1000)), B(">", B("-", V("p"), B("/", V("p"), N(10))), N(900)));
const OPS = {">=": (a, b) => a >= b, ">": (a, b) => a > b, "-": (a, b) => a - b, "/": (a, b) => Math.trunc(a / b)};
const label = e => e.op ?? e.name ?? String(e.num);
function evaluate(e, env, done) {          // the Python eval() in miniature, plus a record of each node
  let v;
  if (e.kids.length === 0) v = e.name ? env[e.name] : e.num;
  else if (e.op === "&&") v = evaluate(e.kids[0], env, done) && evaluate(e.kids[1], env, done);
  else { const a = evaluate(e.kids[0], env, done), b = evaluate(e.kids[1], env, done); v = OPS[e.op](a, b); }
  done.set(e, [done.size + 1, v]);         // finishing order (post-order) and the value
  return v;
}
let col = 0;                               // layout: in-order column, depth row
(function place(e, d) { e.y = d; if (e.kids.length) { place(e.kids[0], d + 1); e.x = col++; place(e.kids[1], d + 1); } else e.x = col++; })(ast, 0);
const nodes = []; (function all(e) { nodes.push(e); e.kids.forEach(all); })(ast);
let html = "";
for (const p of [1040, 520]) {
  const done = new Map(), v = evaluate(ast, {p}, done);
  console.log(`p = ${p}: ${v}; ${done.size}/${nodes.length} nodes evaluated, order: ` +
              [...done].map(([e, [k]]) => label(e)).join(" "));
  let s = "";
  for (const e of nodes) for (const k of e.kids)
    s += `<line x1="${e.x * 36 + 20}" y1="${e.y * 56 + 34}" x2="${k.x * 36 + 20}" y2="${k.y * 56 + 34}" stroke="#94a3b8"/>`;
  for (const e of nodes) {
    const r = done.get(e), cx = e.x * 36 + 20, cy = e.y * 56 + 34;
    s += `<circle cx="${cx}" cy="${cy}" r="15" fill="${r ? "#dbeafe" : "#e5e7eb"}" stroke="${r ? "#1e3a8a" : "#9ca3af"}"/>` +
         `<text x="${cx}" y="${cy + 4}">${label(e).replaceAll("&", "&amp;").replaceAll(">", "&gt;")}</text>` +
         `<text x="${cx}" y="${cy + 29}" font-size="12" fill="${r ? "#b45309" : "#6b7280"}">${r ? r[0] + ":" + r[1] : "বাদ"}</text>`;
  }
  html += `<p>p = ${p} → ${v}</p><svg viewBox="0 0 ${col * 36 + 4} 300" width="100%" font-size="13" text-anchor="middle">${s}</svg>`;
}
document.getElementById("t").innerHTML = html;

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

p = 1040: true; 11/11 nodes evaluated, order: p 1000 >= p p 10 / - 900 > &&
p = 520: false; 4/11 nodes evaluated, order: p 1000 >= &&

প্রতিটি node-এর নিচে লেখা “ক্রম:মান”। শেষ হওয়ার ক্রমটি গাছের post-order: আগে বাঁ সন্তান, তারপর ডান, তারপর নিজে; মূল && সবার শেষে। p = 520-এ বাঁ পাশ 520 >= 1000 মিথ্যা, তাই ১১টির মধ্যে মাত্র ৪টি node-এ যাওয়া হয়েছে, আর ডান দিকের পুরো উপ-গাছ ধূসর, “বাদ”। একটি AST-কে যতবার চালাবেন, ততবার এই হাঁটা নতুন করে হয়; অংশ ৭-এ দেখবেন এর দাম কত।

৪ · Statement চালানো — exec, block আর scope

Statement-এর exec কোনো মান ফেরত দেয় না, Env বা বাইরের জগৎ বদলায়। প্রতিটি ধরনের নিয়ম ছোট:

  • let/var: initializer হিসাব করে বর্তমান Env-এ নাম বসানো। let আর var-এর পার্থক্য (কোনটিতে আবার লেখা যায়) checker আগেই যাচাই করেছে (decision 19), তাই interpreter দুটিকে একই ভাবে রাখে।
  • Assignment x = e;: মান হিসাব করে, তারপর শিকলে x যে Env-এ আছে সেখানেই বদলানো। বর্তমান Env-এ নতুন করে বসালে বাইরের variable বদলাত না, ভেতরে একটি নতুন জন্মাত: একটি সাধারণ বাগ।
  • Block, if-এর শাখা, while-এর body: প্রতিটির জন্য Env(env), অর্থাৎ বর্তমানটির ভেতরে একটি নতুন Env. Block শেষ হলে সেই Env আর কেউ ধরে রাখে না, তাই ভেতরের নামগুলো হারিয়ে যায় (decision 14).
  • while: প্রতিটি ঘোরায় নতুন Env. Loop-এর ভেতরে তৈরি একটি closure তাই সেই ঘোরার variable ধরে রাখে, পরের ঘোরার নয়। একটি Env পুরো loop-এ রাখলে closure ছাড়া সব program একই আচরণ করত, আর ঠিক এ কারণেই এই বাগটি লুকিয়ে থাকে (অংশ ৭-এ সংখ্যা দেখবেন)।
  • print: মান হিসাব করে show দিয়ে লেখা; Str-এর ভেতরে \n থাকলে নতুন লাইন (decision 27).
  • Top level: আগে সব top-level fn global Env-এ বসানো, তারপর বাকি statement ক্রমে (hoisting, decision 17). তাই পারস্পরিক recursion কাজ করে। কিন্তু একটি hoisted function যদি এমন top-level variable পড়ে যার let এখনো চলেনি, তখন শিকলে নামটি কোথাও নেই: home() সেটি ধরে 'k' is not initialized yet দেয় (decision 18). Checker এটি ধরতে পারে না, কারণ কোন call কখন চলবে তা চালানোর আগে সাধারণভাবে জানা যায় না।

একটি তুলনা কাজে লাগে। পর্ব ০৭-এর ছোট interpreter একটি সমতল state σ নিয়ে চলত; এখানে state হলো Env-এর একটি গাছ, যার প্রতিটি শাখা একটি scope. Function-মানের সঙ্গে Env জমা থাকে বলে একটি Env তার block শেষ হওয়ার পরেও বাঁচতে পারে, এটাই closure-এর গোপন কথা (পর্ব ১৭).

৫ · Function call আর return — নতুন Env আর ReturnSignal

Haat-এ function first-class: variable-এ রাখা যায়, argument-এ পাঠানো যায়। Interpreter-এ একটি function-মান হলো একটি Function object, যার চারটি field: name, params (parameter-এর নাম), body আর env, যেখানে env হলো function যে Env-এ তৈরি হয়েছিল। Top-level fn-এর জন্য সেটি global Env, নামহীন fn(…)-এর জন্য যেখানে expression-টি হিসাব হলো সেখানকার Env. Call-এর নিয়ম চার লাইনের:

  1. Callee হিসাব, তারপর argument বাঁ থেকে ডানে (decision 12).
  2. গভীরতা যাচাই: ১,০০০টি call আগে থেকেই চলমান থাকলে stack overflow (অংশ ৬).
  3. Env(f.env): নতুন Env, যার বাইরের সংযোগ function-এর নিজের Env, ডাকার জায়গার নয়। এটাই static scoping. Env(env) লিখলে, অর্থাৎ caller-এর Env, interpreter dynamic scoping করত (পর্ব ১৫). Parameter আর body-র প্রথম স্তর এই একই Env-এ (decision 14).
  4. Body চালানো; return v এলে v ফল, শেষ পর্যন্ত চললে Unit (None).

দ্বিতীয় ব্লক এগুলো যোগ করে: Function, ReturnSignal, Call আর Lambda-র eval, আর সব statement-এর exec. Reference-এ এটি interp.py-র বাকি অংশ; শেষ লাইন পুরো bazar.haat চালায়:

class Function:                   # a closure: parameter names + body + the Env where it was made
    def __init__(self, name, fn, env): self.name, self.params, self.body, self.env = name, [p.name for p in fn.params], fn.body.stmts, env
class ReturnSignal(Exception): pass   # raise ReturnSignal(v): carries v up to the waiting call()
class Interpreter(Interpreter):   # interp.py, part 2: calls and statements
    depth, out = 0, print
    def eval(self, e, env):
        if isinstance(e, Call):       # callee first, then the arguments left to right
            return self.call(self.eval(e.callee, env), [self.eval(a, env) for a in e.args], e)
        if isinstance(e, Lambda): return Function(f"lambda@{e.line}:{e.col}", e, env)
        return super().eval(e, env)
    def call(self, f, args, node):
        if self.depth >= MAX_CALL_DEPTH: raise HaatError(node.line, node.col, "stack overflow")
        env = Env(f.env); env.vars.update(zip(f.params, args))   # params + body share one scope
        try: self.depth += 1; self.exec_block(f.body, env); return None   # fell off the end: Unit
        except ReturnSignal as r: return r.args[0]
        finally: self.depth -= 1
    def exec_block(self, stmts, env):
        for s in stmts: self.exec(s, env)
    def exec(self, s, env):
        if isinstance(s, Let): env.vars[s.name] = self.eval(s.init, env)
        elif isinstance(s, FnDecl): env.vars[s.name] = Function(s.name, s, env)
        elif isinstance(s, Assign): v = self.eval(s.value, env); self.home(s, env).vars[s.name] = v
        elif isinstance(s, If):       # else_ is None, a Block, or an If (else if)
            if self.eval(s.cond, env): self.exec_block(s.then.stmts, Env(env))
            elif s.else_ is not None: self.exec(s.else_, env)
        elif isinstance(s, While):
            while self.eval(s.cond, env): self.exec_block(s.body.stmts, Env(env))  # new scope each round
        elif isinstance(s, Return): raise ReturnSignal(None if s.value is None else self.eval(s.value, env))
        elif isinstance(s, Print): self.out(show(self.eval(s.value, env)))
        elif isinstance(s, ExprStmt): self.eval(s.expr, env)
        elif isinstance(s, Block): self.exec_block(s.stmts, Env(env))
    def run(self, program):       # top-level fn first (hoisting, decision 17), then the rest in order
        g = Env()
        for s in sorted(program.stmts, key=lambda s: not isinstance(s, FnDecl)): self.exec(s, g)
Interpreter().run(parse(open("bazar.haat", encoding="utf-8").read()))

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

996
5000
3

কোর্সের canonical program-এর ঠিক সেই তিনটি লাইন, যা reference-এর haat.py run আর haat.py vm দুটিই ছাপে। কয়েকটি জিনিস লক্ষ করুন। run-এর sorted stable, তাই আগে সব top-level fn তাদের নিজেদের ক্রমে, তারপর বাকিগুলো উৎসের ক্রমে: reference-এর দুই loop-এর সমান। Lambda একটি Function বানায় lambda@line:col নামে, যে নাম reference-এর disassembler-ও ব্যবহার করে (decision 23). পাতার ReturnSignal নিজের মান রাখে r.args[0]-এ (Python-এর সব exception-এর argument সেখানে থাকে), reference একটি value field রাখে; কাজ একই। If-এর else_ একটি Block বা আরেকটি If, দুটিই exec নিজে চালাতে জানে, তাই একটি লাইনেই else আর else if. out একটি বদলানো যায় এমন function: সাধারণভাবে print, কিন্তু পরের ব্লকে test-এর জন্য একটি তালিকায় লিখবে। আর পুরো interpreter-এ কোনো type check নেই; সেই কাজ আগেই শেষ।

এবার bazar.haat-এর প্রথম call, price(2, 520), ধাপে ধাপে। প্রতিটি অবস্থান reference-এর tokens আউটপুট থেকে, আর প্রতিটি মান পাতার interpreter-এ instrumentation লাগিয়ে আসল run থেকে নেওয়া। G মানে global Env, E1 call-এর Env, E2 then-block-এর Env.

2fn price(qty: Int, unit: Int) -> Int {3    let p = qty * unit;4    if p >= 1000 { return p - p / 10; }5    return p;6}10let first = price(2, 520) + …;
Interpreter-এর ভেতরে
চলছে
Env শিকল
মান
  1. Callee. let first = …-এর +-এর বাঁ পাশ একটি Call (10:13). eval আগে callee হিসাব করে: Var price global Env-এ পাওয়া গেল, একটি Function মান, যার env হলো G নিজেই।
  2. Argument, বাঁ থেকে ডানে. 2 আর 520 দুটি Num, নিজের মানই ফেরত দেয়। তালিকা [2, 520].
  3. নতুন Env. call() গভীরতা দেখে (০, সীমার অনেক নিচে), বাড়িয়ে ১ করে, আর Env(f.env) বানায়: E1, যার বাইরের সংযোগ G. Parameter-এর নামে argument বসে: qty = 2, unit = 520.
  4. let p. qty * unit: দুই নামই E1-এ পাওয়া, 2 * 520 = 1040, wrap-এর পরেও একই। p বসে E1-এ, কারণ parameter আর body-র প্রথম স্তর একই scope.
  5. if. শর্ত p >= 1000: p E1-এ, 1040 >= 1000 সত্য। Then-block-এর জন্য নতুন Env E2, ভেতরে খালি, বাইরের সংযোগ E1.
  6. return. p - p / 10: p খুঁজতে E2-তে নেই, এক ধাপ বাইরে E1-এ পাওয়া। 1040 / 10 = 104 (C-ধরনের ভাগ), 1040 - 104 = 936. এবার exec একটি ReturnSignal(936) ছোড়ে।
  7. ফেরা. Signal-টি কয়েকটি Python frame পার হয়ে call()-এর except-এ ধরা পড়ে (পরের stepper-এ বিস্তারিত); finally গভীরতা আবার ০ করে। ফল 936; return p; লাইনটি কখনো চলেনি। E1 আর E2-কে এখন কেউ ধরে নেই, Python-এর garbage collector সেগুলো মুছে দিতে পারে। এবার +-এর ডান পাশ: delivery(price(2, 520)).

এক মুহূর্তে interpreter-এর ভেতরে আসলে দুটি আলাদা কাঠামো থাকে, আর এ দুটি গুলিয়ে ফেলা খুব সাধারণ ভুল। একটি হলো Python-এর call stack: interpreter-এর নিজের method-গুলোর ডাক, যা Haat-এর নয়, host-এর। অন্যটি Haat-এর Env শিকল: heap-এ রাখা dict, যা Haat program-এর scope. নিচের ছবি ধাপ ৬-এর মুহূর্তটি, যখন return চলছে:

ছবি ৫৬.১ — দুই stack, এক মুহূর্ত: return p - p / 10;

বাঁয়ে interpreter-এর Python frame (ওপরে পুরোনো, নিচে নতুন), প্রতিটির পাশে সে কোন Env-এ কাজ করছে। ডানে Haat-এর Env, তির বাইরের সংযোগ (parent). Frame-এর নাম পাতার interpreter-এর আসল run থেকে।

Python call stack of the interpreter and the Haat Env chain at the moment of return in price Python call stack Haat-এর Env শিকল (host-এর frame) (heap-এ dict) run(program) · G exec(let first) · G eval(+) · G eval(price(…)) · G call(price) · E1 exec_block(body) · E1 exec(If) · E1 exec_block(then) · E2 exec(Return) · E2 G (global) price: Function delivery: Function E1 (call price) qty: 2, unit: 520 p: 1040 E2 (then-block) { } খালি parent parent ReturnSignal(936): exec(Return) থেকে এক লাফে call(price)-এ, মাঝের ৩টি frame বাদ
ছবি ৫৬.১ — Python-এর frame-গুলো interpreter-এর কাজ, Env-গুলো Haat program-এর scope. একটি Haat call (call(price)) কয়েকটি Python frame-এর সমান, আর একটি frame-এর হাতে একটি Env. পরের পর্বের Haat VM-এ বাঁ দিকটি থাকবে না: VM নিজের frame নিজে রাখে।

return কেন একটি exception

return চলে exec(Return)-এর গভীরে, কিন্তু তার মান দরকার call()-এর, যা কয়েক স্তর ওপরে। মাঝের exec_block-এর loop-এ পরের statement-গুলো আর চলা চলবে না, exec(If)-কেও থামতে হবে। Python-এর একটি exception ঠিক এই কাজ করে: ছোড়ার জায়গা থেকে ধরার জায়গা পর্যন্ত মাঝের সব frame বাদ দিয়ে ওপরে ওঠে, যাকে বলে stack unwinding (পর্ব ২৮). Reference তাই ReturnSignal নামে একটি exception রাখে, যা কোনো ভুল নয়, শুধু একটি মান বহনকারী:

1def call(self, f, args, node):2  try: self.exec_block(f.body, env); return None3  except ReturnSignal as r: return r.value4  finally: self.depth -= 15def exec_block(self, stmts, env):6  for s in stmts: self.exec(s, env)7elif isinstance(s, If): … self.exec_block(…)8elif isinstance(s, Return): raise ReturnSignal(…)
Python stack (নিচে নতুন)
frame
ঘটনা
  1. ছোড়া. exec(Return) মান 936 হিসাব করে raise ReturnSignal(936). এই frame-এর কাজ এখানেই শেষ, কিছু ফেরত দেয় না। (Call ছাড়া অন্য node-এর, যেমন +-এর, eval আসলে দুটি frame, কারণ দ্বিতীয় ব্লকের eval super() দিয়ে প্রথমটিকে ডাকে; সহজ রাখতে এখানে একটি দেখানো।)
  2. Then-block. exec_block(then)-এ কোনো try নেই, তাই Python তার frame সরিয়ে দেয়। Block-এ পরের statement থাকলে সেগুলোও বাদ পড়ত।
  3. if. exec(If)-ও ধরে না; তার frame-ও যায়। else-শাখা থাকলেও কিছু বদলাত না, সেটি তো চলেইনি।
  4. Body. exec_block(body)-এর for loop-এ পরের statement ছিল return p;. Exception loop-টিকে মাঝপথে থামায়, তাই সেই লাইন কখনো চলে না। এটাই return-এর অর্থ: “বাকিটা বাদ”।
  5. ধরা. call(price)-এ except ReturnSignal as r: return r.value. Signal থামে, মান 936 সাধারণ ফেরত-মান হয়ে যায়। finally সবসময় চলে, তাই গভীরতা ১ থেকে ০, error হলেও।
  6. আবার স্বাভাবিক পথ. eval(price(…)) সাধারণভাবে 936 পায়, আর eval(+) তার বাঁ পাশ হিসেবে সেটি রাখে। মাঝের তিনটি frame কোনো বাড়তি কোড ছাড়াই পার হলো।

বিকল্প পথও আছে, আর তুলনাটি নকশার একটি পরিচিত প্রশ্ন:

পথকীভাবেসুবিধাঅসুবিধা
Exception (reference-এর পথ)raise ReturnSignal(v), ধরে call()কোড ছোট; মাঝের কেউ কিছু জানে নাছোড়া-ধরার খরচ host-এর ওপর নির্ভর; ভুল জায়গায় ধরলে চুপচাপ ভুল ফল
ফলাফল-সংকেত (completion)প্রতিটি exec ফেরত দেয় ("normal",) বা ("return", v); প্রতিটি loop পরীক্ষা করেকোনো লুকানো লাফ নেই; যেকোনো ভাষায় লেখা যায়প্রতিটি statement-এর পরে একটি if; ভুলে গেলে বাগ
নিজস্ব stack বা bytecodeframe নিজে রাখা; RETURN instruction frame ফেলেhost-এর stack-এর সীমা নেই; দ্রুতবেশি কোড: পর্ব ৫৮–৫৯-এর বিষয়

৬ · Runtime error, অবস্থান আর stack-এর সীমা

Type-checked Haat program-এ চলার সময় ঠিক তিন রকম ভুল সম্ভব (decision 26): division by zero, stack overflow আর 'k' is not initialized yet. প্রতিটির বার্তা <line>:<col>: runtime error: <message>, আর অবস্থান একটি নির্দিষ্ট node-এর: ভাগের ক্ষেত্রে / বা % operator, stack overflow-এ callee-র শুরু, অনিয়মিত নামের ক্ষেত্রে নামটি নিজে (decision 24). এটি সম্ভব কারণ parser প্রতিটি node-এ line, col রেখেছিল (পর্ব ৪৭), আর arith সেগুলো হাতে নিয়েই ডাকা হয়। Program থামে, কিন্তু error-এর আগে যা ছাপা হয়েছে তা থাকে। examples/err_divzero.haat ধাপে ধাপে:

1// runtime error: output before …2fn share(total: Int, people: Int) -> Int {3    return total / people;4}5print(share(1000, 4));6print(share(1000, 0));7print("never printed");
Interpreter-এর ভেতরে
চলছে
Env
depth
  1. প্রথম print. run আগে share-কে G-তে বসায় (hoisting), তারপর লাইন ৫: share(1000, 4) = 250, ছাপা হলো। Call শেষ, গভীরতা আবার ০.
  2. দ্বিতীয় call. লাইন ৬-এর Call (6:7): argument 1000 আর 0. নতুন Env E1, গভীরতা ১. এখনো কিছু ভুল হয়নি: শূন্য একটি বৈধ Int.
  3. ভাগ. return total / people;-এর Binary, অবস্থান 3:18, অর্থাৎ / চিহ্নটি। বাঁ পাশ 1000, ডান পাশ 0, দুটিই আগে হিসাব হয়েছে।
  4. ভুল ধরা. arith ভাগের জন্য c_div(1000, 0, 3, 18) ডাকে, যার প্রথম লাইন if b == 0: HaatError(3, 18, "division by zero") ছোড়ে। অবস্থান এসেছে node থেকে, operator-এর।
  5. Unwinding. Error ওপরে ওঠে। call()-এর except ReturnSignal এটি ধরে না, কারণ ধরন আলাদা; কিন্তু finally চলে, গভীরতা ০. exec(Print 6:1) কিছু ছাপার আগেই বাদ, run-ও থামে: লাইন ৭ কখনো চলে না।
  6. বার্তা. Reference-এর haat.py HaatError ধরে, আগে stdout flush করে (যাতে 250 আগে থাকে), তারপর stderr-এ বার্তা, exit status ১. ল্যাবে সত্যিকারের run: stdout-এ শুধু 250, stderr-এ 3:18: runtime error: division by zero.

১,০০০ call-এর সীমা, আর host-এর stack

অসীম recursion থামাতে call() একটি গণনা রাখে: ১,০০০টি call আগে থেকে চলমান থাকলে পরেরটি stack overflow. পর্ব ৫৯-এর VM-এও সীমা হুবহু এক, যাতে দুই back end সবসময় একই উত্তর দেয় (পর্ব ৩০-এ এর কারণ দেখেছেন)। কিন্তু একটি tree-walking interpreter-এ Haat-এর প্রতিটি call Python-এর কয়েকটি frame খায়। ল্যাবে fn d(n: Int) -> Int { if n == 0 { return 0; } return d(n - 1); } মেপে দেখা গেছে, প্রতিটি নতুন Haat call-এ Python stack ৪টি frame বাড়ে: call → exec_block → exec(Return) → eval(Call) → আবার call. Python-এর ডিফল্ট recursion limit ১,০০০ frame. সত্যিকারের run, Python 3.14.4:

$ python -B exp3.py      # পাতার interpreter, sys.setrecursionlimit(1000)
d(240): ['0']
d(250): ['RecursionError: maximum recursion depth exceeded']
$ python -B exp3.py      # sys.setrecursionlimit(40000), reference-এর মতো
d(999): ['0']
d(1000): ['1:54: runtime error: stack overflow']
$ python -B haat.py run d1000.haat ; python -B haat.py vm d1000.haat
1:54: runtime error: stack overflow
1:54: runtime error: stack overflow

ডিফল্ট সীমায় interpreter ২৫০-টির মতো Haat call-এও পৌঁছায় না, আর ভেঙে পড়ে Haat-এর বার্তা দিয়ে নয়, Python-এর একটি RecursionError দিয়ে: ঠিক সেই “host-এর ভুল guest-এর মুখে” যা কখনো হওয়া উচিত নয়। তাই reference শুরুতেই সীমা বাড়িয়ে ৪০ × ১,০০০ = ৪০,০০০ করে (এই পাতার সহায়ক module-ও তাই করে), যাতে nested if আর লম্বা expression-সহ ১,০০০ Haat call-ও Python-এর সীমার অনেক নিচে থাকে, আর সীমাটি সবসময় Haat নিজে গুনে ঠিক করে। d(999) মানে ১,০০০টি call (999 থেকে 0), যা চলে; d(1000) মানে ১,০০১টি, যা আটকায়, আর অবস্থান 1:54, body-র ভেতরের d. Interpreter আর VM একই লাইন দিয়েছে। Recursion-এর গভীরতা কমানোর অন্য পথ, tail call, পর্ব ৩২-এ; Haat v1-এ সেটি নেই।

তৃতীয় ব্লক তিনটি runtime error দেখায়, তারপর দুটি test চালায়। run_src একটি program চালিয়ে ছাপা লাইনগুলো একটি তালিকায় তোলে, আর error হলে তার বার্তা শেষ লাইন হিসেবে, ঠিক reference-এর stdout আর stderr পরপর পড়লে যা দেখায়। প্রথম test: reference-এর examples/ ফোল্ডারের ১০টি চালানো যায় এমন উদাহরণ (পাতায় রাখা, সঙ্গে তাদের প্রত্যাশিত আউটপুটের .out golden file). দ্বিতীয়: ৪০০টি এলোমেলো Int expression, প্রতিটির উত্তর একটি আলাদাভাবে লেখা oracle থেকে, যা wrap আর C-র ভাগ অন্য পথে হিসাব করে (reference-এর নিজের test-এর ধাঁচে):

import random
def run_src(src):                 # printed lines, then the runtime error (if any) as the last line
    lines = []; it = Interpreter(); it.out = lambda text: lines.extend(text.split("\n"))
    try: it.run(parse(src))
    except HaatError as err: lines.append(str(err))
    return lines
print(run_src(open("err_divzero.haat", encoding="utf-8").read()))
print(run_src("fn down(n: Int) -> Int { return down(n + 1); }\nprint(down(0));"))
print(run_src("print(f()); let k = 1; fn f() -> Int { return k; }"))
EXAMPLES = "bazar counter recursion mutual shadowing shortcircuit strings loops nested err_divzero".split()
same = sum(run_src(open(f"{n}.haat", encoding="utf-8").read())
           == open(f"{n}.out", encoding="utf-8").read().splitlines() for n in EXAMPLES)
print(f"examples: {same}/{len(EXAMPLES)} identical to the golden .out files")
def w64(n):                       # independent wrap: keep the low 64 bits, read bit 63 as the sign
    n &= (1 << 64) - 1
    return n - (1 << 64) if n >> 63 else n
def oracle(op, a, b):             # C semantics written another way (floor division, then corrected)
    if "div0" in (a, b) or (op in "/%" and b == 0): return "div0"
    q = a // b if op in "/%" else 0
    if q < 0 and q * b != a: q += 1
    return w64({"+": a + b, "-": a - b, "*": a * b, "/": q, "%": a - b * q}[op])
SEEDS = [0, 1, 2, 3, 7, 10, 100, 1000, 3037000500, 9223372036854775807]
def gen(rng, d):                  # random Int expression: (Haat source, expected value or "div0")
    if d == 0 or rng.random() < 0.25:
        n = rng.choice(SEEDS) if rng.random() < 0.6 else rng.randint(0, 50); return str(n), n
    if rng.random() < 0.15:
        s, v = gen(rng, d - 1); return f"-({s})", v if v == "div0" else w64(-v)
    op = rng.choice("+-*/%"); (ls, a), (rs, b) = gen(rng, d - 1), gen(rng, d - 1)
    return f"({ls} {op} {rs})", oracle(op, a, b)
rng, agree, div0 = random.Random(56), 0, 0
for _ in range(400):
    src, want = gen(rng, 4); got = run_src(f"print({src});")[-1]; div0 += want == "div0"
    agree += got.endswith("division by zero") if want == "div0" else got == str(want)
print(f"random expressions: {agree}/400 agree with the oracle ({div0} divide by zero)")

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

['250', '3:18: runtime error: division by zero']
['1:33: runtime error: stack overflow']
["1:47: runtime error: 'k' is not initialized yet"]
examples: 10/10 identical to the golden .out files
random expressions: 400/400 agree with the oracle (81 divide by zero)

তিনটি error-ই reference-এর haat.py run-এর লেখার সঙ্গে অক্ষরে অক্ষরে এক। down কখনো থামে না; ১,০০১তম call আটকায় 1:33-এ, return down(n + 1)-এর down-এ। তৃতীয়টি decision 18-এর ফাঁক: f hoisted, তাই লাইনের শুরুতেই ডাকা যায়, কিন্তু তখনো let k = 1; চলেনি; error return k-এর k-এ, 1:47. দশটি উদাহরণের আউটপুট golden file-এর সঙ্গে হুবহু, যার মধ্যে closure, পারস্পরিক recursion, wrap আর বাংলা string আছে (strings.haat-এর একটি string-এ \n থাকায় দুই লাইন ছাপে, তাই run_src লেখা ভাগ করে)। Oracle-এর সঙ্গে ৪০০টিতেই মিল, যার ৮১টিতে কোথাও শূন্য দিয়ে ভাগ। Seed (৫৬) স্থির, তাই সংখ্যাগুলো প্রতিবার এক। বাকি তিনটি উদাহরণ (err_syntax, err_names, err_types) static error-এর, interpreter পর্যন্ত পৌঁছায়ই না।

৭ · Reference-এর সঙ্গে মেলানো, আর গাছে হাঁটার দাম

ব্রাউজারে reference নেই, তাই ল্যাবে আরও বড় একটি differential test চালানো হয়েছে: পাতার প্রথম দুই ব্লকের interpreter আর reference-এর interp.py, একই ইনপুটে, আউটপুট (ছাপা লাইন আর runtime error) তুলনা। এলোমেলো program-গুলো একটি ছোট generator থেকে, seed ৫৬: ০–৩টি top-level function (আগের function ডাকতে পারে), let/var, assignment, if/else, সীমিত while, আর Int ও Bool expression-এ সব operator. প্রতিটি আগে reference-এর resolver আর type checker পার হতে হয়েছে। সত্যিকারের run, Python 3.14.4:

$ python -B difftest.py 2000
examples: 10/10 identical (3 rejected by the static checks)
random programs: 2000/2000 identical output (0 rejected by the checker, 583 end in a runtime error, 9220 output lines in all)

সংখ্যা ভালো, কিন্তু test-এর শক্তি কতটা? একটি পরিচিত উপায় হলো mutation testing: interpreter-এ ইচ্ছা করে একটি করে বাগ বসিয়ে দেখা, test সেটি ধরে কি না (Software Testing & QA-র পর্ব ৫৯). ল্যাবে চারটি বাস্তবসম্মত বাগ, প্রতিটি reference-এর একই ১০টি চালানো যায় এমন উদাহরণ আর একই ২,০০০টি program-এ:

ইচ্ছাকৃত বাগউদাহরণে ধরা২,০০০ এলোমেলো program-এ অমিল
M1: / আর %-এ Python-এর // আর %১টি (loops.haat)২৯৬
M2: &&-এ দুই পাশই আগে হিসাব১টি (shortcircuit.haat)০
M3: ReturnSignal call()-এ নয়, exec_block-এ ধরা৪টি (bazar, mutual, nested, recursion)১১৪
M4: পুরো while-এ একটিই Env১টি (nested.haat)০

M2 আর M4 দুই হাজারের একটিতেও ধরা পড়েনি। কারণ generator-এর সীমা: তার &&-এর ডান পাশ প্রায় কখনো error বা ছাপার মতো পার্শ্বফল ঘটায় না, আর সে কখনো loop-এর ভেতরে closure বানায় না। দুটিই ধরেছে হাতে লেখা একটি করে উদাহরণ। শিক্ষাটি পর্ব ৪৭-এর parser-এর মতোই: এলোমেলো test সেই ভুলই খোঁজে যা তার generator তৈরি করতে পারে; ভাষার প্রতিটি সূক্ষ্ম নিয়মের (short-circuit, প্রতি ঘোরায় নতুন scope) জন্য অন্তত একটি হাতে লেখা golden উদাহরণ রাখুন।

গতির দাম

Tree-walking সহজ, কিন্তু ধীর। একই fib(22) (ফল 17711) তিনভাবে, এক মেশিনে, পাঁচবার চালিয়ে median; শুধু ধারণা দেওয়ার জন্য, benchmark নয় (Python 3.14.4, Windows, x86-64):

$ python -B timing.py
interp: 0.197s  vm: 0.160s  cpython: 0.0015s  interp/vm=1.23  interp/py=130
{'eval': 515815, 'exec': 114627, 'call': 57313}

একই কাজ সরাসরি Python-এ লিখলে প্রায় ১৩০ গুণ দ্রুত। কারণগুলো গুনে দেখা যায়: ৫৭,৩১৩টি Haat call-এর জন্য interpreter-এর eval ডাকা হয়েছে ৫,১৫,৮১৫ বার আর exec ১,১৪,৬২৭ বার। প্রতিটি ডাকে একটি Python frame, তারপর isinstance-এর শিকলে node-এর ধরন খোঁজা; প্রতিটি নাম পড়তে dict-এর শিকল বেয়ে ওঠা (fib নামটি প্রতিবার call-এর Env থেকে global পর্যন্ত); প্রতিটি call-এ নতুন dict; প্রতিটি return-এ একটি exception. Reference-এর bytecode VM এখানে মাত্র ১.২–১.২৫ গুণ দ্রুত, কারণ সেটিও Python-এ লেখা আর শেখানোর জন্য সরল রাখা। গতির বড় লাভ আসে যখন VM নাম খোঁজার বদলে slot-এর সংখ্যা ব্যবহার করে, আর instruction-চক্র একটি দ্রুত ভাষায় লেখা হয়: পর্ব ৫৮–৫৯ সেই নকশা, আর পর্ব ৬১ (JIT) তার পরের ধাপ। CPython নিজেও AST নয়, bytecode চালায় (Python কোর্সের পর্ব ০৫).

আরও গভীরে: “AST চালানো ধীর” সবসময় সত্য নয়। Ruby-র মূল বাস্তবায়ন (MRI) ১.৮ পর্যন্ত একটি AST interpreter ছিল; ২০০৭ সালে Ruby 1.9 YARV নামের bytecode VM-এ সরে যায়, মূলত গতির জন্য। অন্যদিকে Oracle Labs-এর Truffle framework (Würthinger ও সহকর্মীদের ২০১২–২০১৩-এর প্রবন্ধ) ইচ্ছা করেই AST interpreter রাখে: চলার সময় node নিজেকে বিশেষায়িত রূপে বদলে নেয় (যেমন “এখানে সবসময় দুটি int এসেছে”), আর Graal compiler পুরো interpreter-এর partial evaluation করে machine code বানায়। এভাবে একটি সরল tree-walking interpreter থেকেই JIT-এর কাছাকাছি গতি পাওয়ার দাবি করা হয়, যার বিস্তারিত পর্ব ৬১-এর ধারণার সঙ্গে মিলবে।

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

  • Tree-walking interpreter আর bytecode VM-এর পার্থক্য? প্রথমটি AST সরাসরি চালায় (সহজ, ধীর); দ্বিতীয়টি আগে একটি সমতল instruction তালিকা বানিয়ে loop-এ চালায় (বেশি কাজ, দ্রুত, ছোট মেমরি)।
  • একটি ছোট calculator বা expression interpreter লিখুন। প্রতিটি node-এ একটি শাখা: literal → মান, binary → দুই পাশ recursive হিসাব করে operator; operator-এর অর্থ (integer ভাগ, overflow) স্পষ্ট করুন।
  • Interpreter-এ return কীভাবে বাস্তবায়ন করবেন? Host-এর exception দিয়ে (ধরবে function call), বা প্রতিটি statement একটি ফলাফল-সংকেত ফেরত দিয়ে।
  • Static আর dynamic scoping interpreter-এ কোথায় আলাদা? Call-এর নতুন environment-এর parent: function তৈরির environment হলে static, caller-এর হলে dynamic.
  • Short-circuit কোথায় বাস্তবায়িত হয়? &&/||-কে সাধারণ binary operator-এর পথে পাঠানো যায় না; বাঁ পাশ দেখে তবেই ডান পাশ হিসাব।

৮ · AI-এর যুগে interpreter লেখা

“একটি ছোট ভাষার interpreter লিখে দাও” AI assistant-এর জন্য সহজ কাজ, আর ফল প্রায়ই প্রথম উদাহরণে ঠিক চলে। ভুল থাকে ভাষার সূক্ষ্ম নিয়মে, যেখানে assistant নিজের পরিচিত ভাষার (সাধারণত Python বা JavaScript) নিয়ম চুপচাপ বসিয়ে দেয়। বারবার দেখা ভুল:

AI-এর ভুলকীভাবে ধরবেন
ভাগে host-এর // আর %, বা float-এর /-7 / 2, 7 % -2, -7 % 2-এর প্রত্যাশিত মান golden file-এ
Python-এর সীমাহীন int ধরে নেওয়া, wrap না করা9223372036854775807 + 1, 3037000500 * 3037000500
ছাপায় True/False, বা show-এ int আগে যাচাইprint(1 < 2);-এর আউটপুট true কি না
Operator-এর একটি টেবিল দিয়ে সব binary, ফলে &&/||-এ দুই পাশ আগে হিসাবডান পাশে ছাপা বা শূন্য দিয়ে ভাগ রেখে test (shortcircuit.haat)
Call-এ caller-এর env দিয়ে নতুন scope (dynamic scoping)বাইরের আর ভেতরের একই নামের variable-সহ closure-এর test
return-এর exception ভুল জায়গায় ধরা, বা loop-এ একটি Envbazar.haat (৯৯৬ না এলে সন্দেহ), loop-এ তৈরি closure
“interpreter” বলতে Python-এর eval()-এ source পাঠানোHaat আর Python-এর অর্থ আলাদা, আর অবিশ্বস্ত লেখা চালানো নিরাপত্তার ঝুঁকি (পর্ব ১২)
“Python-এ recursion limit নেই” বা গভীরতার সীমা না রাখা১,০০১ স্তরের recursion চালিয়ে দেখা: Haat-এর বার্তা, না Python-এর traceback

AI-কে কাজে লাগানোর ভালো উপায়: ভাষার নিয়ম নিজে দিন, বিশেষ করে যেখানে সেটি host-এর থেকে আলাদা; আর কোডের সঙ্গে test-ও চান, যাতে নিজে চালিয়ে মেলাতে পারেন।

আমি Haat নামের একটি ছোট ভাষার tree-walking interpreter লিখছি (Python 3). AST class আর তাদের field নিচে দিলাম; program আগেই type check করা। ১. eval(e, env) আর exec(s, env) লেখো; environment হবে dict আর parent-এর শিকল, call-এর নতুন env-এর parent হবে function তৈরির env (static scoping). ২. Int ৬৪-বিট two's complement, প্রতিটি হিসাবের পরে wrap; / আর % C-র মতো শূন্যের দিকে কাটে; শূন্য দিয়ে ভাগে "line:col: runtime error: division by zero", অবস্থান operator-এর। ৩. && আর || short-circuit; বাঁ থেকে ডানে হিসাব; Bool ছাপা হবে true/false. ৪. return একটি exception দিয়ে, যা শুধু function call-এ ধরা হবে; ১,০০০টির বেশি nested call হলে "stack overflow". ৫. কোডের পরে আলাদা করে ১০টি test দাও, প্রতিটির প্রত্যাশিত আউটপুটসহ: -7 / 2, -7 % 2, সবচেয়ে বড় Int + 1, short-circuit-এ শূন্য দিয়ে ভাগ, loop-এ তৈরি closure, else-এর পরে return, আর ১,০০১ স্তরের recursion. ৬. কোনো নিয়মে নিশ্চিত না হলে “নিশ্চিত নই” লেখো; Python-এর নিয়ম ধরে নিয়ে লিখবে না। [এখানে AST class-এর তালিকা]

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

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

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

প্র ০১LISP-এর eval থেকে SICP পর্যন্ত, একটি ভাষার interpreter সেই ভাষাতেই লেখার ঐতিহ্য কেন এত প্রভাবশালী, আর Haat-এর Python interpreter থেকে এ বিষয়ে কী শেখা যায়?

John McCarthy-র ১৯৬০ সালের প্রবন্ধ “Recursive Functions of Symbolic Expressions and Their Computation by Machine” LISP-কে বর্ণনা করতে গিয়ে LISP-এর ভেতরেই একটি eval function লেখে: একটি expression আর একটি environment নিয়ে মান ফেরত দেয়, ঠিক এই পর্বের eval(e, env). প্রচলিত বিবরণ অনুযায়ী McCarthy এটিকে প্রথমে একটি তাত্ত্বিক বর্ণনা ভেবেছিলেন, কিন্তু Steve Russell সেটি হাতে IBM 704-এর machine code-এ অনুবাদ করেন, আর এভাবেই প্রথম LISP interpreter চালু হয় (দিন-তারিখ নিয়ে উৎসভেদে সামান্য পার্থক্য আছে)। পরে Abelson আর Sussman-এর “Structure and Interpretation of Computer Programs” (১৯৮৫) বইয়ের চতুর্থ অধ্যায় পুরো একটি Scheme evaluator Scheme-এই লেখে, eval আর apply-এর পারস্পরিক ডাক দিয়ে; একে বলা হয় metacircular interpreter.

প্রভাবের কারণ দুটি। প্রথমত, এটি দেখায় যে একটি ভাষার অর্থ একটি ছোট program দিয়ে সম্পূর্ণ বলা যায়: গণনার তত্ত্বের universal machine-এর ধারণা (গণনার তত্ত্বের পর্ব ৪৮) এখানে হাতে-কলমে। দ্বিতীয়ত, ভাষার নকশায় পরীক্ষা সস্তা হয়ে যায়: evaluator-এ দুই লাইন বদলে lazy evaluation বা নতুন scope-নিয়ম চেষ্টা করা যায়।

কিন্তু metacircularity-র একটি ফাঁদ আছে, আর Haat-এর Python interpreter তা স্পষ্ট দেখায়। যে সুবিধা host থেকে ধার নেওয়া হয়, guest-এর ভাষায় তার অর্থ কী, তা interpreter আর বলে না। Python-এর recursion দিয়ে Haat-এর recursion বানালে Haat-এর গভীরতার সীমা Python-এর ওপর নির্ভর করে, যতক্ষণ না নিজে একটি সীমা গোনা হয়। Python-এর exception দিয়ে return বানালে তার খরচ Python-এর exception-এর খরচ। Python-এর int দিয়ে Int বানালে overflow নিজে লিখতে হয়, নইলে ভাষার অর্থ চুপচাপ Python-এর হয়ে যায়। একটি evaluator যত বেশি ধার নেয়, তত ছোট, কিন্তু তত কম কথা বলে। এ কারণেই পর্ব ৫৮–৫৯-এর VM নিজের stack আর frame নিজে রাখে।

মূল উপলব্ধি: নিজের ভাষায় নিজের interpreter শেখার জন্য অসাধারণ, কিন্তু spec হিসেবে পড়ার সময় প্রশ্ন করুন: এই লাইনটি নিয়মটি নিজে বলছে, না host-এর নিয়মের ওপর ভরসা করছে?

প্র ০২return-এর জন্য exception, না প্রতিটি statement থেকে একটি ফলাফল-সংকেত? বাস্তব interpreter আর ভাষার spec এই প্রশ্ন কীভাবে মিটিয়েছে?

Robert Nystrom-এর বই “Crafting Interpreters” (অনলাইনে ধারাবাহিক, ২০২১ সালে বই আকারে) তার Java-তে লেখা tree-walking interpreter jlox-এ ঠিক reference-এর পথ নেয়: return একটি Return exception ছোড়ে, যা function call ধরে। বইটি নিজেই স্বীকার করে এটি exception-এর “অপব্যবহার”, আর খরচ কমাতে Java-র stack trace তৈরি বন্ধ রাখে, কারণ এই exception কোনো ভুল নয়, শুধু control flow. যুক্তি সরল: return যত গভীরেই থাকুক, মাঝের কোনো কোডকে এর কথা জানতে হয় না।

উল্টো পথের সবচেয়ে বিখ্যাত উদাহরণ JavaScript-এর spec নিজে। ECMAScript-এ প্রতিটি statement-এর মূল্যায়ন একটি “Completion Record” ফেরত দেয়, যার ধরন normal, break, continue, return বা throw, সঙ্গে একটি মান। Block-এর নিয়ম বলে: একটি statement-এর completion normal না হলে সেখানেই থামতে হবে আর সেটিই ওপরে পাঠাতে হবে। break আর continue-এ লেবেলও থাকে। Spec-এর জন্য এটি স্বাভাবিক, কারণ spec-এ কোনো host exception নেই; প্রতিটি লাফ স্পষ্ট লিখতে হয়। একটি C-তে লেখা interpreter-ও সাধারণত এই পথে যায়, কারণ C-তে exception নেই (setjmp/longjmp সম্ভব, কিন্তু ঝুঁকিপূর্ণ)।

খরচের প্রশ্নটি host-নির্ভর। CPython 3.11 থেকে “zero-cost” exception: try block-এ ঢোকার কোনো খরচ নেই, শুধু সত্যিই ছোড়া হলে খরচ। Reference-এ প্রায় প্রতিটি call একটি return দিয়ে শেষ হয়, তাই প্রায় প্রতিটি call-এ একবার ছোড়া আর ধরা; অংশ ৭-এর ধীরগতির একটি অংশ এটিই। ফলাফল-সংকেতে প্রতিটি statement-এর পরে একটি তুলনা লাগে, কিন্তু কোনো লাফ নেই। কোনটি দ্রুত, তা মেপে দেখতে হয়; অনুমানে বলা যায় না। break/continue যোগ করলে (Haat v1-এ নেই) দুটি পথই সহজে বাড়ে: আরও দুটি exception, বা আরও দুটি completion-ধরন।

মূল উপলব্ধি: exception-পথ কোড ছোট রাখে আর host-এর ওপর নির্ভর করে; completion-পথ সব লাফ স্পষ্ট লেখে আর যেকোনো ভাষায় চলে। দুটিই একই semantics দেয়, যতক্ষণ “কে ধরবে” প্রশ্নের উত্তর ঠিক থাকে, যা M3 বাগ দেখিয়েছে।

প্র ০৩Haat-এর interpreter-এ static scoping মাত্র একটি শব্দের ব্যাপার: Env(f.env), Env(env) নয়। ইতিহাসে এই এক শব্দের পার্থক্য কেন এত বড় হয়ে উঠেছিল?

প্রথম দিকের LISP বাস্তবায়নগুলো কার্যত dynamic scoping করত: একটি function-এর ভেতরের মুক্ত নাম খোঁজা হতো ডাকার মুহূর্তের environment-এ, অর্থাৎ caller-এর দিকে। Interpreter-এর ভাষায় নতুন call-এর env-এর parent ছিল ডাকার জায়গার env. এটি বাস্তবায়নে সহজ, কারণ একটি stack-এ নাম ঠেলে দিলেই হয়; কিন্তু একটি function-কে argument হিসেবে পাঠালে তার মুক্ত নাম অন্য কারও variable ধরে ফেলত। এই সমস্যার নাম হয় “funarg problem”; ১৯৭০ সালের দিকে Joel Moses-এর একটি MIT memo এটি বিস্তারিত ব্যাখ্যা করে, আর সমাধান হিসেবে function-এর সঙ্গে তার environment জুড়ে রাখার কথা বলে, যাকে আজ closure বলি।

ALGOL 60 শুরু থেকেই lexical scope-এর ভাষা ছিল, আর Peter Landin-এর ১৯৬৪ সালের SECD machine function-মানকে “closure” নামে (code + environment) আনুষ্ঠানিক রূপ দেয়। Scheme (১৯৭৫, Steele আর Sussman) LISP পরিবারে lexical scoping নিয়ে আসে, আর তার সাফল্যের পরে Common Lisp-ও lexical scoping-কে ডিফল্ট করে, যদিও “special” variable-এর জন্য dynamic scoping রেখে দেয়। Emacs Lisp দীর্ঘদিন dynamic scoping-এ ছিল; Emacs 24 (২০১২) ফাইলভিত্তিক lexical-binding যোগ করে।

Haat-এর interpreter-এ পার্থক্যটি কত ছোট, সেটিই শিক্ষণীয়। Env(f.env) মানে “function যেখানে লেখা”, Env(env) মানে “function যেখান থেকে ডাকা”। Static scoping-এর দাম হলো প্রতিটি function-মানের সঙ্গে একটি Env জমা রাখা, আর সেই Env তার block শেষ হওয়ার পরেও বেঁচে থাকতে পারে, তাই Env stack-এ নয়, heap-এ রাখতে হয়। একটি stack-ভিত্তিক বাস্তবায়নে (C, বা পর্ব ৫৯-এর VM) এটি সত্যিকারের কাজ চায়: cell, upvalue, বা heap-এ রাখা frame. পর্ব ৫৭ এই বাস্তবায়নের পথগুলো তুলনা করবে।

মূল উপলব্ধি: scope-নিয়ম একটি interpreter-এ একটি parent-সংযোগের পছন্দ। Static scoping বাছলে নাম চালানোর আগেই resolve করা যায়, type checker কাজ করতে পারে, আর function argument হিসেবে নিরাপদে পাঠানো যায়; দাম হলো environment-কে heap-এ বাঁচিয়ে রাখা।

প্র ০৪Interpreter-এর recursion host-এর stack খায়। বাস্তব ভাষার runtime গভীর recursion কীভাবে সামলায়, আর Haat কেন নিজে একটি সংখ্যা গোনে?

প্রতিটি ভাষার runtime-এর একটি সীমা আছে, আর তা কীভাবে প্রকাশ পায় সেটিই পার্থক্য। CPython-এ Python function-এর গভীরতার একটি গণনা আছে, ডিফল্ট ১,০০০, যা sys.setrecursionlimit দিয়ে বদলানো যায়; সীমা ছাড়ালে একটি ধরা যায় এমন RecursionError. Java-তে থ্রেডের stack-এর আকার (-Xss) সীমা ঠিক করে, আর ছাড়ালে StackOverflowError, যা একটি Error, সাধারণ exception নয়। JavaScript engine-গুলোতে সীমা engine আর stack-আকারের ওপর নির্ভর করে, বার্তা সাধারণত “Maximum call stack size exceeded” ধরনের একটি RangeError. C-তে কোনো যাচাই নেই: stack ফুরালে সাধারণত segmentation fault.

একটি tree-walking interpreter-এ সমস্যা দ্বিগুণ: guest-এর প্রতিটি call host-এর কয়েকটি frame. অংশ ৬-এর মাপে Haat-এর একটি সরল recursive call Python-এর ৪টি frame; লম্বা expression বা nested if-এর ভেতরে ডাক হলে আরও বেশি। Reference যদি শুধু Python-এর সীমার ওপর ভরসা করত, তাহলে একই Haat program কখনো চলত, কখনো Python-এর traceback দিত, nesting-এর ধরন অনুযায়ী; আর VM, যার frame প্রতি call-এ একটি, একেবারে অন্য সংখ্যায় থামত। নিজে গুনলে (১,০০০) সীমাটি ভাষার নিয়ম হয়ে যায়: দুই back end-এ এক, বার্তা Haat-এর, অবস্থান callee-র। Python-এর সীমা তখন শুধু একটি নিরাপত্তা-জাল, ৪০,০০০-এ রাখা।

আরও গভীর recursion চাইলে পথ কী? (১) Tail call optimization, যা Scheme-এর spec বাধ্যতামূলক করে (পর্ব ৩২); একটি tree-walker-এ এটি trampoline দিয়ে করা যায়। (২) Interpreter-কে নিজস্ব stack দিয়ে লেখা, যেমন continuation-ভিত্তিক CEK machine (পর্ব ৪০) বা bytecode VM, যেখানে guest-এর গভীরতা শুধু heap-এর মাপে সীমিত। (৩) Stack-এর আকার বাড়ানো, যা host-এর ওপর নির্ভরশীল আর বহনযোগ্য নয়।

মূল উপলব্ধি: একটি ভাষার আচরণ কখনো তার বাস্তবায়নের দুর্ঘটনা হওয়া উচিত নয়। গভীরতার সীমা একটি দৃশ্যমান, পরীক্ষাযোগ্য নিয়ম হলে দুই বাস্তবায়ন একমত থাকে, আর ব্যবহারকারী সবসময় নিজের ভাষার বার্তা দেখেন।

প্র ০৫একটি interpreter “সঠিক”, এটি কীভাবে দেখানো যায়? Differential testing-এর ইতিহাস আর এই পর্বের mutation-এর ফল থেকে কী শেখা যায়?

“সঠিক” মানে ভাষার semantics-এর সঙ্গে মেলা। পূর্ণ প্রমাণ সম্ভব, কিন্তু ব্যয়বহুল: CompCert-এর মতো verified compiler-এ (পর্ব ৪৪) প্রতিটি ধাপের semantics-রক্ষা একটি proof assistant-এ প্রমাণিত। বেশিরভাগ বাস্তবায়ন test-এ ভরসা করে, আর সেখানে মূল প্রশ্ন হলো “সঠিক উত্তর কে বলবে?”, অর্থাৎ oracle. William McKeeman ১৯৯৮ সালে Digital Technical Journal-এ “Differential Testing for Software” প্রবন্ধে একটি সহজ উত্তর দেন: একই ইনপুট দুটি স্বাধীন বাস্তবায়নে চালানো, আর উত্তর আলাদা হলে অন্তত একটি ভুল। তিনি C compiler-গুলোর ওপর এটি প্রয়োগ করেছিলেন।

এই ধারণা পরে অনেক বড় হয়েছে। Utah বিশ্ববিদ্যালয়ের Csmith (Yang, Chen, Eide আর Regehr, PLDI ২০১১) এলোমেলো কিন্তু undefined behavior-মুক্ত C program বানিয়ে GCC আর LLVM-এর ফল মেলায়, আর প্রবন্ধে তিন শতাধিক compiler বাগ রিপোর্ট করার কথা বলে। Haat-এর reference নিজেও এই পথে: interpreter আর VM-কে প্রতিটি উদাহরণ আর ৪০০টি এলোমেলো expression-এ মেলায়, আর একটি স্বাধীন oracle রাখে।

কিন্তু অংশ ৭-এর mutation টেবিল একটি সীমা দেখায়। দুই হাজার এলোমেলো program M2 (short-circuit ভাঙা) আর M4 (loop-এ একটি Env) একটিও ধরেনি, অথচ একটি করে হাতে লেখা উদাহরণ দুটিই ধরেছে। Differential test শুধু সেই আচরণ যাচাই করে যা generator ঘটায়। আরেকটি সূক্ষ্ম সীমা: দুই বাস্তবায়ন একই ভুল বুঝলে (দুটিই একই spec-এর একই ভুল ব্যাখ্যা থেকে লেখা) তারা একমত হয়ে ভুল করবে; তাই পাতার ব্লকের oracle reference-এর কোড ব্যবহার করে না, wrap আর ভাগ অন্য পথে লেখে। Mutation testing এখানে test-এর test: যে বাগ কোনো test ধরে না, সেটি একটি নতুন test-এর ঠিকানা।

মূল উপলব্ধি: ভালো interpreter-test তিন স্তরের: হাতে লেখা golden উদাহরণ (প্রতিটি সূক্ষ্ম নিয়মের জন্য), স্বাধীন বাস্তবায়নের সঙ্গে এলোমেলো differential test (প্রস্থের জন্য), আর mutation দিয়ে test-এর শক্তি মাপা।

অনুশীলন

প্রথমে নিজে করুন, তারপর উত্তর খুলে মেলান। প্রতিটি আউটপুট Haat reference বা পাতার interpreter-এর সত্যিকারের run থেকে।

  1. নকশা ও বাস্তবায়ন — ধাপের সীমা: একটি অনলাইন Haat playground বানাচ্ছেন; while true { } যেন সার্ভার আটকে না রাখে। পাতার Interpreter-কে বাড়িয়ে একটি সীমা যোগ করুন: ১০,০০০টির বেশি statement চালালে step limit exceeded (10000 statements) runtime error, যে statement-এ সীমা ছাড়াল তার অবস্থানে। শর্ত: স্বাভাবিক program-এর আউটপুট একটুও বদলাবে না, আর checker-এ কোনো বদল নয়।

    সব statement exec দিয়ে যায়, তাই সেখানে একটি গণনাই যথেষ্ট:

    STEP_LIMIT = 10_000
    class Fueled(Interpreter):
        steps = 0
        def exec(self, s, env):
            self.steps += 1
            if self.steps > STEP_LIMIT:
                raise HaatError(s.line, s.col, f"step limit exceeded ({STEP_LIMIT} statements)")
            return super().exec(s, env)

    ল্যাবের সত্যিকারের run:

    bazar.haat                       : ['996', '5000', '3']  (26 statements)
    var i = 0; / while true { i = i + 1; } / print(i);
                                     : ['2:14: runtime error: step limit exceeded (10000 statements)']
    2,000 random programs            : 2000/2000 same as reference run (largest: 1215 statements)

    bazar.haat মাত্র ২৬টি statement চালায় (hoisting-এর দুটি fn আর delivery-র else-block-সহ, কারণ পাতার exec else-এর block-কে একটি Block statement হিসেবেই চালায়)। অসীম loop-এ ১০,০০১তম statement হলো i = i + 1;, অবস্থান 2:14, যা Assign-এর নাম। Python-এর RecursionError বা সময়সীমার বদলে এখন একটি Haat-এর বার্তা। নকশার প্রশ্ন: সীমা কি statement গুনবে, না node (eval-ও)? Node গুনলে একটি লম্বা expression-ও ধরা পড়ে, কিন্তু খরচ বেশি; Haat-এ expression-এ loop নেই, তাই statement-গণনাই অসীমতা ধরতে যথেষ্ট, কারণ প্রতিটি loop-ঘোরা বা call অন্তত একটি statement চালায়। একই ধারণা বাস্তবে “fuel” বা instruction budget নামে পরিচিত।

  2. ভুল খুঁজুন — return কোথায় ধরা: একজন return “সরল” করতে call()-এর except সরিয়ে exec_block-এ ধরলেন। bazar.haat কী ছাপবে, ভুলটি ঠিক কোথায়, আর কোন test এটি ধরবে?
    def exec_block(self, stmts, env):
        for s in stmts:
            try: self.exec(s, env)
            except ReturnSignal as r: self.result = r.args[0]; return
    def call(self, f, args, node):
        ...                                   # depth check, new Env
        self.result = None
        try: self.exec_block(f.body, env); return self.result
        finally: self.depth -= 1

    ল্যাবে এই বাগ বসিয়ে সত্যিকারের run: bazar.haat ছাপে 1040, 5000, 3. প্রথম লাইন ৯৯৬ নয়।

    কারণ: return এখন শুধু নিজের সবচেয়ে ভেতরের block থেকে বের হয়। price-এ return p - p / 10; then-block-এর exec_block-এ ধরা পড়ে, result = 936, then-block শেষ; কিন্তু function-এর body চলতে থাকে, আর return p; result-কে 1040 করে দেয়। delivery(1040) দেয় 0 (সেখানে return-এর পরে body-তে কিছু নেই), তাই first = 1040 + 0. বাকি দুই লাইন top level-এ, কোনো return নেই, তাই ঠিক থাকে। নিয়মটি: return-এর লক্ষ্য সবচেয়ে কাছের function, block নয়; তাই ধরার জায়গা একমাত্র call(). অংশ ৭-এর টেবিলে এটিই M3: ৪টি উদাহরণ আর ২,০০০-এর ১১৪টি এলোমেলো program-এ অমিল, অর্থাৎ golden file আর differential test দুটিই সহজে ধরে, যদি return-এর পরে body-তে আরও statement থাকে।

  3. আউটপুট বলুন: নিচের Haat program reference-এর haat.py run-এ কী ছাপবে (stdout আর stderr দুটিই), আর exit status কত?
    fn check(n: Int) -> Bool {
        print(n);
        return n > 0;
    }
    print(-7 / 2 + -7 % 2);
    print(check(0) && check(1));
    print(check(5) || check(6));
    print(9223372036854775807 * 2);
    print(10 % (3 - 3));
    print("unreachable");

    Reference-এর সত্যিকারের আউটপুট:

    -4
    0
    false
    5
    true
    -2
    9:10: runtime error: division by zero

    Exit status ১. লাইন ধরে: -7 / 2 = -3, -7 % 2 = -1, যোগ -4 (Python-এর নিয়মে হতো -4 + 1 = -3). check(0) ছাপে 0 আর মিথ্যা দেয়, তাই && check(1) ডাকেই না: শুধু 0, তারপর false. check(5) ছাপে 5 আর সত্য, তাই || থামে: 5, তারপর true. (263 − 1) × 2 = 264 − 2, wrap করলে -2. লাইন ৯-এ % column 10-এ, তাই 9:10; শেষ লাইন কখনো চলে না।

  4. প্রমাণ — interpreter আর big-step semantics মেলে: Call আর Lambda-ছাড়া expression-এর জন্য দেখান: (ক) eval(e, env) সবসময় থামে (একটি মান দেয় বা HaatError ছোড়ে); (খ) যদি eval(e, env) মান v দেয়, তাহলে ⟨e, ρ⟩ ⇓ v নিয়মগুলো দিয়ে প্রমাণযোগ্য, যেখানে ρ হলো env-এর শিকল একসঙ্গে দেখলে নাম থেকে মানের function (ভেতরের নাম বাইরেরটিকে ঢাকে)। ধরে নিন e well-typed আর তার সব নাম ρ-তে আছে।

    প্রমাণের রূপরেখা (e-এর গঠনের ওপর structural induction):

    1. ভিত্তি. Num, Str, Bool: eval এক ধাপে node-এর মান দেয়, কোনো recursion নেই; নিয়ম B-Val (⟨v, ρ⟩ ⇓ v). Var x: find শিকল বেয়ে ওঠে; শিকল সসীম (প্রতিটি Env তৈরি হয়েছে আগে তৈরি একটি parent দিয়ে, তাই চক্র নেই), তাই থামে, আর প্রথম যে Env-এ x পায় সেটিই ρ(x): নিয়ম B-Var.
    2. Unary. IH অনুযায়ী operand-এর eval থামে আর মান v1. তারপর wrap(-v1) বা not v1, দুটিই এক ধাপ। নিয়ম: v1 থেকে ⊖̂ v1.
    3. Binary, &&/|| নয়. IH দুই সন্তানে: eval(e.left) থামে, মান v1 (বা error, তখন পুরোটাই error দিয়ে থামে); তারপর eval(e.right), v2. arith loop-হীন, তাই থামে: মান v1 ⊕̂ v2, বা ভাগে b = 0 হলে HaatError. এটি হুবহু B-Op-এর তিনটি premise.
    4. &&. eval(e.left) থামে (IH). মিথ্যা হলে Python-এর and ডান পাশ ডাকে না, মান false: B-AndF. সত্য হলে eval(e.right) (IH) মান v: B-AndT. || সমমিতভাবে।
    5. উপসংহার. প্রতিটি recursive ডাক কঠোরভাবে ছোট উপ-গাছে, আর গাছ সসীম, তাই (ক)। প্রতিটি শাখা ঠিক একটি নিয়মের premise থেকে conclusion-এ যায়, তাই (খ)। ∎

    Call যোগ করলে (ক) ভেঙে যায়: fn d(n: Int) -> Int { return d(n + 1); }-এ উপ-গাছ ছোট হয় না, কারণ call body-তে ফিরে যায়। তখন থামার নিশ্চয়তা আসে শুধু গভীরতার সীমা থেকে: ১,০০১তম call-এ stack overflow. ল্যাবে প্রথম ব্লকের Interpreter-এ মাপা সংখ্যা মেলান (দ্বিতীয় ব্লকের সংস্করণে প্রতিটি node-এ super()-এর জন্য দুটি ডাক): Call-ছাড়া p >= 1000 && p - p / 10 > 900-এ (p = 1040) eval ঠিক ১১ বার ডাকা হয়, গাছের ১১টি node-এর জন্য একবার করে, আর p = 520-এ ৪ বার: JS ব্লকের গণনার সঙ্গে এক।

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

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

ক্রমHaat-এর tree-walking interpreter price(2, 520) হিসাব করে, যেখানে fn price(qty: Int, unit: Int) -> Int { let p = qty * unit; if p >= 1000 { return p - p / 10; } return p; }. কাজগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Callee price নামটি Env-এর শিকলে খুঁজে function-মান পাওয়া
  2. Argument 2 আর 520 বাঁ থেকে ডানে হিসাব
  3. গভীরতা যাচাই, তারপর function-এর নিজের Env-এর ভেতরে নতুন Env-এ qty আর unit বসানো
  4. let p চালিয়ে নতুন Env-এ p = 1040
  5. শর্ত সত্য, then-block-এর জন্য আরেকটি নতুন Env
  6. return 936 নিয়ে signal ছোড়ে, আর call সেটি ধরে 936 ফেরত দেয়

Haat reference interpreter-এ print(-7 / 2); কী ছাপে?

  • -4
  • -3
  • -3.5
  • runtime error

একটি Python-এ লেখা tree-walking interpreter return বাস্তবায়ন করে raise ReturnSignal(v) দিয়ে। এই exception কোথায় ধরা উচিত?

  • exec-এর Return শাখায়
  • প্রতিটি exec_block-এ
  • Function call চালানোর জায়গায় (call())
  • শুধু program-এর run-এ

Haat-এ let p = 1040; তারপর print(p > 0 || p / 0 == 1);. Reference interpreter কী করে?

  • true ছাপে
  • শূন্য দিয়ে ভাগের runtime error দেয়
  • false ছাপে
  • Type checker program আটকায়

একটি interpreter-এ function call-এর নতুন environment-এর parent হিসেবে function তৈরির environment-এর বদলে caller-এর environment দেওয়া হলো। এতে ভাষা কোন নিয়ম মানতে শুরু করে?

  • Call-by-name
  • Tail call optimization
  • Static (lexical) scoping
  • Dynamic scoping

Haat reference-এর while প্রতিটি ঘোরায় body-র জন্য একটি নতুন Env বানায়। একটিমাত্র Env পুরো loop-এ রাখলে কোন program-এর আচরণ বদলায়?

  • যে loop-এর body-তে let আছে, সেটি redeclaration error দেয়
  • যে loop-এর ভেতরে closure তৈরি হয়ে পরে ডাকা হয়
  • প্রতিটি loop এক ঘোরা কম চলে
  • Loop-এর শর্ত আর বাইরের variable দেখতে পায় না

Haat-এ fn d(n: Int) -> Int { if n == 0 { return 0; } return d(n - 1); } আর print(d(1000)); (দুটি লাইন)। Haat-এর call-এর সীমা ১,০০০। Reference interpreter কী দেয়?

  • 0
  • Python-এর RecursionError traceback
  • 1:54: runtime error: stack overflow
  • Type checker-এর error

শব্দকোষ

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

মনে রাখুন

  1. দুই function, একটি গাছ: eval expression থেকে মান, exec statement থেকে কাজ; দুটিই node-এর ধরন দেখে সন্তানের জন্য নিজেকে ডাকে। এটি big-step semantics-এর কোড-রূপ।
  2. মান ধার, অর্থ নিজের: Python-এর int/bool/str/None আর Function; প্রতিটি হিসাবের পরে wrap, C-র মতো / আর %, ছাপায় আগে bool.
  3. Env-এর শিকল: প্রতিটি block, প্রতিটি loop-ঘোরা আর প্রতিটি call একটি নতুন Env; call-এর Env-এর parent function-এর নিজের Env (static scoping).
  4. return = ReturnSignal: ছোড়ে exec(Return), ধরে শুধু call(); finally-তে গভীরতা কমে।
  5. Runtime error: তিন রকম, অবস্থান node থেকে; ১,০০০ call-এর সীমা Haat নিজে গোনে, host-এর stack নয়; differential test-এর পাশে হাতে লেখা golden উদাহরণ রাখুন।

পরের পর্বে: এই পর্বে environment ছিল dict-এর একটি সরল শিকল। পর্ব ৫৭-এ (Environment আর closure-এর বাস্তবায়ন) দেখবেন তার বিকল্প: resolver-এর দেওয়া slot-সংখ্যা দিয়ে array, দুটি closure-এর একটি variable ভাগ করা, VM-এর cell আর upvalue, আর নাম খোঁজা বনাম slot পড়ার সত্যিকারের গতি।

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

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