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

Desugaring আর lowering — বড় ভাষাকে ছোট core-এ নামানো

Desugaring and Lowering — Translating a Big Language into a Small Core

Taught in Bangla, this lesson separates syntactic sugar, desugaring within one language and lowering to a lower level, and shows the desugaring already inside the Haat reference. In-page Python (Pyodide) passes desugar x += e, for i in a..b and f-strings, exposing the evaluation-order trap, gensym and hygiene. It discusses where to desugar and how that affects error messages, larger lowerings for closures, generators and async, and checks correctness with a proof sketch and differential testing.

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

  • Syntactic sugar, core ভাষা, desugaring আর lowering-এর পার্থক্য, আর Haat reference-এর নিজের desugaring
  • AST-এর ওপর একটি সাধারণ desugaring pass লেখা: x += e, for i in a..b আর f-string
  • Double evaluation, evaluation order আর নাম-সংঘাত (hygiene) — desugaring-এর তিন পরিচিত ফাঁদ
  • কোথায় desugar করবেন (parser-এ, type checking-এর আগে বা পরে, lowering-এর সময়) আর error message-এর ওপর তার প্রভাব
  • Desugaring সঠিক কি না, তা প্রমাণের রূপরেখা আর differential test দিয়ে যাচাই

১ · Syntactic sugar আর core ভাষা

রেস্তোরাঁয় ওয়েটার অর্ডার স্লিপে লেখেন “কম্বো ২”. রান্নাঘরে কেউ “কম্বো” রাঁধেন না: ক্যাশিয়ার স্লিপটি ভেঙে দেন “এক প্লেট খিচুড়ি, একটি ডিম ভাজি, এক কাপ চা”. মেনুতে নতুন কম্বো যোগ করতে রাঁধুনিকে নতুন কিছু শিখতে হয় না; শুধু ভাঙার তালিকা বড় হয়। তবে কোনো কম্বোতে ভুল হলে খদ্দের অভিযোগ করবেন “কম্বো ২”-এর নামে, “ডিম ভাজি”-র নামে নয়। Compiler-এর desugaring ঠিক এই ক্যাশিয়ার।

একটি ভাষার কিছু লেখা নতুন কোনো ক্ষমতা আনে না, শুধু একই কাজ ছোট বা পরিষ্কার করে লেখার সুবিধা দেয়। এদের বলে syntactic sugar. নামটি সাধারণত Peter Landin-কে (১৯৬৪) কৃতিত্ব দেওয়া হয়। ভাষার যে ছোট অংশে বাকি সব লেখা যায়, সেটি core ভাষা। আর sugar-কে core-এ বদলানোর কাজ desugaring. এই পর্বের সব কোড একটি AST পায় আর একটি AST ফেরত দেয়, তাই এটি একটি pass.

কাছের আরেকটি শব্দ lowering. দুটির সীমা ঝাপসা, তবে এই কোর্সে আমরা এভাবে আলাদা করব:

দিকDesugaringLowering
কোথা থেকে কোথায়একই ভাষার বড় রূপ থেকে ছোট রূপে (Haat → core Haat)উঁচু স্তর থেকে নিচু স্তরে (AST → bytecode বা IR)
ফল কি এখনো উৎসের ভাষা?হ্যাঁ, ছেপে আবার চালানো যায়না, নতুন ধারণা আসে (jump, register, cell)
Haat reference-এ উদাহরণelse if → নিচের If; বাদ দেওয়া -> T → Unit&&, ||, if, while → JUMP_IF_FALSE; নামহীন function → MAKE_CLOSURE
সাধারণত কখনparse-এর পরে, resolver-এর আগে বা type checking-এর পরেsemantic analysis-এর পরে, IR বা code তৈরির সময়

কেন এত ঝামেলা? কারণ core ছোট হলে বাকি সব কাজ ছোট হয়। Haat-এর resolver, type checker, interpreter আর VM প্রত্যেকে প্রতিটি statement চেনে। নতুন একটি loop যোগ করলে চারটি জায়গায় চারবার নিয়ম লিখতে হতো, আর চারটির মধ্যে মিল রাখতে হতো। Desugaring-এ একবার লিখলেই হয়: ছোট core-এর জন্য যা প্রমাণিত আর পরীক্ষিত (পর্ব ৩৮-এর soundness, পর্ব ৪০-এর semantics), নতুন লেখার জন্যও তা আপনাআপনি খাটে। Scheme এই ধারণার সবচেয়ে পরিচিত উদাহরণ: তার specification-এ let, cond, and, or-এর মতো অনেক রূপ কয়েকটি মৌলিক রূপের ভাষায় সংজ্ঞায়িত।

রোজকার ভাষায়ও sugar সব জায়গায়। C-তে a[i]-এর সংজ্ঞাই *(a + i); Python-এর decorator @log মানে f = log(f); Java-র enhanced for একটি Iterator-এর loop. তবে সব “sugar” পুরোপুরি sugar নয়: অংশ ৬ আর ভাবনার প্রশ্ন ৪-এ দেখবেন, কিছু লেখা দেখতে এক রকম হলেও অর্থে সামান্য আলাদা, আর ঠিক সেখানেই desugaring ভুল করে।

২ · Haat-এর ভেতরে আগে থেকেই লুকোনো desugaring

Haat spec v1-এ নতুন কিছু যোগ না করেও reference বাস্তবায়ন তিনটি জায়গায় sugar ভাঙে। প্রথমটি parser-এ: else if-এর জন্য আলাদা কোনো node নেই (পর্ব ৪৭-এ Recursive descent parser). else-এর পরে if এলে parser বাইরের If-এর else_ ঘরে আরেকটি If বসায়। ল্যাবে reference-এর সত্যিকারের ast আউটপুট:

$ python -B haat.py ast elseif.haat      # let n = 5; if n > 5 {…} else if n > 0 {…} else {…}
(program
  (let n 5)
  (if (> n 5)
    (block
      (print 1))
    (if (> n 0)
      (block
        (print 2))
      (block
        (print 3)))))

দ্বিতীয়টিও parser-এ: fn f(x: Int) { … }-এ return type না লিখলে AST-এ UNIT বসে, যেন -> Unit লেখা ছিল। তৃতীয়টি একটি lowering, compiler.py-তে। && আর ||-এর জন্য VM-এ কোনো opcode নেই; short-circuit অর্থ রাখতে compiler এদের শর্তসহ jump-এ নামায় (তত্ত্ব পর্ব ২৭-এ, Control flow). let a = false; print(a && a);-এর সত্যিকারের dis:

   2  LOAD_GLOBAL    0     ; a
   3  JUMP_IF_FALSE  6
   4  LOAD_GLOBAL    0     ; a
   5  JUMP           7
   6  CONST          0     ; false
   7  PRINT

বাঁ পাশ false হলে ৩ নম্বর instruction সোজা ৬-এ লাফ দেয়, ডান পাশ (৪) কখনো চলে না। এটি source-স্তরের desugaring দিয়ে করা যেত না। Haat-এ if একটি statement, expression নয়, তাই a && b-কে “if a { b } else { false }” লেখার কোনো উপায় core Haat-এ নেই। Core-এ যা নেই, তা lowering-এর স্তরে নামাতে হয়। এটিই প্রথম নকশা-শিক্ষা: কোন sugar কোথায় ভাঙবে, তা ঠিক করে core ভাষার ক্ষমতা।

৩ · প্রথম বর্ধিত রূপ: x += e আর evaluation order

Haat-এর বর্ধিত রূপ: এই পর্বের তিনটি নতুন লেখা (x += e / x -= e, for i in a..b { … } আর f"…{e}…") Haat spec v1-এর অংশ নয়। Reference এদের চেনে না; পাতার desugarer এদের core Haat-এ নামায়, আর সেই core program reference-এ চালানো হয়।

পাতার Python ব্লকগুলো একটি সহায়ক module, haat_sugar.py, import করে। এতে আছে বর্ধিত Haat-এর lexer আর parser (reference-এর lexer.py আর parser.py-র সংক্ষিপ্ত রূপ, তিনটি নতুন node OpAssign, For, FStr-সহ), আর fmt: reference-এর python haat.py fmt যে canonical source ছাপে, হুবহু সেই লেখা।

সহায়ক module haat_sugar.py দেখুন (ব্লকগুলো এটি import করে)
# haat_sugar.py — সহায়ক অংশ: বর্ধিত Haat-এর lexer, parser আর formatter.
# Reference-এর lexer.py + parser.py + ast_print.py-র pretty-র সংক্ষিপ্ত রূপ (পর্ব ৪৬–৪৯),
# সঙ্গে তিনটি বর্ধিত রূপ: x += e / x -= e, for i in a..b { … } আর f"…{e}…".
import re
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 for in".split()
OPS = dict(zip("+= -= .. == != <= >= && || -> + - * / % < > ! = ( ) { } , ; :".split(),
    "PLUS_EQ MINUS_EQ DOT_DOT 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<FSTRING>f"(?:\\["\\n]|[^"\\\n])*")'
        r'|(?P<IDENT>[A-Za-z_][A-Za-z0-9_]*)|(?P<INT>[0-9]+)|(?P<STRING>"(?:\\["\\n]|[^"\\\n])*")'
        r'|(?P<op>\+=|-=|\.\.|==|!=|<=|>=|&&|\|\||->|[-+*/%<>!=(){},;:])|(?P<bad>.)')

def tokenize(src, line0=0, col0=0):      # line0/col0: offset for the text inside an f"…" hole
    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 + line0}:{col + col0}: 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 + line0, col + col0))
    return toks + [Token("EOF", "", src.count("\n") + 1 + line0, len(src) - src.rfind("\n") + col0)]

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",
         "OpAssign": "op name value", "For": "name lo hi body", "FStr": "parts"}   # শেষ তিনটি: sugar
for _name, _fields in NODES.items():     # reference-এর নাম আর field; line, col সবসময় শেষে
    globals()[_name] = make_dataclass(_name, _fields.split() + ["line", "col"])
Program = make_dataclass("Program", ["stmts"])
TypeName = make_dataclass("TypeName", ["name"], frozen=True, namespace={"__str__": lambda s: s.name})
FnType = make_dataclass("FnType", ["params", "ret"], frozen=True, namespace={
    "__str__": lambda s: "(" + ", ".join(map(str, s.params)) + ") -> " + str(s.ret)})
INT, BOOL, STR, UNIT = (TypeName(n) for n in ("Int", "Bool", "Str", "Unit"))
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}
unesc = lambda s: re.sub(r'\\(.)', lambda m: "\n" if m[1] == "n" else m[1], s)

