Closure — ফাংশন যখন environment সাথে নিয়ে হাঁটে

formal-semantics লেসনের arithmetic evaluator মনে আছে? সেটা substitution-based ছিল। এখন environment-passing-এ পুরোটা লিখি — প্লাস lambda আর closure:

"""mini_lambda.py — environment-passing interpreter with closures"""
import re
from dataclasses import dataclass

# ---------- AST ----------
@dataclass
class Num:   v: int
@dataclass
class Var:   name: str
@dataclass
class Lam:   p: str; body: object
@dataclass
class App:   f: object; a: object
@dataclass
class BinOp: op: str; l: object; r: object

# ---------- Parser (tiny recursive descent) ----------
TOKEN = re.compile(r"\s*(lambda|[a-zA-Z_]\w*|\d+|[()+\-*/.]|\\)")

def tokenize(s):
    out, i = [], 0
    while s[i:]:
        m = TOKEN.match(s, i)
        if not m: raise SyntaxError(f"bad char at {s[i:]!r}")
        out.append(m.group(1)); i = m.end()
    return out

def parse(src):
    toks = tokenize(src); pos = [0]
    def peek(): return toks[pos[0]] if pos[0] < len(toks) else None
    def eat(t=None):
        tok = toks[pos[0]]; pos[0] += 1
        if t and tok != t: raise SyntaxError(f"want {t}, got {tok}")
        return tok
    def expr():
        if peek() in ("lambda", "\\"):
            eat(); p = eat(); eat(".")
            return Lam(p, expr())
        return add_()
    def atom():
        t = peek()
        if t == "(":
            eat(); e = expr(); eat(")")
            return e
        if t.isdigit(): return Num(int(eat()))
        return Var(eat())
    def app():
        f = atom()
        while True:                       # juxtaposition = application
            t = peek()
            if t and t not in ("lambda", "\\") and \
               (t == "(" or t.isdigit() or t[0].isalpha()):
                f = App(f, atom())
            else: break
        return f
    def mul_():
        e = app()
        while peek() in ("*", "/"):
            e = BinOp(eat(), e, app())
        return e
    def add_():
        e = mul_()
        while peek() in ("+", "-"):
            e = BinOp(eat(), e, mul_())
        return e
    ast = expr()
    if pos[0] != len(toks): raise SyntaxError("trailing input")
    return ast

# ---------- Environment ----------
class Env:
    __slots__ = ("names", "parent")
    def __init__(self, names, parent):
        self.names, self.parent = names, parent
    def get(self, k):
        e = self
        while e:
            if k in e.names: return e.names[k]
            e = e.parent
        raise NameError(k)

# ---------- Closure + evaluator ----------
class Closure:
    __slots__ = ("param", "body", "env")          # THE pair!
    def __init__(self, param, body, env):
        self.param, self.body, self.env = param, body, env

def ev(node, env):
    if isinstance(node, Closure): return node     # closures are values too
    if isinstance(node, Num):   return node.v
    if isinstance(node, Var):   return env.get(node.name)
    if isinstance(node, Lam):   return Closure(node.p, node.body, env)
    if isinstance(node, BinOp):
        l, r = ev(node.l, env), ev(node.r, env)
        return {"+" : l + r, "-": l - r, "*": l * r, "/": l // r}[node.op]
    if isinstance(node, App):
        f = ev(node.f, env); a = ev(node.a, env)
        return ev(f.body, Env({f.param: a}, f.env))   # extend, not substitute!
    raise TypeError(node)

# ---------- Tests ----------
run = lambda src: ev(parse(src), None)

assert run("(lambda x. x + 1) 41") == 42
assert run("(lambda x. (lambda y. x + y) 3) 4") == 7      # nested closure
assert run("((lambda a. lambda b. a * b) 6) 7") == 42     # curried application

# ---- THE test: live environment, not snapshot ----
def demo_live_capture():
    env = Env({"x": 10}, None)
    clo = ev(parse("lambda d. x"), env)     # captures env by reference
    env.names["x"] = 99                     # later mutation
    return ev(App(clo, Num(0)), None) == 99 # closure sees NEW value

assert demo_live_capture(), "closure must capture ENVIRONMENT, not snapshot!"
print("all tests passed — closures carry environments")

python3 mini_lambda.py

all tests passed — closures carry environments

সবচেয়ে গুরুত্বপূর্ণ দুই লাইন খেয়াল করুন:

1. isinstance(node, Lam) branch: return Closure(node.p, node.body, env) — lambda evaluate হওয়া মাত্রই current env-এর reference সহ pair তৈরি। এই একটা লাইনই পুরো closure theory।
2. App branch: ev(f.body, Env({f.param: a}, f.env)) — body চলে closure-এর জন্ম-env-কে parent করে। Call-site-এর env না — lexical scoping-এর প্রোগ্রামাতিক সংজ্ঞা ঠিক এই লাইনে।

আর demo_live_capture-test-টাই প্রমাণ: env-এর x mutate করলে closure নতুন value দেখে — snapshot না, live environment (Python-এর cell, C-এর env-pointer — একই সত্যের দুই dialect)।

নিজে বাড়ান:

1. Set(name, val) form যোগ করুন — nearest-frame assignment (Python-এর nonlocal)। তারপর two-counter test: দুই make-call-এর closure-রা কি state share করে? (উত্তর না — কেন, এক লাইনে লিখুন।)
2. Y-combinator দিয়ে anonymous recursion চালান: Y = λf.(λx.f (λy.x x y)) (λx.f (λy.x x y)) — parser কি recursion keyword ছাড়াই factorial চালাতে পারল?
3. Defunctionalize: Closure-কে tagged tuple করে আর apply-কে central dispatch করে একই interpreter লিখুন — first-class function মুছে গেল, first-class data-ই রইল।