class Parser:                            # parser.py-র মতো (প্রথম error-এ থামে)
    def __init__(self, tokens): self.toks, self.pos = tokens, 0
    def peek(self, k=0): return self.toks[min(self.pos + k, len(self.toks) - 1)]
    def check(self, kind): return self.peek().kind == kind
    def advance(self):
        t = self.peek(); self.pos += t.kind != "EOF"; return t
    def match(self, kind): return self.advance() if self.check(kind) else None
    def expect(self, kind, msg):
        if self.check(kind): return self.advance()
        p = self.toks[self.pos - 1] if kind == "SEMI" and self.pos else None
        self.fail(msg, (p.line, p.col + len(p.text)) if p else None)
    def fail(self, msg, at=None):
        line, col = at or (self.peek().line, self.peek().col)
        raise SyntaxError(f"{line}:{col}: error: {msg}")
    def program(self): return Program(self.until("EOF"))
    def until(self, end):
        out = []
        while not self.check(end) and not self.check("EOF"): out.append(self.statement())
        return out
    def block(self, msg="expected '{'"):
        lb = self.expect("LBRACE", msg); body = self.until("RBRACE")
        self.expect("RBRACE", "expected '}' at end of block"); return Block(body, lb.line, lb.col)
    def statement(self):
        k = self.peek().kind
        if k in ("LET", "VAR"):
            mut = self.advance().kind == "VAR"; name = self.expect("IDENT", "expected variable name")
            ann = self.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, mut, ann, init, name.line, name.col)
        if k == "FN" and self.peek(1).kind == "IDENT":
            self.advance(); n = self.advance(); return FnDecl(n.text, *self.fn_rest(), n.line, n.col)
        if k == "IF": return self.if_stmt()
        if k == "WHILE":
            kw = self.advance(); c = self.expression(); return While(c, self.block(), kw.line, kw.col)
        if k == "FOR":                   # বর্ধিত রূপ: for NAME in expr .. expr block
            kw = self.advance(); n = self.expect("IDENT", "expected loop variable")
            self.expect("IN", "expected 'in'"); lo = self.expression()
            self.expect("DOT_DOT", "expected '..'"); hi = self.expression()
            return For(n.text, lo, hi, self.block(), kw.line, kw.col)
        if k == "RETURN":
            kw = self.advance(); v = None if self.check("SEMI") else self.expression()
            self.expect("SEMI", "expected ';' after return"); return Return(v, kw.line, kw.col)
        if k == "PRINT":
            kw = self.advance(); self.expect("LPAREN", "expected '('"); v = self.expression()
            self.expect("RPAREN", "expected ')'"); self.expect("SEMI", "expected ';' after print statement")
            return Print(v, kw.line, kw.col)
        if k == "LBRACE": return self.block()
        first = self.peek(); e = self.expression()
        if self.peek().kind in ("EQ", "PLUS_EQ", "MINUS_EQ"):
            if not isinstance(e, Var): self.fail("invalid assignment target")
            op = self.advance().text; v = self.expression()
            self.expect("SEMI", "expected ';' after assignment")
            return Assign(e.name, v, e.line, e.col) if op == "=" else OpAssign(op, e.name, v, e.line, e.col)
        self.expect("SEMI", "expected ';' after expression"); return ExprStmt(e, first.line, first.col)
    def if_stmt(self):
        kw = self.advance(); c = self.expression(); then = self.block(); els = None
        if self.match("ELSE"): els = self.if_stmt() if self.check("IF") else self.block()
        return If(c, then, els, kw.line, kw.col)
    def fn_rest(self):
        self.expect("LPAREN", "expected '('"); ps = []
        while not self.check("RPAREN"):
            p = self.expect("IDENT", "expected parameter name"); self.expect("COLON", "expected ':'")
            ps.append(Param(p.text, self.type_(), p.line, p.col))
            if not self.match("COMMA"): break
        self.expect("RPAREN", "expected ')'")
        return ps, (self.type_() if self.match("ARROW") else UNIT), self.block()
    def type_(self):
        t = self.advance()
        if t.kind == "IDENT" and t.text in ("Int", "Bool", "Str", "Unit"): return TypeName(t.text)
        if t.kind != "LPAREN": self.fail("expected a type", (t.line, t.col))
        ps = [] if self.check("RPAREN") else [self.type_()]
        while self.match("COMMA"): ps.append(self.type_())
        self.expect("RPAREN", "expected ')'"); self.expect("ARROW", "expected '->'")
        return FnType(tuple(ps), self.type_())
    def expression(self, min_bp=0):      # Pratt (পর্ব ৪৮)
        t = self.advance()
        if t.kind == "INT": left = Num(int(t.text), t.line, t.col)
        elif t.kind == "STRING": left = Str(unesc(t.text[1:-1]), t.line, t.col)
        elif t.kind == "FSTRING": left = self.fstring(t)
        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.fn_rest(), t.line, t.col)
        elif t.kind == "LPAREN": left = self.expression(); self.expect("RPAREN", "expected ')'")
        else: self.fail("expected expression", (t.line, t.col))
        last = None
        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 ')'"); 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
            if bp in (30, 40) and last == bp: self.fail("comparison operators cannot be chained")
            self.advance(); left = Binary(t.text, left, self.expression(bp + 1), t.line, t.col); last = bp
    def fstring(self, t):                # f"মোট {total} টাকা" -> FStr(["মোট ", Var total, " টাকা"])
        parts, body = [], t.text[2:-1]
        for m in re.finditer(r'\{([^{}]*)\}|((?:\\.|[^{}\\])+)', body):
            if m[2] is not None: parts.append(unesc(m[2])); continue
            sub = Parser(tokenize(m[1], t.line - 1, t.col + 2 + m.start(1) - 1))
            e = sub.expression(); sub.expect("EOF", "expected '}'"); parts.append(e)
        return FStr(parts, t.line, t.col)

def parse(src): return Parser(tokenize(src)).program()

LEVEL = {"||": 1, "&&": 2, "==": 3, "!=": 3, "<": 4, "<=": 4, ">": 4, ">=": 4,
         "+": 5, "-": 5, "*": 6, "/": 6, "%": 6}
def lvl(e): return LEVEL[e.op] if isinstance(e, Binary) else 7 if isinstance(e, Unary) else 8
def quote(s): return '"' + s.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n") + '"'

def fmt(n, ind=0):                       # reference-এর `haat.py fmt`-এর মতো canonical source
    if isinstance(n, Program): return "".join(fmt(s) for s in n.stmts)
    pad = "    " * ind; c = type(n).__name__
    if c == "Let":
        ann = f": {n.type}" if n.type is not None else ""
        return f"{pad}{'var' if n.mutable else 'let'} {n.name}{ann} = {ex(n.init, ind)};\n"
    if c == "Assign": return f"{pad}{n.name} = {ex(n.value, ind)};\n"
    if c == "OpAssign": return f"{pad}{n.name} {n.op} {ex(n.value, ind)};\n"
    if c == "If": return pad + if_text(n, ind) + "\n"
    if c == "While": return f"{pad}while {ex(n.cond, ind)} {blk(n.body, ind)}\n"
    if c == "For": return f"{pad}for {n.name} in {ex(n.lo, ind)}..{ex(n.hi, ind)} {blk(n.body, ind)}\n"
    if c == "Return": return f"{pad}return{'' if n.value is None else ' ' + ex(n.value, ind)};\n"
    if c == "Print": return f"{pad}print({ex(n.value, ind)});\n"
    if c == "ExprStmt": return f"{pad}{ex(n.expr, ind)};\n"
    if c == "Block": return pad + blk(n, ind) + "\n"
    return f"{pad}fn {n.name}{sig(n)} {blk(n.body, ind)}\n"
def blk(b, ind): return "{}" if not b.stmts else "{\n" + "".join(fmt(s, ind + 1) for s in b.stmts) + "    " * ind + "}"
def if_text(n, ind):
    s = f"if {ex(n.cond, ind)} {blk(n.then, ind)}"
    if n.else_ is None: return s
    return s + " else " + (if_text(n.else_, ind) if isinstance(n.else_, If) else blk(n.else_, ind))
def sig(f): return "(" + ", ".join(f"{p.name}: {p.type}" for p in f.params) + ")" + ("" if f.ret == UNIT else f" -> {f.ret}")
def ex(e, ind=0):
    c = type(e).__name__
    if c == "Num": return str(e.value)
    if c == "Str": return quote(e.value)
    if c == "Bool": return "true" if e.value else "false"
    if c == "Var": return e.name
    if c == "FStr": return 'f"' + "".join(quote(p)[1:-1] if isinstance(p, str) else "{" + ex(p) + "}" for p in e.parts) + '"'
    if c == "Unary": return e.op + par(e.operand, lvl(e.operand) < 7, ind)
    if c == "Binary":
        p = LEVEL[e.op]
        lp = lvl(e.left) < p or (p in (3, 4) and lvl(e.left) == p)
        return f"{par(e.left, lp, ind)} {e.op} {par(e.right, lvl(e.right) <= p, ind)}"
    if c == "Call": return par(e.callee, lvl(e.callee) < 8, ind) + "(" + ", ".join(ex(a, ind) for a in e.args) + ")"
    return f"fn{sig(e)} {blk(e.body, ind)}"
def par(e, p, ind): return f"({ex(e, ind)})" if p else ex(e, ind)

Desugaring pass-এর কাঠামো একটি সাধারণ গাছ-হাঁটা function, walk: এটি প্রথমে সন্তানদের নতুন করে বানায়, তারপর node-টিকে একটি rule-এর হাতে দেয়। প্রতিটি sugar-এর জন্য একটি ছোট rule; যে node তার নয়, rule সেটি অপরিবর্তিত ফেরত দেয়। নিচ থেকে ওপরে হাঁটার ফলে একটি sugar-এর ভেতরে আরেকটি sugar থাকলে (যেমন for-এর body-তে +=) ভেতরেরটি আগেই ভেঙে যায়। এর সংজ্ঞা দুই লাইনের:

নিয়ম ৫৫.১ — compound assignment-এর desugaring

D⟦x += e;⟧ = x = x + D⟦e⟧;    D⟦x -= e;⟧ = x = x - D⟦e⟧;

এখানে D⟦…⟧ মানে “এই লেখার desugaring”. বাকি সব node-এ D শুধু সন্তানদের ওপর চলে। ডান পাশে D⟦e⟧ একটি পুরো গাছ, লেখা নয়; তাই বন্ধনী নিজে থেকেই ঠিক থাকে।

from haat_sugar import *              # বর্ধিত Haat: tokenize, parse, fmt, AST class
from dataclasses import fields, replace, is_dataclass

def walk(n, rule):                    # গাছটি নিচ থেকে ওপরে নতুন করে বানায়
    if isinstance(n, list): return [walk(x, rule) for x in n]
    if not is_dataclass(n) or isinstance(n, (TypeName, FnType)): return n
    kids = {f.name: walk(getattr(n, f.name), rule) for f in fields(n)}
    return rule(replace(n, **kids))   # আগে সন্তান, তারপর এই node

def op_assign(n):                     # x += e  ->  x = x + e  (x আগে পড়া হয়)
    if type(n).__name__ != "OpAssign": return n
    x = Var(n.name, n.line, n.col)
    return Assign(n.name, Binary(n.op[0], x, n.value, n.line, n.col), n.line, n.col)

src = """var total = 0;
var rounds = 0;
while total < 5000 { total += 1250; rounds += 1; }
var stock = 40;
let sold = 7;
stock -= sold - 1;
print(total); print(rounds); print(stock);"""
tree = parse(src)
print(type(tree.stmts[2].body.stmts[0]).__name__, "->", end=" ")
core = walk(tree, op_assign)
print(type(core.stmts[2].body.stmts[0]).__name__)
print(fmt(core), end="")

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

OpAssign -> Assign
var total = 0;
var rounds = 0;
while total < 5000 {
    total = total + 1250;
    rounds = rounds + 1;
}
var stock = 40;
let sold = 7;
stock = stock - (sold - 1);
print(total);
print(rounds);
print(stock);

প্রথম লাইন দেখায়, parser একটি OpAssign বানিয়েছিল, desugaring-এর পরে সেটি সাধারণ Assign. ফলের প্রথম ছয় লাইন bazar.haat-এর loop-এর হুবহু core রূপ। শেষের দিকের stock -= sold - 1; দেখুন: ফল stock = stock - (sold - 1);, বন্ধনীসহ। কারণ desugarer লেখা নয়, গাছ বদলায়, আর fmt গাছ থেকে প্রয়োজনীয় বন্ধনী নিজে বসায়। লেখা কপি করা একটি C macro-র মতো desugarer এখানে stock - sold - 1 লিখত: reference-এ চালালে ঠিকটি ৩৪ ছাপে, ভুলটি ৩২ (অনুশীলন ২)। এই core program reference-এর run আর vm-এ 5000, 4, 34 ছাপে।

এবার একটি সূক্ষ্ম প্রশ্ন। x += f()-এ যদি f নিজেই x বদলায়? x = x + f() লিখলে Haat-এর বাঁ-থেকে-ডানে নিয়মে (decision 12) x আগে পড়া হয়। আরেকটি “সমান দেখতে” desugaring হলো আগে f() একটি temp-এ রাখা: let t = f(); x = x + t;. দুটি কি একই? নিচের stepper-এ বাজারঘরের ডেলিভারি ফি দিয়ে দেখুন (দুটি program-ই reference-এ চালানো)।

1var total = 100;2fn fee() -> Int {3    total = total + 50;4    return 10;5}6total += fee();7print(total);
A: total = total + fee()
total
হাতে রাখা মান
B: let t = fee(); total = total + t
total
t
  1. শুরু. total = 100, দুই সংস্করণেই। fee() ফি হিসেবে 10 ফেরত দেয়, কিন্তু চুপিচুপি total-এ 50 যোগও করে (একটি side effect).
  2. লাইন ৬, প্রথম কাজ. A বাঁ operand total পড়ে হাতে রাখে: 100. B আগে fee() ডাকতে যায়, total এখনো পড়েনি।
  3. fee-এর ভেতরে. দুই সংস্করণেই total হয় 150. কিন্তু A-র হাতে আগের 100 রয়ে গেছে।
  4. fee ফেরে. A-র হাতে এখন 100 আর 10. B-তে t = 10, আর total এখনো পড়া হয়নি।
  5. যোগ আর assignment. A: 100 + 10 = 110; fee-এর +50 হারিয়ে গেল। B: এখন total পড়ে 150, তাই 150 + 10 = 160.
  6. দুটি ভিন্ন ভাষা. Reference-এ সত্যিকারের run: A ছাপে 110, B ছাপে 160. Java, JavaScript আর Python-এ total += fee()-এর নিয়ম A-র মতো: বাঁ পাশের মান আগে পড়ে রাখা হয় (নিচের JS ব্লকে আসল run). Haat-এর বর্ধিত রূপও A বেছে নিল, আর নিয়ম ৫৫.১ ঠিক সেটিই।

শিক্ষাটি বড়: একটি desugaring শুধু “একই কাজ” নয়, একই ক্রমে একই কাজ। পর্ব ২৬-এ (Expression আর evaluation order) দেখেছিলেন compound assignment-এর আরেক ফাঁদ: বাঁ পাশ নিজেই একটি হিসাব হলে, যেমন stock[slot()] += 1, লেখা কপি করলে slot() দুবার চলে। Haat-এ assignment-এর লক্ষ্য শুধু একটি নাম (decision 9), আর একটি নাম পড়ায় কোনো side effect নেই, তাই নিয়ম ৫৫.১ নিরাপদ। Array যোগ হলে (Haat-এর পরের কোনো বর্ধিত রূপে) তা আর থাকবে না। JavaScript-এ দুটি ফাঁদই আসল run-এ দেখুন:

"use strict";                        // JavaScript-এর নিজের += : বাঁ পাশ একবারই
let total = 100;
function fee() { total = total + 50; return 10; }
total += fee();                      // বাঁ পাশ আগে পড়া হয়: 100 + 10
console.log("total += fee() ->", total);

let calls = 0;
const stock = [5, 8, 2];
function slot() { calls++; return calls - 1; }   // প্রতি ডাকে নতুন ঘর: 0, 1, 2 …

stock[slot()] += 1;                  // আসল sugar
console.log("real    :", JSON.stringify(stock), "slot() calls:", calls);

calls = 0; stock.splice(0, 3, 5, 8, 2);
stock[slot()] = stock[slot()] + 1;   // ভুল desugaring: লেখা কপি
console.log("naive   :", JSON.stringify(stock), "slot() calls:", calls);

calls = 0; stock.splice(0, 3, 5, 8, 2);
{ const a = stock, k = slot();       // ঠিক desugaring: temp-এ একবার হিসাব
  a[k] = a[k] + 1; }
console.log("with tmp:", JSON.stringify(stock), "slot() calls:", calls);

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

total += fee() -> 110
real    : [6,8,2] slot() calls: 1
naive   : [9,8,2] slot() calls: 2
with tmp: [6,8,2] slot() calls: 1

প্রথম লাইন stepper-এর A: JavaScript বাঁ পাশের মান আগে পড়ে, তাই 110. তারপর array. আসল stock[slot()] += 1 slot() একবার ডাকে আর ঘর ০-এ 5 থেকে 6 করে। লেখা কপি করা desugaring slot() দুবার ডাকে: বাঁ পাশে ঘর ০, ডান পাশে ঘর ১, তাই ঘর ০-এ বসে 8 + 1 = 9. সঠিক desugaring array আর index একবার হিসাব করে temp-এ রাখে, তারপর দুবার ব্যবহার করে। নিয়মটি মনে রাখুন: একটি sub-expression desugaring-এর ফলে একাধিকবার দেখা দিলে, তাকে আগে একটি নতুন নামে বেঁধে নিন।

৪ · for i in a..b থেকে while — লুকোনো নাম আর gensym

দ্বিতীয় বর্ধিত রূপ একটি গোনা loop: for i in a..b { … }. আগে অর্থটি ঠিক করি, কারণ desugaring সেই অর্থেরই অনুবাদ। (১) a আগে, তারপর b, দুটিই একবার হিসাব হয়। (২) i নেয় a, a+1, …, b−1 (b বাদ, একে বলে half-open range); a ≥ b হলে একবারও না। (৩) i body-র ভেতরে বদলানো যায় না, আর প্রতি round-এ নতুন (একটি per-iteration binding), যাতে loop-এ তৈরি closure সেই round-এর মান ধরে। (৪) body নিজের একটি scope.

নিয়ম ৫৫.২ — for-এর desugaring (i′ আর n′ নতুন নাম)

D⟦for x in a..b { S }⟧ = { var i′ = D⟦a⟧; let n′ = D⟦b⟧; while i′ < n′ { let x = i′; D⟦{ S }⟧ i′ = i′ + 1; } }

প্রতিটি অংশ অর্থের একটি শর্ত পূরণ করে, আর নিচের stepper সেটি ধাপে ধাপে দেখায়। লক্ষ্য করুন i′ আর n′: এরা এমন নাম যা ব্যবহারকারী লেখেননি। এগুলো বানায় একটি gensym (“generate symbol”, LISP-এর পুরোনো নাম): প্রোগ্রামে আগে থেকে থাকা সব নাম দেখে এমন একটি নাম, যা কোথাও নেই।

def names(n, out):                    # প্রোগ্রামে লেখা সব নাম
    if isinstance(n, list): [names(x, out) for x in n]
    elif is_dataclass(n) and not isinstance(n, (TypeName, FnType)):
        if isinstance(getattr(n, "name", None), str): out.add(n.name)
        for f in fields(n): names(getattr(n, f.name), out)
    return out

def make_fresh(prog, check=True):     # gensym: প্রোগ্রামে নেই এমন নতুন নাম
    used, count = names(prog, set()), {}
    def fresh(base):
        while True:
            count[base] = count.get(base, 0) + 1; name = f"__{base}{count[base]}"
            if not check or name not in used: used.add(name); return name
    return fresh

def for_loop(fresh):                  # for x in lo..hi { B }  ->  { var/let/while }
    def rule(n):
        if type(n).__name__ != "For": return n
        L, C = n.line, n.col; i, end = fresh("i"), fresh("end")
        V = lambda name: Var(name, L, C)
        step = Assign(i, Binary("+", V(i), Num(1, L, C), L, C), L, C)
        body = Block([Let(n.name, False, None, V(i), L, C), n.body, step], L, C)
        loop = While(Binary("<", V(i), V(end), L, C), body, L, C)
        return Block([Let(i, True, None, n.lo, L, C), Let(end, False, None, n.hi, L, C), loop], L, C)
    return rule

def desugar(prog, check=True):        # প্রতি node-এ আগে +=, তারপর for
    rule = for_loop(make_fresh(prog, check)); return walk(prog, lambda n: rule(op_assign(n)))

prog = parse("var total = 0;\nfn n() -> Int { print(\"n called\"); return 4; }\n"
             "for i in 1..n() { total += i; }\nprint(total);")
print(fmt(desugar(prog)), end="")
trap = parse("let __end1 = 100;\nfor k in 0..2 { print(__end1); }")
for check in (False, True):
    print(check, "->", fmt(desugar(trap, check)).split("\n")[3].strip())

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

var total = 0;
fn n() -> Int {
    print("n called");
    return 4;
}
{
    var __i1 = 1;
    let __end1 = n();
    while __i1 < __end1 {
        let i = __i1;
        {
            total = total + i;
        }
        __i1 = __i1 + 1;
    }
}
print(total);
False -> let __end1 = 2;
True -> let __end2 = 2;

for একটি Block-এ বদলেছে, তাই __i1 আর __end1 loop শেষ হলেই scope-এর বাইরে। Body-র total += i আগেই total = total + i হয়ে গেছে, কারণ desugar প্রতিটি node-এ আগে op_assign, তারপর for_loop চালায়, আর walk নিচ থেকে ওপরে যায়। এই core program reference-এর run আর vm দুটিতেই ছাপে n called একবার, তারপর 6 (১ + ২ + ৩)। শেষ দুই লাইন hygiene-এর ফাঁদ, নিচে ব্যাখ্যা।

1{2    var __i1 = 1;3    let __end1 = n();4    while __i1 < __end1 {5        let i = __i1;6        {7            total = total + i;8        }9        __i1 = __i1 + 1;10    }11}
Desugarer-এর হাতে
এই ধাপে
প্রোগ্রামের নাম
  1. আগে ভেতরটা. walk নিচ থেকে ওপরে যায়, তাই For node পৌঁছানোর আগেই তার body-র total += i; হয়ে গেছে total = total + i;.
  2. নতুন নাম. প্রোগ্রামে আছে total, n, i. Gensym এদের কোনোটির সঙ্গে না মেলা দুটি নাম দেয়: __i1, __end1. পুরোটা একটি বাইরের { }-এ, যাতে loop-এর পরে এরা আর দেখা না যায়।
  3. সীমা একবার. var __i1 = 1; তারপর let __end1 = n();: প্রথমে a, তারপর b, আর n() এখানে একবারই ডাকা হয়। শর্তে সরাসরি n() লিখলে প্রতি round-এ ডাকা হতো; ল্যাবে সেই সংস্করণ n called চারবার ছেপেছে।
  4. শর্ত. __i1 < __end1: b বাদ। একটি সুবিধাও আছে: শর্ত সত্য হলে __i1 + 1 ≤ __end1, তাই b = সবচেয়ে বড় Int হলেও যোগ কখনো overflow করে না (অনুশীলন ১-এ উল্টোটা দেখবেন)।
  5. Loop variable. let i = __i1;: let বলে body i বদলাতে পারে না, আর Haat-এ while-এর body প্রতি round নতুন scope (decision 14), তাই প্রতি round-এ নতুন i. ল্যাবে loop-এ তৈরি দুটি closure যথাক্রমে 0 আর 1 ছেপেছে।
  6. User-এর body নিজের block-এ. আলাদা { } থাকায় body-তে let i = 10; লিখলে সেটি বৈধ shadowing; block না থাকলে একই scope-এ দ্বিতীয় i হতো, আর error আসত “'i' is already declared”, যা ব্যবহারকারী বুঝতেন না।
  7. এগোনো. লুকোনো counter বাড়ে, তাই body-র কোনো কিছু round-এর সংখ্যা বদলাতে পারে না। Reference-এর সত্যিকারের run: n called, তারপর 6.

Hygiene: লুকোনো নাম যখন ব্যবহারকারীর নাম ধরে ফেলে

ব্লকের শেষ পরীক্ষায় ব্যবহারকারী (অদ্ভুত হলেও বৈধভাবে) একটি variable-এর নাম রেখেছেন __end1, আর loop-এর ভেতরে সেটি ছাপছেন। যে gensym নাম মিলিয়ে দেখে না (False), সে-ও বানায় let __end1 = 2;. সেটি ভেতরের block-এ বাইরেরটিকে ঢেকে দেয়, আর reference-এ সত্যিকারের run ছাপে 2, 2; ঠিক উত্তর 100, 100, যা নাম-মেলানো gensym (True → __end2) দেয়। একে বলে variable capture, আর তা এড়ানোর গুণকে hygiene. C-র macro-তে এই সমস্যা পরিচিত (C কোর্সের পর্ব ২৭); Scheme-এর hygienic macro এর জন্যই তৈরি। Macro-র পুরো গল্প পর্ব ৭৮-এ (Metaprogramming — macro, template আর reflection). একটি compiler, যে লেখা নয় AST নিয়ে কাজ করে, আরও সহজ পথ নিতে পারে: লুকোনো নামে এমন অক্ষর রাখা যা ব্যবহারকারী লিখতেই পারেন না। CPython ঠিক তাই করে (অংশ ৬)। আমরা এখানে লেখা-যোগ্য নাম রেখেছি শুধু এ কারণে যে core program-টি ছেপে reference-এ চালাতে চাই।

C-র for কেন হুবহু while নয়

অনেক বইয়ে প্রায়ই লেখা থাকে, C-তে for (init; cond; step) body মানে init; while (cond) { body; step; }. প্রায় ঠিক, কিন্তু পুরো ঠিক নয়। Body-তে continue থাকলে C-র for পরের round-এর আগে step চালায়; সরল রূপান্তরে continue সোজা শর্তে লাফ দেয়, step বাদ পড়ে, আর loop প্রায়ই আর থামে না। Kernighan আর Ritchie-র বইতেও এই সমতার পাশে continue-এর ব্যতিক্রম উল্লেখ করা আছে। আরেকটি পার্থক্য scope: C99 থেকে for (int i = 0; …)-এর i loop-এর বাইরে দেখা যায় না, তাই রূপান্তরে বাইরে একটি { } লাগে, আমাদের নিয়ম ৫৫.২-এর মতো। Haat-এ break বা continue নেই, তাই আমাদের রূপান্তর সরল থাকতে পেরেছে; যোগ করলে counter বাড়ানোর কাজটি continue-এর পথেও বসাতে হবে।

৫ · f-string আর error message — কোথায় desugar করবেন

তৃতীয় বর্ধিত রূপ string interpolation: f"মোট {total} টাকা". Spec v1-এ f"…" লেখা যেত না (f একটি নাম, তারপর একটি string, যা syntax error), তাই নতুন লেখাটি কোনো পুরোনো program ভাঙে না। Haat-এ Int থেকে Str বানানোর কোনো function নেই, তাই এই রূপে ফাঁকা ঘরে (hole) শুধু Str চলবে। Desugaring: f"a{x}b" → "a" + x + "b".

এখানে একটি ছোট সিদ্ধান্ত বড় ফল দেয়। Decision 11 বলে, +-এর বাঁ operand ঠিক করে ডানটি কী হবে। f"{total} টাকা" সরাসরি total + " টাকা" হলে, আর total Int হলে, reference বলে 2:15: error: type mismatch: expected Int, found Str: আঙুল তোলে " টাকা"-এর দিকে, যেখানে কোনো ভুল নেই। তাই desugarer শুরুতে hole থাকলে একটি ফাঁকা "" বসায়: "" + total + " টাকা"; এবার বার্তা আসে ঠিক total-এ, expected Str, found Int.

origin = {}                           # (line, col) -> কোন sugar থেকে এসেছে

def start(e):                         # expression কোথায় শুরু (ast_nodes.start)
    while type(e).__name__ in ("Binary", "Call"):
        e = e.left if type(e).__name__ == "Binary" else e.callee
    return e.line, e.col

def f_string(n):                      # f"a{x}b"  ->  "a" + x + "b"
    if type(n).__name__ != "FStr": return n
    acc = None if n.parts and isinstance(n.parts[0], str) else Str("", n.line, n.col)
    for p in n.parts:
        if isinstance(p, str): p = Str(p, n.line, n.col)
        else: origin[start(p)] = "f-string hole"   # উৎসের অবস্থান মনে রাখা
        acc = p if acc is None else Binary("+", acc, p, *start(p))
    return acc

src = 'let name = "Rina";\nvar total = 1250;\nprint(f"{name}, মোট {total} টাকা");'
core = walk(parse(src), f_string)
print(fmt(core), end="")
print("holes:", origin)

def explain(msg):                     # checker-এর বার্তা উৎসের ভাষায় ফেরানো
    where, text = msg.split(": error: ")
    if origin.get(tuple(map(int, where.split(":")))) and text.startswith("type mismatch: expected Str"):
        return f"{where}: error: f-string hole must be Str, found {text.split('found ')[1]}"
    return msg
# lab-এ এই core AST (উৎসের অবস্থানসহ) reference-এর checker-এ দিয়ে পাওয়া আসল বার্তা:
real = "3:22: error: type mismatch: expected Str, found Int"
print(explain(real))

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

let name = "Rina";
var total = 1250;
print("" + name + ", মোট " + total + " টাকা");
holes: {(3, 10): 'f-string hole', (3, 22): 'f-string hole'}
3:22: error: f-string hole must be Str, found Int

তৈরি প্রতিটি + node hole-এর উৎসের অবস্থান পেয়েছে, আর origin মনে রেখেছে: 3:10-এ name, 3:22-এ total, দুটিই f-string-এর hole. ল্যাবে এই core AST (লেখায় না ছেপে, সরাসরি গাছ) reference-এর resolver আর type checker-এ দেওয়া হয়েছে; তার আসল বার্তা 3:22: error: type mismatch: expected Str, found Int. explain বার্তাটি উৎসের ভাষায় ফেরায়। শেষ লাইনই ব্যবহারকারী দেখবেন।

একই ভুল তিনটি পথে কেমন দেখায়, stepper-এ দেখুন। প্রতিটি বার্তা ল্যাবে reference চালিয়ে পাওয়া।

1let name = "Rina";2var total = 1250;3print(f"{name}, মোট {total} টাকা");
Compiler-এর ভেতরে
পথ
Checker যা দেখে
  1. পড়া. Lexer পুরো f"…" একটি token হিসেবে নেয় (3:7). Parser hole-গুলোর ভেতরের লেখা আলাদা করে parse করে, আর প্রতিটি node-কে আসল ফাইলের অবস্থান দেয়: name 3:10, total 3:22 (বাংলা অক্ষর একটি করে column, decision 1).
  2. Desugar. FStr হয় +-এর একটি বাঁ-ঝোঁকা শৃঙ্খল, শুরুতে "". এখনো কোনো error নেই: desugarer type জানে না।
  3. পথ A: লেখায় ছেপে আবার compile. নতুন লাইন print("" + name + ", মোট " + total + " টাকা");-এ total column 30-এ। বার্তার ঠিকানা এমন এক ফাইলের, যা ব্যবহারকারী কখনো দেখেননি; তাঁর ফাইলে 3:30 পড়ে টাকা-র মাঝে।
  4. পথ B: গাছ সরাসরি checker-এ, উৎসের অবস্থানসহ. এবার ঠিকানা ঠিক: 3:22, ঠিক total. কিন্তু “expected Str” পড়ে মনে হয় কোথাও একটি + আছে, যা ব্যবহারকারী লেখেননি।
  5. পথ C: B + origin. Desugarer মনে রেখেছে 3:22 একটি f-string hole. বার্তা উৎসের ভাষায়: “f-string hole must be Str”. রাঁধুনির ভুল খদ্দেরের কাছে পৌঁছাল “কম্বো”-র নামে।
  6. ছোট সিদ্ধান্তের দাম. f"{total} টাকা"-কে শুরুতে "" ছাড়া নামালে total + " টাকা", আর reference আঙুল তোলে নির্দোষ " টাকা"-র দিকে (2:15). "" দিয়ে শুরু করলে একই program-এ বার্তা 2:10-এ, ঠিক total-এ।

ছবি ৫৫.১ — Haat compiler-এ কোথায় কোন sugar ভাঙে

প্রতিটি বাক্সে একটি ধাপ বা মাঝের রূপ, আর তার ভেতরে সেই জায়গায় কী নামে।

Where each piece of sugar is removed in the Haat pipeline source (sugar-সহ) lexer + parserparser.py else if → নিচের If -> T বাদ → Unit surface AST desugar passএই পর্ব x += e → x = x + e for → { var; let; while } f"…" → "" + … + … core AST resolver + type checker বিকল্প: আগে চেক, পরে desugar (GHC-র ধরন) loweringcompiler.py &&, ||, if, while → jump fn(…) {…} → MAKE_CLOSURE bytecode → VM
ছবি ৫৫.১ — ওপরে যত আগে sugar ভাঙে, পরের ধাপ তত সরল, কিন্তু তত কম তথ্য পায় ব্যবহারকারী কী লিখেছিলেন। নিচে যত দেরিতে, error message তত ভালো, কিন্তু checker-কে তত বেশি নিয়ম জানতে হয়।

চারটি জায়গার প্রতিটির নিজের দাম আছে:

কোথায়সুবিধাদামবাস্তব উদাহরণ
Parser-এর ভেতরেকোনো আলাদা pass নেইAST-এ মূল রূপ আর থাকে না; formatter আর tool মূল লেখা ফেরত দিতে পারে নাHaat-এর else if
Type checking-এর আগেchecker ছোট থাকেerror core-এর ভাষায়; অবস্থান আর origin না রাখলে বার্তা বিভ্রান্তিকরrustc (AST → HIR-এ for, ?, async নামে)
Type checking-এর পরেerror ব্যবহারকারীর লেখার ভাষায়checker-কে প্রতিটি sugar-এর নিয়ম জানতে হয়GHC (source-এর ওপর type check, তারপর Core-এ)
Lowering-এর সময়নিচের স্তরের ক্ষমতা পাওয়া যায় (jump)source-স্তরে আর দেখা যায় নাHaat-এর &&; CPython-এর for, with

Rust একটি মাঝামাঝি পথ নিয়েছে বলে জানা যায়: rustc-এর source-এ DesugaringKind নামে একটি চিহ্ন (যেমন ForLoop, QuestionMark) তৈরি কোডের অবস্থানের সঙ্গে রাখা হয়, যাতে diagnostic বলতে পারে ভুলটি কোন sugar থেকে এসেছে। আমাদের origin টেবিল এর একটি ছোট রূপ। আরেকটি উদাহরণ নিজে চালিয়ে দেখা: for i in 0..3 { i = 5; }. গাছ-পথে reference বলে 2:5: error: cannot assign to 'i': it is declared with 'let'. অবস্থান ঠিক, কিন্তু ব্যবহারকারী কোথাও let লেখেননি; ভালো বার্তা হতো “cannot assign to loop variable 'i'”. লেখা-পথে একই ভুল আসে 7:13-এ, যে লাইন তাঁর ফাইলে নেই।

৬ · Python নিজে কী করে — AST-এ রাখা, bytecode-এ নামানো

CPython 3.14-এর সত্যিকারের run (ল্যাবে, Python 3.14.4; PSF License). প্রথমে for item in cart: total += item:

>>> ast.dump(...)        # AST-এ for আর += দুটিই নিজের node
For(target=Name(id='item'), iter=Name(id='cart'),
    body=[AugAssign(target=Name(id='total'), op=Add(), value=Name(id='item'))])
>>> dis.dis(...)         # bytecode-এ lowering
  1    LOAD_NAME     0 (cart)
       GET_ITER
  L1:  FOR_ITER      12 (to L2)
       STORE_NAME    1 (item)
  2    LOAD_NAME     2 (total)
       LOAD_NAME     1 (item)
       BINARY_OP     13 (+=)
       STORE_NAME    2 (total)
       JUMP_BACKWARD 14 (to L1)

(সারি ছোট করতে ctx আর শুরু-শেষের কয়েকটি instruction বাদ।) তিনটি জিনিস লক্ষ করুন। (১) CPython for-কে source-স্তরে while-এ নামায় না; AST-এ For থাকে, আর bytecode-এ সেটি GET_ITER, FOR_ITER আর একটি পেছনের jump হয়: lowering. (২) += x = x + y হয় না, নিজের BINARY_OP 13 (+=) পায়। কারণ Python-এ এটি সত্যিই আলাদা: list-এ += পুরোনো object-টিই বদলায় (__iadd__)। ল্যাবের run: a = [1]; b = a; a += [2]-এর পরে b হয় [1, 2] (a is b → True), কিন্তু a = a + [2]-এর পরে b থাকে [1] (False). নিয়ম ৫৫.১ Python-এর জন্য ভুল হতো। (৩) with open_ledger() as f:-এর bytecode-এ দেখা যায় LOAD_SPECIAL (__exit__), LOAD_SPECIAL (__enter__), WITH_EXCEPT_START আর একটি exception table: try/finally-র মতো একটি কাঠামো, যা compiler নিজে বানায়।

লুকোনো নামও আছে। sum(q * 2 for q in qty)-এর generator expression একটি আলাদা code object, যার local নাম ল্যাবে ('.0', 'q'): .0 হলো iterator-এর parameter, আর Python-এ কোনো নাম বিন্দু দিয়ে শুরু হতে পারে না, তাই ব্যবহারকারীর কোনো নামের সঙ্গে সংঘাত অসম্ভব। একেবারে hygienic gensym. শেষে assert stock >= 0, 'negative': সাধারণ compile-এ এটি একটি তুলনা, শর্তসহ jump আর RAISE_VARARGS; optimize=1 (python -O-এর সমান) দিলে ল্যাবে instruction-এর তালিকা শুধু ['RESUME', 'LOAD_CONST', 'RETURN_VALUE']: পুরো assert-ই উধাও। Python-এর execution model-এর বাকিটা Python কোর্সের পর্ব ০৫-এ।

৭ · বড় lowering — closure, generator আর async

কিছু রূপান্তর এত বড় যে তাদের আর “sugar” বলা যায় না, তবু ধারণাটি একই: একটি জটিল গঠনকে সরল অংশে নামানো, অর্থ না বদলে।

  • Closure. Haat-এর fn(x: Int) -> Int { return x + n; } reference-এর compiler.py-তে একটি আলাদা Code object আর একটি MAKE_CLOSURE হয়, আর ধরা variable n থাকে একটি cell-এ। Native code-এর compiler এক ধাপ এগিয়ে closure conversion করে: function একটি অতিরিক্ত parameter (পরিবেশের record) পায়, আর বাইরের নাম পড়া হয় সেই record থেকে। ধারণাটি পর্ব ১৭-এ (Closure), বাস্তবায়ন পর্ব ৫৭-এ।
  • Generator আর async. yield বা await-ওয়ালা function-কে অনেক compiler একটি state machine-এ নামায়: local variable হয় একটি object-এর field, আর প্রতিটি থামার জায়গা একটি অবস্থা-নম্বর। পর্ব ৩১-এ (Generator, coroutine আর async/await) এটি হাতে করে দেখেছেন। JavaScript-এর পুরোনো সংস্করণের জন্য transpiler যে async কোড তৈরি করে, সেটি এই lowering-এরই ফল।
  • Java-র enhanced for (Java 5). Java Language Specification for (T x : list)-এর অর্থ লিখেছে একটি Iterator-ওয়ালা সাধারণ for দিয়ে: specification নিজেই একটি desugaring.

এই সব ক্ষেত্রে একই তিন প্রশ্ন করতে হয়, যা এই পর্বে দেখলেন: কোন sub-expression কতবার আর কোন ক্রমে চলে, লুকোনো নাম কি ব্যবহারকারীর নামের সঙ্গে মিশতে পারে, আর ভুল হলে বার্তা কার ভাষায় আসে।

৮ · Desugaring সঠিক কি না — প্রমাণ আর differential test

Desugaring সঠিক মানে semantic preservation: প্রতিটি বর্ধিত program P-র জন্য D⟦P⟧ বাইরে থেকে একই আচরণ দেখায় (একই আউটপুট, একই runtime error, একই থামা বা না-থামা)। D নিজে structural induction-এর মতো গঠন মেনে সংজ্ঞায়িত, তাই প্রমাণও সেভাবে চলে।

প্রমাণের রূপরেখা (নিয়ম ৫৫.১):

  1. বর্ধিত ভাষার big-step নিয়ম (পর্ব ৪০-এর ধরনে): পরিবেশ σ-তে x += e চালাতে প্রথমে v₁ = σ(x), তারপর ⟨e, σ⟩ ⇓ ⟨v₂, σ′⟩ (e-র side effect σ-কে σ′ বানাতে পারে), শেষে σ′[x ↦ v₁ + v₂]. ফল σ′[x ↦ v₁ + v₂].
  2. Core-এ x = x + e: Haat-এ বাঁ operand আগে (decision 12), তাই ⟨x, σ⟩ ⇓ ⟨σ(x), σ⟩ = v₁ (নাম পড়ায় σ বদলায় না), তারপর ⟨e, σ⟩ ⇓ ⟨v₂, σ′⟩, যোগে v₁ + v₂ (একই 64-বিট wrap), assignment-এ σ′[x ↦ v₁ + v₂].
  3. Induction-এর অনুমান: e-র ভেতরের প্রতিটি ছোট অংশে D অর্থ রাখে, তাই D⟦e⟧-ও ⟨v₂, σ′⟩ দেয়। দুই পাশের ফল একই। ∎

প্রমাণটি কোথায় ভাঙত, সেটাই আসল শিক্ষা: ধাপ ২-এ আমরা ধরেছি “নাম পড়ায় σ বদলায় না”. লক্ষ্য a[f()] হলে কথাটি মিথ্যা, আর তখন temp লাগে। আর নিয়ম ৫৫.২-এর প্রমাণে দুটি তথ্য দরকার হয়: i′ আর n′ নতুন (gensym), আর i′ + 1 কখনো overflow করে না (শর্ত i′ < n′ থেকে)।

প্রমাণের পাশাপাশি differential testing. ল্যাবে একটি আলাদা, ছোট interpreter লেখা হয়েছে যা বর্ধিত AST সরাসরি চালায় (কোনো desugaring ছাড়া)। তারপর একটি seed দেওয়া generator এলোমেলো program বানিয়েছে: +=, -=, nested for, f-string, if, আর একটি bump function যা global variable বদলায় (evaluation order পরীক্ষার জন্য)। প্রতিটি program desugar করে, ছেপে, reference-এর run আর vm-এ চালানো হয়েছে:

$ python -B fuzz.py 400        # seed 55; oracle = আলাদা interpreter
programs 400: run match 400/400, vm match 400/400
programs with a user name like __i1: 99; naive gensym wrong on 17 (5 never stopped)
sugar uses: {'+=': 975, '-=': 532, 'for': 562, 'f"': 231}

প্রথম লাইন: ৪০০টির সবকটিতে তিন বাস্তবায়নের আউটপুট হুবহু এক। দ্বিতীয় লাইন hygiene-এর দাম দেখায়: ৯৯টি program-এ ব্যবহারকারী __i1 বা __end1 ধরনের নাম রেখেছিলেন; একই program নাম না-মেলানো gensym দিয়ে নামালে ১৭টির আউটপুট ভুল হয়েছে, আর তার ৫টি কখনো থামেনি (১০ সেকেন্ড পরে বন্ধ করা হয়েছে)। কারণ body-র __i1 -= … তখন ব্যবহারকারীর variable নয়, লুকোনো counter বদলায়। বাকি ৮২টিতে ভুল ধরা পড়েনি শুধু এ কারণে যে সেখানে সেই নাম loop-এর ভেতরে ব্যবহৃত হয়নি। এলোমেলো test শুধু সেই ভুল খোঁজে যা তার generator তৈরি করতে পারে; তাই অংশ ৪-এর মতো সীমার উদাহরণ হাতেও লিখে রাখতে হয় (ধারণাটি Software Testing কোর্সের পর্ব ৬০-এ)।

আরও গভীরে: Hygienic macro expansion-এর আনুষ্ঠানিক সমাধান সাধারণত Kohlbecker, Friedman, Felleisen আর Duba-র ১৯৮৬ সালের কাজকে কৃতিত্ব দেওয়া হয়; Scheme-এর syntax-rules এই ধারার ফল। Desugaring-এর পরেও error message সুন্দর রাখার একটি গবেষণা-ধারা “resugaring” নামে পরিচিত (Pombrio আর Krishnamurthi, ২০১৪ সালের দিকে): core-এর evaluation-এর প্রতিটি ধাপকে আবার উৎসের রূপে ফিরিয়ে দেখানো। আর GHC-র Core একটি ছোট typed lambda calculus (System F-এর একটি বর্ধিত রূপ): পুরো Haskell সেটিতে নামে, আর optimizer শুধু সেই ছোট ভাষাটি চেনে।

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

  • Syntactic sugar কী? দুটি উদাহরণ দিন। নতুন ক্ষমতা ছাড়া সুবিধার লেখা: x += e, for loop, else if, C-র a[i] = *(a + i).
  • C-র for(init; cond; step) body-কে while-এ লিখুন। কোথায় পার্থক্য? init; while (cond) { body; step; }; কিন্তু body-তে continue থাকলে step বাদ পড়ে যায়, তাই সরল রূপান্তর তখন ভুল।
  • x += e আর x = x + e কি সবসময় এক? না: বাঁ পাশে side effect থাকলে (a[f()]) দুবার চলে; Python-এ list-এ += object বদলায়; Java-তে +=-এ একটি অন্তর্নিহিত cast থাকে।
  • Desugaring-এ hygiene কেন দরকার? তৈরি লুকোনো নাম ব্যবহারকারীর নাম ঢেকে দিতে পারে; gensym বা লেখা-অযোগ্য নাম দিয়ে আটকানো হয়।
  • Short-circuit && কীভাবে code-এ নামে? বাঁ পাশ, JUMP_IF_FALSE শেষে-false-এ, ডান পাশ, JUMP শেষে; ডান পাশ শুধু দরকার হলে চলে।

৯ · AI-এর যুগে desugaring

“এই নতুন syntax-কে আমার ভাষার core-এ নামিয়ে দাও” AI assistant-কে দিলে উত্তর প্রায়ই প্রথম দেখায় ঠিক লাগে, কারণ সাধারণ উদাহরণে ফল মেলে। ভুল লুকিয়ে থাকে সীমার জায়গায়। বারবার দেখা ভুল:

AI-এর ভুলকীভাবে ধরবেন
Sub-expression কপি করা (n() শর্তে, a[f()] দুপাশে), ফলে দুবার চলাside effect-ওয়ালা function (ছাপে বা গোনে) দিয়ে test; ডাকের সংখ্যা মেলানো
Temp-এ আগে রেখে evaluation order বদলে ফেলা (১১০ বনাম ১৬০)ভাষার specification-এর ক্রম পড়া; ডান পাশ বাঁ পাশ বদলায় এমন test
লুকোনো নাম স্থির রাখা (__end), hygiene ভুলে যাওয়াব্যবহারকারীর program-এ ঠিক সেই নাম রেখে চালানো
লেখা জুড়ে desugar করা, ফলে বন্ধনী হারানোx -= y - 1-এর মতো ইনপুট; AST-এ কাজ করা
এক ভাষার নিয়ম সব ভাষায় চাপানো (“+= সবসময় x = x + e”)প্রতিটি ভাষার আসল interpreter বা compiler-এ চালানো (Python list, Java cast)
Overflow, ফাঁকা range বা continue-এর মতো সীমা ভুলে যাওয়াসবচেয়ে বড় Int, a ≥ b, ফাঁকা body দিয়ে test

AI-কে কাজে লাগানোর ভালো উপায়: অর্থটি নিজে লিখে দিন (কী কতবার, কোন ক্রমে), core ভাষার সীমা জানিয়ে দিন, আর ফলের সঙ্গে test চান যা আপনি নিজে চালাতে পারবেন।

আমি Haat নামের একটি ছোট ভাষার compiler-এ for i in a..b { … } loop যোগ করছি, desugaring দিয়ে (Python 3, AST-এর ওপর)। অর্থ: a আগে, তারপর b, দুটিই একবার হিসাব হবে; i নেবে a থেকে b-1; i body-তে বদলানো যাবে না আর প্রতি round-এ নতুন; body নিজের scope. Core ভাষায় আছে শুধু let, var, assignment, while, if, block; break বা continue নেই। ১. Desugaring নিয়মটি আগে লিখে বলো, প্রতিটি অংশ অর্থের কোন শর্ত পূরণ করে। ২. লুকোনো নাম বানাবে gensym দিয়ে, যা প্রোগ্রামের কোনো নামের সঙ্গে মিলবে না। ৩. তৈরি প্রতিটি node-এ উৎসের line:col বসাবে। ৪. এরপর ৮টি test দাও প্রত্যাশিত আউটপুটসহ: b-তে side effect, a ≥ b, b = সবচেয়ে বড় Int, body-তে i বদলানোর চেষ্টা, loop-এ closure, আর ব্যবহারকারীর নাম __end1. ৫. কোনো জায়গায় নিশ্চিত না হলে “নিশ্চিত নই” লেখো, অনুমান করবে না।

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

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

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

প্র ০১একটি ছোট core আর তার ওপর অনেক sugar — এই নকশা কোথা থেকে এল, আর এর লুকোনো দাম কী?

Peter Landin ১৯৬০-এর দশকের মাঝামাঝি দেখিয়েছিলেন, ALGOL-এর মতো একটি ভাষার বড় অংশ lambda calculus-এর ওপর সামান্য কিছু যোগ করে ব্যাখ্যা করা যায়; “syntactic sugar” শব্দটিও সাধারণত তাঁর ১৯৬৪ সালের লেখাকে কৃতিত্ব দেওয়া হয়। এরপর Scheme এই দর্শনকে ভাষার নকশার কেন্দ্রে আনে: ভাষার report-এ কয়েকটি মৌলিক রূপ, আর let, cond, and, or, do-এর মতো “derived” রূপ সেগুলো দিয়ে সংজ্ঞায়িত। যেমন (let ((x e)) body) মানে ((lambda (x) body) e).

সুবিধা তিন জায়গায়। Semantics: পর্ব ৪০–৪১-এর মতো আনুষ্ঠানিক সংজ্ঞা শুধু core-এর জন্য লিখলেই হয়। প্রমাণ: type soundness (পর্ব ৩৮) core-এ একবার প্রমাণ করলে, desugaring অর্থ রাখলে পুরো ভাষায় খাটে। বাস্তবায়ন: interpreter, VM, optimizer, static analyzer প্রত্যেকে ছোট একটি ভাষা চেনে, আর নতুন feature আনতে শুধু একটি নতুন rule লাগে।

দাম লুকোনো, কিন্তু আসল। প্রথম, error message: এই পর্বেই দেখলেন let-এর নামে loop variable-এর বার্তা, বা এমন ফাইলের column যা ব্যবহারকারী দেখেননি। দ্বিতীয়, debugging: debugger যদি core কোড ধরে চলে, তাহলে step করার সময় ব্যবহারকারী লুকোনো __i1 দেখেন। তৃতীয়, performance: সাধারণ desugaring সবসময় সবচেয়ে ভালো কোড দেয় না; যেমন Python নিজের for-এর জন্য আলাদা FOR_ITER opcode রেখেছে, while আর next() ডাকে নামায়নি। চতুর্থ, “প্রায়-sugar”: যে লেখা দেখতে sugar কিন্তু আসলে নয় (Python-এ list-এর +=), সেটি ভুলভাবে desugar করলে অর্থই বদলে যায়।

মূল উপলব্ধি: ছোট core ভাষাকে বোঝা, প্রমাণ আর বাস্তবায়ন সহজ করে, কিন্তু ব্যবহারকারী core দেখেন না, দেখেন sugar. তাই desugaring-এর সঙ্গে অবস্থান, উৎসের চিহ্ন আর বার্তার যত্নও নকশার অংশ।

প্র ০২GHC type checking-এর পরে desugar করে, rustc অনেকটা আগে। দুটি নকশার পেছনের যুক্তি কী, আর Haat কোনটি নেবে?

GHC-র pipeline মোটামুটি এরকম: parse, rename (নাম মেলানো), type check, তারপর desugar করে Core নামের একটি ছোট typed ভাষায়, তারপর optimization. Type checker তাই পুরো Haskell-এর source রূপ দেখে: do-block, list comprehension, record syntax. সুবিধা, error message ব্যবহারকারীর লেখার ভাষায়: “In a stmt of a 'do' block …” ধরনের বার্তা দেওয়া যায়, কারণ checker জানে এটি একটি do. দাম, checker বিশাল: প্রতিটি sugar-এর typing নিয়ম তাকে আলাদা করে জানতে হয়। Haskell-এর type system জটিল বলে এই দামকে GHC-র ডেভেলপাররা যুক্তিসংগত মনে করেছেন: বিভ্রান্তিকর type error একজন Haskell প্রোগ্রামারের সবচেয়ে বড় কষ্টের একটি।

rustc ভিন্ন পথে চলে: AST থেকে HIR-এ নামানোর সময়ই for loop একটি loop আর iterator-এর next-এর match হয়ে যায়, ? operator একটি match হয়; type checking চলে HIR-এর ওপর। এতে checker ছোট, কিন্তু error message-এ desugaring-এর ছাপ পড়ার ঝুঁকি থাকে। তাই rustc তৈরি কোডের অবস্থানের সঙ্গে একটি চিহ্ন (DesugaringKind) রাখে, আর diagnostic সেটি দেখে বার্তা ঠিক করে। কার্যত এটি আমাদের পথ C-র বড় রূপ।

Haat-এর জন্য এই পর্বের অভিজ্ঞতা কী বলে? আমাদের sugar ছোট আর type-নিয়ম সরল, তাই পথ C যথেষ্ট: desugar আগে, কিন্তু উৎসের অবস্থান আর origin রেখে। for-এর variable-এর বার্তাটি (declared with 'let') সারাতে Let node-এ একটি ছোট চিহ্ন (“এটি loop variable”) যোগ করা যায়, আর resolver সেটি দেখে বার্তা বদলাবে। Haat-এ যদি কখনো জটিল type-ওয়ালা feature আসে (যেমন pattern matching, পর্ব ২৪), তখন GHC-র পথ ভাবার মতো হবে।

মূল উপলব্ধি: desugaring কোথায় হবে, তা একটি ভারসাম্যের সিদ্ধান্ত: checker-এর আকার বনাম বার্তার মান। মাঝামাঝি সমাধান সাধারণত আগে desugar করা, কিন্তু তৈরি কোডে উৎসের পুরো চিহ্ন রেখে দেওয়া।

প্র ০৩Hygiene-এর সমস্যা C macro, LISP আর Scheme কীভাবে সামলেছে, আর একটি compiler-এর ভেতরের desugarer-এর জন্য এটি কেন অনেক সহজ?

C-র preprocessor লেখা বদলায়, নাম বা scope কিছুই চেনে না। একটি SWAP(a, b) macro যদি ভেতরে tmp নামের variable বানায়, আর ব্যবহারকারী SWAP(tmp, x) লেখেন, তাহলে macro-র tmp ব্যবহারকারীর tmp-কে ঢেকে দেয়, ফল নীরবে ভুল। এটি অংশ ৪-এর __end1-এর ঠিক একই রোগ। C-তে এর কোনো ভাষাগত সমাধান নেই; প্রোগ্রামাররা অদ্ভুত নাম বেছে (_swap_tmp_) ঝুঁকি কমান। বন্ধনীর সমস্যাও একই উৎস থেকে: macro-র প্রতিটি parameter বন্ধনীতে না রাখলে precedence ভাঙে, অনুশীলন ২-এর মতো।

LISP-এর macro লেখা নয়, list-রূপের কোড নিয়ে কাজ করে, তাই বন্ধনীর সমস্যা নেই। কিন্তু নাম-সংঘাত থেকে যায়, আর তার পুরোনো সমাধান gensym: একটি নতুন symbol যা আগে কখনো তৈরি হয়নি। এতে macro-র নিজের নাম নিরাপদ, কিন্তু উল্টো দিকের সমস্যা (macro যে নাম ব্যবহার করে, যেমন list, ব্যবহারকারী সেটি local-এ নতুন করে বাঁধলে) থেকে যায়। Scheme-এর hygienic macro (১৯৮০-এর দশকের মাঝামাঝি থেকে, পরে syntax-rules) দুই দিকই সামলায়: প্রতিটি নাম তার লেখার জায়গার scope মনে রাখে। Rust-এর macro_rules!-এ local variable-এর জন্য hygiene আছে বলে জানা যায়, যদিও সব ধরনের নামে নয়।

Compiler-এর ভেতরের desugarer-এর কাজ অনেক সহজ, কারণ সে নিজেই নাম বানায় আর পুরো program দেখে। হয় সব নাম মিলিয়ে নতুন নাম নেয় (আমাদের make_fresh), নয়তো এমন নাম নেয় যা lexer কখনো তৈরি করবে না (CPython-এর .0), নয়তো নাম ছাড়াই সরাসরি resolver-এর binding object দিয়ে node জোড়ে। শেষ পথটি সবচেয়ে শক্ত, কারণ তখন নামের লেখা আদৌ গুরুত্বহীন।

মূল উপলব্ধি: hygiene-এর সমস্যা আসে যখন একটি রূপান্তর “লেখা” নিয়ে কাজ করে কিন্তু “অর্থ” (কোন নাম কোন ঘোষণার) হারায়। AST আর binding নিয়ে কাজ করলে সমস্যার বড় অংশ নিজেই মিলিয়ে যায়।

প্র ০৪কোন “sugar” আসলে sugar নয়? Java, Python আর JavaScript থেকে উদাহরণ দিয়ে বলুন, desugaring-এর আগে কী যাচাই করতে হয়।

Java: Java Language Specification E1 op= E2-এর অর্থ লিখেছে মোটামুটি E1 = (T)((E1) op (E2)), যেখানে T হলো E1-এর type আর E1 একবারই হিসাব হয়। ওই অন্তর্নিহিত cast-ই পার্থক্য: byte b = 10; b += 5; compile হয়, কিন্তু b = b + 5; হয় না, কারণ b + 5 একটি int, আর int থেকে byte-এ নামতে স্পষ্ট cast লাগে। অর্থাৎ += লেখা-কপির sugar নয়, একটি cast-সহ রূপান্তর।

Python: এই পর্বের ল্যাবে আসল run দেখাল, list-এ a += [2] একই object বদলায় (a is b সত্য থাকে), আর a = a + [2] নতুন object বানায়। কারণ += প্রথমে __iadd__ খোঁজে, না পেলে __add__. এর একটি বিখ্যাত পরিণতি: tuple-এর ভেতরের list-এ t[0] += [1] list-টি বদলে ফেলে, তারপর tuple-এ assignment-এর সময় TypeError ছোড়ে; কাজ আংশিক হয়ে যায়। JavaScript: ES2015-এর class-কে প্রায়ই prototype-এর sugar বলা হয়, কিন্তু পুরোপুরি নয়: class constructor new ছাড়া ডাকলে error হয়, class-এর ভেতর স্বয়ংক্রিয়ভাবে strict mode, আর method-গুলো enumerable নয়। পুরোনো ব্রাউজারের জন্য transpiler এসব আচরণ অনুকরণ করতে বাড়তি সহায়ক কোড যোগ করে।

তাই desugaring লেখার আগে তিনটি প্রশ্ন: (১) specification কি এটিকে অন্য লেখার ভাষায় সংজ্ঞায়িত করে, নাকি নিজের আলাদা নিয়ম দেয়? (২) কোন অংশ কতবার আর কোন ক্রমে চলে? (৩) type, object-এর পরিচয় (identity) আর exception-এর আচরণ কি হুবহু এক? প্রতিটি উত্তর সেই ভাষার আসল interpreter বা compiler-এ চালিয়ে মেলাতে হয়, অন্য ভাষার অভিজ্ঞতা থেকে অনুমান করে নয়।

মূল উপলব্ধি: “sugar” শব্দটি একটি দাবি, প্রমাণ নয়। প্রতিটি ভাষার নিয়ম আলাদা, আর একটি desugaring সঠিক তখনই, যখন সেই ভাষার specification আর আসল run দুটিই একমত।

প্র ০৫Desugar করা বা transpile করা কোড debug করার সময় ব্যবহারকারী কী দেখবেন? Source map আর CPython-এর পদ্ধতি কীভাবে এর উত্তর দেয়?

একটি desugarer বা transpiler যা তৈরি করে, debugger সেটিই চালায়। অবস্থানের তথ্য না থাকলে breakpoint বসবে ভুল লাইনে, stack trace দেখাবে এমন ফাইলের লাইন যা কেউ লেখেননি, আর step করার সময় দেখা যাবে লুকোনো variable. Web-এর জগতে এই সমস্যা বড় আকারে দেখা দিয়েছিল: TypeScript, পুরোনো ব্রাউজারের জন্য রূপান্তর আর minifier মিলে ব্রাউজার যে JavaScript চালায় তা মূল কোড থেকে অনেক দূরে। সমাধান source map: একটি আলাদা ফাইল, যেখানে তৈরি কোডের প্রতিটি অবস্থানের পাশে মূল ফাইলের line আর column লেখা। ব্রাউজারের developer tool সেটি পড়ে মূল কোডই দেখায়। আমাদের origin টেবিল আর “তৈরি node-এ উৎসের অবস্থান বসানো” ঠিক এরই ছোট রূপ।

CPython অন্য পথ নিয়েছে: সে source-স্তরে প্রায় কিছুই desugar করে না। এই পর্বের ল্যাবে দেখলেন, AST-এ For, AugAssign, With নিজের node হিসেবে থাকে, আর রূপান্তর হয় bytecode তৈরির সময়, যেখানে প্রতিটি instruction-এর সঙ্গে তার উৎসের লাইন (আর নতুন সংস্করণে column-ও) রাখা হয়। dis-এর আউটপুটে বাঁয়ের লাইন নম্বরগুলো সেটিই। তাই traceback সবসময় ব্যবহারকারীর লেখা লাইন দেখায়, এমনকি with-এর পেছনে compiler-এর বানানো exception table-এর ভেতর থেকে error এলেও।

Haat-এর জন্য শিক্ষা সোজা। পর্ব ৫৬-এর tree-walking interpreter আর পর্ব ৫৯-এর VM runtime error-এর সময় node বা instruction-এর অবস্থান ছাপে (division by zero দেখায় /-এর ঘরে)। Desugar করা কোডে যদি অবস্থান ঠিক থাকে, runtime error-ও ব্যবহারকারীর ফাইলেই আঙুল তুলবে। Reference-এর Code object-এ প্রতিটি instruction-এর positions তালিকা ঠিক এই উদ্দেশ্যেই রাখা।

মূল উপলব্ধি: রূপান্তর যত দূরেই যাক, উৎসের ঠিকানা সঙ্গে নিয়ে যেতে হয়। অবস্থানহীন desugaring compile-এর ভুল আর runtime-এর ভুল দুটিকেই ব্যবহারকারীর কাছে দুর্বোধ্য করে।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — closed range a..=b: Haat-এর বর্ধিত রূপে for i in a..=b যোগ করুন (b-ও অন্তর্ভুক্ত)। একজন লিখলেন “<-এর জায়গায় <=”. b = 9223372036854775807 (সবচেয়ে বড় Int) হলে কী হয়? break ছাড়া core Haat-এ সঠিক desugaring লিখুন।

    while i′ <= n′ { …; i′ = i′ + 1; }-এ শেষ round-এ i′ = INT_MAX, যোগে wrap হয়ে i′ সবচেয়ে ছোট Int (decision 13), যা আবার <= n′, তাই loop কখনো থামে না। ল্যাবে একটি পাহারাদার counter রেখে (৪ round পরে থামানো) সত্যিকারের run:

    9223372036854775806
    9223372036854775807
    -9223372036854775808
    -9223372036854775807

    সমাধান: যোগের আগে শেষ মান কি না দেখা, আর একটি লুকোনো Bool দিয়ে থামা:

    {
        var __i1 = a;  let __end1 = b;
        var __go1 = __i1 <= __end1;          // ফাঁকা range-এ একবারও না
        while __go1 {
            let i = __i1;
            { …body… }
            if __i1 == __end1 { __go1 = false; } else { __i1 = __i1 + 1; }
        }
    }

    Reference-এর run (run আর vm একই): 9223372036854775806..=9223372036854775807-এ দুটি সংখ্যা তারপর done; 1..=3-এ 1 2 3; 3..=2-এ শুধু done. Rust-এর standard library-র inclusive range-এও ঠিক এই কারণে একটি বাড়তি “শেষ হয়েছে” চিহ্ন রাখা হয় বলে জানা যায়।

  2. ভুল খুঁজুন — লেখা-কপির desugarer: একজন x -= e;-কে একটি string replace দিয়ে নামালেন: f"{x} = {x} - {e};", যেখানে e হলো ব্যবহারকারীর লেখা হুবহু। var stock = 40; let sold = 7; stock -= sold - 1; print(stock);-এ কী ছাপবে, আর ভুলটি কোথায়?

    তৈরি লেখা stock = stock - sold - 1;. - বাঁ-সংযোগী, তাই এর মানে (stock - sold) - 1 = ৩২, অথচ অর্থ ছিল stock - (sold - 1) = ৩৪. Reference-এর সত্যিকারের run: ভুল সংস্করণ 32, AST-ভিত্তিক desugarer-এর ফল (stock = stock - (sold - 1);) 34.

    ভুলের মূল: desugarer গাছ নয়, লেখা নিয়ে কাজ করেছে, তাই e-র ভেতরের গঠন (সে একটি পুরো sub-expression) হারিয়েছে। সমাধান দুটি: AST-এ কাজ করা (নিয়ম ৫৫.১), বা লেখায় করলে e-কে সবসময় বন্ধনীতে মোড়ানো, C macro-র পুরোনো নিয়মের মতো। Random test এটি ধরতে পারত যদি generator ডান পাশে - বা +-ওয়ালা expression বানায়; নিয়ম ৫৫.১-এর যুক্তিও এটি সরাসরি দেখায়: D⟦e⟧ একটি node, লেখা নয়।

  3. আউটপুট বলুন: নিচের বর্ধিত Haat program কী ছাপবে? twice কতবার ডাকা হবে?
    fn twice() -> Int {
        print("twice");
        return 2;
    }
    var s = 0;
    var log = "";
    for i in 1..twice() + 2 {
        s += i * 10;
        log += f"[{log}]";
    }
    print(s);
    print(log);

    Range-এর শেষ twice() + 2 = ৪, একবারই হিসাব (let __end1 = twice() + 2;), তাই twice একবার। i = ১, ২, ৩, ফলে s = ১০ + ২০ + ৩০ = ৬০. log += f"[{log}]" নামে log = log + ("[" + log + "]");: ডান পাশের পুরো f-string একটি node, তাই বন্ধনীসহ। প্রতি round-এ ডান পাশ পুরোনো log পড়ে: "" → [] → [][[]] → [][[]][[][[]]]. Reference-এর সত্যিকারের run (run আর vm একই):

    twice
    60
    [][[]][[][[]]]
  4. প্রমাণ — নিয়ম ৫৫.২ ফাঁকা range-এ আর গোনায় সঠিক: দেখান যে for x in a..b { S }-এর desugaring, যেখানে a আর b-এর মান যথাক্রমে l আর h, body ঠিক max(0, h − l) বার চালায়, প্রতিবার x = l, l+1, … নিয়ে, আর কোনো যোগ overflow করে না। ধরে নিন body লুকোনো নামগুলো ছুঁতে পারে না।

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

    1. লুকোনো নাম নিরাপদ: i′ আর n′ gensym থেকে, তাই প্রোগ্রামের কোনো নামের সঙ্গে মেলে না; body এদের পড়তে বা বদলাতে পারে না (hygiene). n′ let, তাই সারাক্ষণ h.
    2. Loop invariant: k-তম বার শর্ত দেখার সময় (k = ০, ১, …) i′ = l + k, আর k ≥ ১ হলে body ঠিক k বার চলেছে, x = l, …, l + k − 1 নিয়ে। শুরুতে k = ০, i′ = l: সত্য। একটি round-এ let x = i′ x-কে l + k দেয়, body চলে (i′ ছোঁয় না), তারপর i′ = l + k + 1.
    3. Overflow নেই: round চলে শুধু i′ < h হলে, তাই i′ + 1 ≤ h ≤ INT_MAX; যোগ কখনো wrap করে না।
    4. থামা আর গোনা: l ≥ h হলে প্রথম শর্তই মিথ্যা, শূন্য round. নইলে i′ প্রতি round-এ ১ বাড়ে আর h-এ পৌঁছায় ঠিক k = h − l-এ, তখন শর্ত মিথ্যা। মোট round = max(0, h − l). ∎

    সংখ্যায় মেলান: for i in 9223372036854775805..9223372036854775807-এ (h − l = ২) reference ছাপে 9223372036854775805, 9223372036854775806 আর গণনা 2, কোনো wrap ছাড়া। ধাপ ৩ ভাঙলে কী হয়, অনুশীলন ১-এ দেখেছেন।

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

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

ক্রমHaat-এর বর্ধিত রূপে for i in a..b { S }-এর desugared core program চলার সময় যে কাজগুলো ঘটে, সেগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. লুকোনো counter-এ a-র মান রাখা
  2. b একবার হিসাব করে লুকোনো let-এ রাখা
  3. শর্ত দেখা: counter < শেষ মান
  4. let i-কে counter-এর মান দেওয়া
  5. ব্যবহারকারীর body চালানো, নিজের block-এ
  6. Counter এক বাড়ানো, তারপর আবার শর্তে ফেরা

Desugaring আর lowering-এর পার্থক্য কোনটি সবচেয়ে ভালো বর্ণনা করে?

  • Desugaring compile time-এ, lowering run time-এ হয়
  • Desugaring ফল দেয় একই ভাষার ছোট রূপে, lowering নিচের স্তরের রূপে
  • Desugaring অর্থ বদলাতে পারে, lowering পারে না
  • শুধু native compiler lowering করে, interpreter করে না

Haat-এর বর্ধিত রূপে var total = 100;, তারপর fn fee() -> Int { total = total + 50; return 10; }, তারপর total += fee(); print(total);. নিয়ম x += e → x = x + e আর বাঁ-থেকে-ডানে evaluation ধরে কী ছাপা হবে?

  • 160
  • 150
  • 110
  • একটি type error

একটি desugarer for i in 0..n() { … }-কে var i = 0; while i < n() { …; i = i + 1; }-এ নামায়। n() 4 ফেরত দেয় আর প্রতি ডাকে একটি লাইন ছাপে। কী ঘটবে?

  • n() পাঁচবার ডাকা হবে, যদিও অর্থ অনুযায়ী একবার হওয়ার কথা
  • n() একবারই ডাকা হবে, কারণ শর্তটি স্থির
  • Loop কখনো থামবে না
  • একটি syntax error হবে

একটি desugarer প্রতিটি for-এর জন্য স্থির নাম __end ব্যবহার করে। ব্যবহারকারী লিখলেন let __end = 100; for k in 0..2 { print(__end); }. কী ছাপবে, আর সমস্যাটির নাম কী?

  • 100, 100 — কোনো সমস্যা নেই
  • Redeclaration error
  • 0, 1 — loop variable ছাপা হয়
  • 2, 2 — hygiene-এর অভাব (variable capture)

Haat-এর বর্ধিত রূপে var total = 1250; তারপর print(f"{total} টাকা");. Desugarer যদি এটিকে total + " টাকা"-এ নামায় (শুরুতে "" ছাড়া), আর Haat-এ +-এর বাঁ operand ঠিক করে ডানটি কী হবে, তাহলে type error কোথায় দেখাবে?

  • total-এর ঘরে, expected Str, found Int
  • " টাকা"-র ঘরে, expected Int, found Str
  • print-এর ঘরে, cannot print
  • কোনো error নেই, 1250 টাকা ছাপবে

Python 3.14-এ a = [1]; b = a; a += [2]-এর পরে b কী, আর এ থেকে x += e → x = x + e desugaring সম্পর্কে কী শিখি?

  • [1]; দুটি লেখা Python-এ একই
  • TypeError; list-এ += চলে না
  • [1, 2]; Python-এ এই desugaring অর্থ বদলাত
  • [1, 2, 2]; += দুবার যোগ করে

Haat reference বাস্তবায়নে a && b কীভাবে চালানো হয়?

  • Bytecode compiler এটিকে শর্তসহ jump-এ নামায় (lowering)
  • Parser এটিকে if a { b } else { false } expression-এ বদলায়
  • VM-এর একটি আলাদা AND opcode আছে
  • দুপাশ হিসাব করে তারপর মেলানো হয়

শব্দকোষ

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

মনে রাখুন

  1. ছোট core, বড় সুবিধা: sugar একবার core-এ নামালে resolver, checker, interpreter আর VM বদলাতে হয় না; desugaring একই ভাষায়, lowering নিচের স্তরে।
  2. গাছে কাজ করুন: AST-ভিত্তিক desugaring বন্ধনী আর গঠন আপনাআপনি রাখে; লেখা-কপি করলে precedence ভাঙে।
  3. সংখ্যা আর ক্রম: প্রতিটি sub-expression যতবার আর যে ক্রমে চলার কথা, ঠিক ততবার আর সেই ক্রমে; দরকারে আগে temp-এ বাঁধুন।
  4. Hygiene: লুকোনো নাম gensym বা লেখা-অযোগ্য নাম দিয়ে, যাতে ব্যবহারকারীর নাম কখনো ঢাকা না পড়ে।
  5. বার্তা উৎসের ভাষায়: তৈরি node-এ উৎসের অবস্থান আর origin রাখুন; আর প্রতিটি desugaring reference-এ চালিয়ে differential test দিয়ে যাচাই করুন।

পরের পর্বে: মডিউল ৯ এখানে শেষ: Haat-এর program এখন parse, resolve, type check আর desugar হয়ে একটি পরিষ্কার core AST. পর্ব ৫৬-এ (Tree-walking interpreter — Haat চালানো) সেই গাছ সরাসরি চালাবেন: প্রতিটি node-এর জন্য একটি eval, environment, function call আর runtime error-এর অবস্থান।

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

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