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

Metaprogramming — macro, template আর reflection

Metaprogramming — Macros, Templates and Reflection

Taught in Bangla, this lesson shows programs that write programs. It runs real C preprocessor output to expose textual macro traps, contrasts tree-based macros in LISP and Rust, builds a small macro expander for Haat, and explains both sides of hygiene with marks, renaming and gensym. It covers expansion order and depth limits, C++ templates and constexpr evaluated at compile time, and run-time reflection, annotations and decorators in Java, Python and JavaScript, with steppers for each expansion trap.

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

  • Metaprogramming-এর স্তর: লেখা, token, গাছ, type-মান আর চলমান program; কোনটি compile time-এ, কোনটি run time-এ
  • C preprocessor-এর তিন ফাঁদ (precedence, double evaluation, নাম-সংঘাত) আর argument prescan
  • LISP-এর quasi-quotation, Rust-এর macro_rules! আর proc macro
  • Haat-এর বর্ধিত রূপে একটি hygienic macro expander লেখা: mark, gensym, rename আর reference-এ যাচাই
  • Expansion-এর ক্রম, থামার নিয়ম, C++ template/constexpr আর run time reflection-এর সঙ্গে তুলনা

১ · Metaprogramming — যে program অন্য program লেখে

বিয়ের দাওয়াতপত্রের ছাপাখানার কথা ভাবুন। কারিগর প্রতিটি কার্ড আলাদা করে লেখেন না; একটি ছাঁচ বানান, যেখানে “বরের নাম”, “তারিখ” আর “স্থান”-এর ফাঁকা ঘর আছে। প্রতিটি অর্ডারে ঘরগুলো ভরে নতুন কার্ড বেরিয়ে আসে। ছাঁচটি নিজে কোনো দাওয়াত নয়, দাওয়াত বানানোর যন্ত্র। আর ভুলও আসে ছাঁচ থেকে: ফাঁকা ঘরে লম্বা নাম বসালে পাশের লেখা ঢাকা পড়ে, আর ছাঁচে ছাপা “আমাদের বাড়ি” কার বাড়ি বোঝায়, তা নির্ভর করে কার্ডটি কে পাঠাচ্ছেন তার ওপর।

সাধারণ program ডেটা নিয়ে কাজ করে: অর্ডারের দাম, ডেলিভারির ঠিকানা। Metaprogramming-এ কাজের বস্তু কোড নিজেই: একটি program কোড তৈরি করে, বদলায় বা পড়ে। এই কোর্সে আপনি আসলে শুরু থেকেই metaprogramming করছেন: Haat-এর lexer, parser, desugarer আর compiler সবাই এমন program, যার ইনপুট আরেকটি program (পর্ব ৫৫-এ Desugaring আর lowering). এই পর্বের প্রশ্ন ভিন্ন: ভাষা যখন ব্যবহারকারীর হাতেই এই ক্ষমতা দেয়, তখন কী কী সম্ভব, আর কোথায় বিপদ।

দুটি প্রশ্নে সব ধরনকে সাজানো যায়। প্রথম, কখন: compile time-এ (program চলার আগে), নাকি run time-এ (চলার সময়)। দ্বিতীয়, কোডের কোন রূপে: কাঁচা লেখা, token, গাছ, type, নাকি চলমান object. নিচের ছবিতে ওপর থেকে নিচে যত নামবেন, কোডের রূপ তত “অর্থপূর্ণ”, আর metaprogram তত বেশি জানে সে কী বদলাচ্ছে।

ছবি ৭৮.১ — Metaprogramming-এর পাঁচ স্তর

প্রতিটি বাক্সে কোডের একটি রূপ, আর সেই রূপের ওপর কাজ করে এমন পরিচিত উদাহরণ।

Five levels of metaprogramming, from source text to the running program compile time run time ১ · লেখা (text) C preprocessor: #define ২ · token Rust: macro_rules!, proc macro ৩ · গাছ (AST) এই পর্ব LISP, Scheme, Haat-এর macro ৪ · type আর মান C++: template, constexpr ৫ · চলমান program reflection, decorator, eval
ছবি ৭৮.১ — দাগের ওপরের চার স্তর program চলার আগেই শেষ; নিচের স্তর চলার সময় কাজ করে। ওপরের দিকে metaprogram সবচেয়ে কম জানে (শুধু অক্ষর), নিচের দিকে সবচেয়ে বেশি (আসল object আর মান), কিন্তু তখন compiler-এর সাহায্য আর পাওয়া যায় না।

দুই প্রান্তের দুটি উদাহরণ। ওপরে C-র macro: preprocessor compile-এর আগে অক্ষর বদলায়, C ভাষার কিছুই বোঝে না। নিচে reflection: চলমান Java বা Python program একটি object-এর class আর method নাম ধরে খুঁজে ডাকে; এর ভিত্তি পর্ব ১২-এ (Scripting আর dynamic ভাষা) দেখেছেন, সেখানে eval-এর বিপদও। মাঝখানের স্তরগুলো এই পর্বের মূল বিষয়, কারণ compiler-লেখকের কাজ সেখানেই: macro expander একটি compiler pass, আর তার ভুল সরাসরি ব্যবহারকারীর program-এর অর্থ বদলায়।

২ · লেখা বদলানোর macro — C preprocessor-এর তিন ফাঁদ

C-র preprocessor-এর ব্যবহার C কোর্সের পর্ব ২৭-এ শিখেছেন; এখানে শুধু প্রশ্নটি compiler-লেখকের চোখে: লেখা বদলালে কী হারায়? উত্তর তিনটি। গঠন (কোন অংশ একটি পুরো expression), হিসাবের সংখ্যা (একটি argument কতবার চলে), আর নামের অর্থ (কোন i কার)। তিনটিই নিচের একটি ছোট program-এ। প্রথমে zig 0.17.1-এর সঙ্গে আসা Clang 22.1.8-এ -E দিয়ে preprocessor-এর সত্যিকারের ফল (শুধু main):

$ zig cc -E -P macros.c        # preprocessor-এর ফল, শেষের অংশ
int main(void) {
    printf("100 / SQUARE(2+3)  = %d\n", 100 / 2+3*2+3);
    printf("100 / SQUARE2(2+3) = %d\n", 100 / ((2+3)*(2+3)));
    int stock = 5, order = 3;
    int m = ((stock++) > (order) ? (stock++) : (order));
    printf("MAX(stock++, order) = %d, stock = %d\n", m, stock);
    int i = 100;
    for (int i = 0; i < (3); i++) { printf("i = %d\n", i); };
    return 0;
}

প্রতিটি ফাঁদ এই লেখাতেই দেখা যাচ্ছে। এবার একই program নিজে চালিয়ে দেখুন:

#include <stdio.h>
#define SQUARE(x)  x*x                        /* বন্ধনী ছাড়া */
#define SQUARE2(x) ((x)*(x))                  /* বন্ধনীসহ */
#define MAX(a, b)  ((a) > (b) ? (a) : (b))
#define REPEAT(n, stmt) for (int i = 0; i < (n); i++) { stmt; }

int main(void) {
    printf("100 / SQUARE(2+3)  = %d\n", 100 / SQUARE(2+3));
    printf("100 / SQUARE2(2+3) = %d\n", 100 / SQUARE2(2+3));
    int stock = 5, order = 3;
    int m = MAX(stock++, order);              /* stock++ লেখা দুবার বসে */
    printf("MAX(stock++, order) = %d, stock = %d\n", m, stock);
    int i = 100;                              /* বাজারঘরের নিজের i */
    REPEAT(3, printf("i = %d\n", i));
    return 0;
}

আসল আউটপুট (Wandbox-এর GCC, warning চালু):

prog.c:13:9: warning: unused variable 'i' [-Wunused-variable]
100 / SQUARE(2+3)  = 59
100 / SQUARE2(2+3) = 4
MAX(stock++, order) = 6, stock = 7
i = 0
i = 1
i = 2

প্রথম লাইন: function-like macro argument-কে একটি মান বা গাছ হিসেবে নয়, তিনটি token 2 + 3 হিসেবে বসায়, তাই গুণ আর ভাগ আগে হয়ে ৫৯ আসে (নিচের stepper). বন্ধনীসহ সংস্করণ ঠিক ৪ দেয়। তৃতীয় লাইন double evaluation: stock++ লেখাটি দুবার বসেছে, শর্তে একবার আর ফলে একবার, তাই stock ৫ থেকে ৭ হয়েছে আর ফল ৬, ৫ নয়। শেষ তিন লাইন নাম-সংঘাত: macro-র নিজের int i বাজারঘরের i = 100-কে ঢেকে দিয়েছে, তাই ছাপা হয়েছে loop counter. সবচেয়ে মজার সূত্রটি compiler নিজেই দিয়েছে: সে বলছে বাইরের i “unused”, অর্থাৎ ব্যবহারকারী যাকে ছাপতে চেয়েছিলেন, সে কোথাও ব্যবহৃত হয়নি। এই তৃতীয় সমস্যার নাম name capture.

1#define SQUARE(x)  x*x2#define SQUARE2(x) ((x)*(x))3int a = 100 / SQUARE(2+3);4int b = 100 / SQUARE2(2+3);
এই ধাপে
লেখা
গাছ বা মান
  1. Argument সংগ্রহ. Preprocessor SQUARE( দেখে বন্ধনীর ভেতরের token-গুলো তোলে: 2, +, 3. এটি কোনো মান নয়, কোনো গাছও নয়, শুধু তিনটি টুকরো।
  2. বসানো. সংজ্ঞার x*x-এ প্রতিটি x-এর জায়গায় ওই তিনটি token. ফল 2+3*2+3, আর লাইনটি হয় 100 / 2+3*2+3: ঠিক এটিই -E-এর সত্যিকারের আউটপুটে আছে।
  3. এবার compiler parse করে. Parser নতুন লেখাটি precedence মেনে পড়ে: / আর * আগে, তাই গাছ হয় (100/2) + (3*2) + 3. Macro-র লেখক যে গঠন ভেবেছিলেন, তা preprocessor-এর ধাপেই হারিয়ে গেছে।
  4. হিসাব. ৫০ + ৬ + ৩ = ৫৯. Run-এ ঠিক এই সংখ্যাই এসেছে। কোনো error বা warning নেই: ভুলটি নীরব।
  5. পুরোনো প্রতিকার. প্রতিটি parameter আর পুরো body বন্ধনীতে: ((2+3)*(2+3)), তাই ১০০ / ২৫ = ৪. প্রতিকার কাজ করে, কিন্তু প্রতিটি macro-লেখককে নিয়মটি মনে রাখতে হয়।
  6. গাছের macro. Haat-এর বর্ধিত রূপের square! (অংশ ৪) argument পায় একটি গাছ হিসেবে, তাই কেউ বন্ধনী না লিখলেও formatter নিজে বসায় আর reference ছাপে ৪. Precedence-এর ফাঁদ শেষ; কিন্তু অংশ ৬-এ দেখবেন, double evaluation গাছের macro-তেও থাকে।

দুটি নিয়ম preprocessor-কে আরও অদ্ভুত করে। প্রথম, argument prescan: C standard অনুযায়ী argument বসানোর আগেই তার ভেতরের macro খোলা হয়, যদি না সেটি # (লেখাকে string বানানো) বা ## (দুটি token জোড়া)-এর পাশে থাকে। দ্বিতীয়, একটি macro নিজের expansion-এর ভেতরে আবার খোলে না। একই Clang-এর সত্যিকারের -E:

#define SQUARE(x) ((x)*(x))
#define STR(x)  #x
#define XSTR(x) STR(x)
#define grow(x) grow(x + 1)
const char *a = STR(SQUARE(2));     →  const char *a = "SQUARE(2)";
const char *b = XSTR(SQUARE(2));    →  const char *b = "((2)*(2))";
int c = grow(0);                    →  int c = grow(0 + 1);

STR-এ argument #-এর পাশে, তাই খোলা হয়নি; XSTR-এ আগে খুলে তারপর STR-এ গেছে। আর grow একবার খুলে থেমেছে: ফলের ভেতরের grow-কে preprocessor আর ছোঁয় না, তাই অসীম expansion অসম্ভব। অংশ ৬-এ দেখবেন, গাছের macro-তে এই সহজ নিয়ম খাটে না, কারণ সেখানে নিজেকে ডাকা (recursive) macro একটি দরকারি কৌশল।

৩ · গাছ বদলানোর macro — LISP, quasi-quotation আর Rust

LISP-এ কোড আর ডেটা একই রূপে লেখা: (+ 2 (* 3 4)) একটি list, আবার একটি program. এই গুণের নাম homoiconicity, আর এর ফলে LISP-এর macro শুরু থেকেই গাছ নিয়ে কাজ করেছে, লেখা নিয়ে নয়। LISP-এ macro যোগের কৃতিত্ব সাধারণত Timothy Hart-এর ১৯৬৩ সালের একটি memo-কে দেওয়া হয়। একটি LISP macro একটি সাধারণ function, যা compile-এর সময় চলে: argument পায় S-expression, ফেরত দেয় নতুন S-expression. Common Lisp-ধাঁচে একটি swap (উদাহরণ, চালানো হয়নি):

(defmacro my-swap (a b)              ; a আর b: কোডের টুকরো, মান নয়
  (let ((tmp (gensym)))              ; নতুন, কখনো-না-দেখা নাম
    `(let ((,tmp ,a))                ; ` = ছাঁচ, , = এখানে ফাঁকা ঘর ভরো
       (setf ,a ,b)
       (setf ,b ,tmp))))

ব্যাকটিক (`) আর কমা (,) মিলে quasi-quotation: ছাঁচটি হুবহু কোড, শুধু কমা-দেওয়া জায়গাগুলো ভরা হয়। এটি ঠিক দাওয়াতপত্রের ছাঁচ, আর নামটি দার্শনিক W. V. O. Quine-এর একটি যুক্তিবিদ্যার ধারণা থেকে নেওয়া বলে জানা যায়। লক্ষ করুন (gensym): macro-র নিজের temp-এর জন্য একটি নতুন নাম, যাতে ব্যবহারকারীর tmp ধরা না পড়ে। এটি পর্ব ৫৫-এর সেই gensym, তবে এখানে দায়িত্ব macro-লেখকের: ভুলে গেলে C-র মতো একই ভুল। Scheme এক ধাপ এগিয়ে গেছে: তার syntax-rules-এ লেখা (let ((tmp a)) …) নিজে থেকেই নিরাপদ, কারণ expander প্রতিটি নামের উৎস মনে রাখে। এই গুণের নাম hygiene; অংশ ৫-এ এর ভেতরের যন্ত্রটি নিজে বানাবেন।

Rust-এ দুই ধরনের macro. macro_rules! হলো pattern দিয়ে লেখা নিয়ম: $x:expr মানে “এখানে একটি পুরো expression”. Parser argument-কে আগে একটি expression হিসেবে চেনে, তাই C-র precedence-এর ফাঁদ নেই। Wandbox-এ Rust 1.82.0-এ সত্যিকারের run:

macro_rules! square { ($x:expr) => { $x * $x }; }
macro_rules! sum {
    () => { 0 };                                       // থামার নিয়ম
    ($x:expr $(, $rest:expr)*) => { $x + sum!($($rest),*) };
}
println!("{}", 100 / square!(2 + 3));                  // → 4
println!("{}", sum!(1, 2, 3, 4));                      // → 10

sum! নিজেকে ডাকে, আর $(…)* মানে “এই অংশ শূন্য বা বেশিবার”: একটি ছোট syntactic macro ভাষা, যা চারটি সংখ্যাকে 1 + (2 + (3 + (4 + 0)))-এ খোলে। দ্বিতীয় ধরন procedural macro: একটি আলাদা crate-এ লেখা Rust function, যা compiler-এর ভেতরে চলে, একটি token-এর স্রোত নেয় আর আরেকটি ফেরত দেয়। #[derive(Debug)] এর সবচেয়ে পরিচিত উদাহরণ: struct-এর গঠন পড়ে ছাপার কোড তৈরি করে। Proc macro যেকোনো Rust কোড চালাতে পারে (ফাইল পড়া পর্যন্ত), তাই এটি শক্তিশালী আর ঝুঁকিপূর্ণ দুটোই। Expansion দেখার পরিচিত tool cargo expand একটি তৃতীয়-পক্ষের tool, Wandbox-এ নেই; তাই এখানে কোনো proc macro-র expansion দেখানো হয়নি।

৪ · Haat-এ macro — একটি ছোট expander

Haat-এর বর্ধিত রূপ: macro keyword আর name!(…) লেখা Haat spec v1-এর অংশ নয়। Reference এগুলো চেনে না। পাতার expander এদের খুলে সাধারণ Haat বানায়, আর সেই program reference-এর python -B haat.py run আর vm-এ চালানো হয়েছে।

নকশা ছোট রাখি। Macro শুধু top level-এ সংজ্ঞায়িত হয়, দুই রূপে। Expression macro: macro square!(x) => x * x;. Statement macro: macro repeat!(n, body) { … }, যার ব্যবহার একটি block-এ খোলে। Argument হয় একটি expression, নয়তো { … } block. name!-এর ! চিহ্নটি Rust থেকে নেওয়া, আর spec v1-এ f!(x) কখনো বৈধ ছিল না, তাই কোনো পুরোনো program ভাঙে না। Lexer নামের ঠিক পরে !( দেখলে একটি MCALL token দেয়, parser একটি MacroCall node বানায়। পাতার Python ব্লকগুলো এই সহায়ক module import করে:

সহায়ক module haat_macro.py দেখুন (ব্লকগুলো এটি import করে)
# haat_macro.py — সহায়ক অংশ: macro-সহ বর্ধিত Haat-এর lexer, parser, expander আর formatter.
# Lexer/parser/formatter reference-এর lexer.py, parser.py আর ast_print.py-র সংক্ষিপ্ত রূপ (পর্ব ৪৬–৪৯).
# নতুন: macro name!(p, …) => expr;   macro name!(p, …) { … }   আর ব্যবহার name!(arg, …)
import re
from copy import deepcopy
from dataclasses import dataclass, make_dataclass, fields, replace, is_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 macro".split()
OPS = dict(zip("=> == != <= >= && || -> + - * / % < > ! = ( ) { } , ; :".split(),
    "FAT_ARROW 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<MCALL>[A-Za-z_][A-Za-z0-9_]*!(?=\())'
        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):
    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.rstrip("!"), 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",
         "MacroDef": "name params body", "MacroCall": "name args"}      # শেষ দুটি: বর্ধিত রূপ
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 == "MACRO":                 # বর্ধিত রূপ: macro-র সংজ্ঞা, শুধু top level-এ
            self.advance(); n = self.expect("MCALL", "expected macro name like m!(")
            self.expect("LPAREN", "expected '('"); ps = []
            while not self.check("RPAREN"):
                ps.append(self.expect("IDENT", "expected parameter name").text)
                if not self.match("COMMA"): break
            self.expect("RPAREN", "expected ')'")
            if self.match("FAT_ARROW"):
                body = self.expression(); self.expect("SEMI", "expected ';' after macro")
            else: body = self.block()
            return MacroDef(n.text, ps, body, n.line, n.col)
        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 == "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.match("EQ"):
            if not isinstance(e, Var): self.fail("invalid assignment target")
            v = self.expression(); self.expect("SEMI", "expected ';' after assignment")
            return Assign(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 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 == "MCALL":          # বর্ধিত রূপ: m!(expr বা { block }, …)
            self.expect("LPAREN", "expected '('"); args = []
            while not self.check("RPAREN"):
                args.append(self.block() if self.check("LBRACE") else self.expression())
                if not self.match("COMMA"): break
            self.expect("RPAREN", "expected ')'"); left = MacroCall(t.text, args, 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 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 == "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 == "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"
    if c == "MacroDef":
        head = f"{pad}macro {n.name}!({', '.join(n.params)})"
        return head + (f" {blk(n.body, ind)}\n" if isinstance(n.body, Block) else f" => {ex(n.body)};\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 == "Block": return blk(e, ind)
    if c == "MacroCall": return e.name + "!(" + ", ".join(ex(a, ind) for a in e.args) + ")"
    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)

# ---------------- macro expander: বাইরে থেকে ভেতরে, প্রতিটি expansion-এ নতুন mark ----------------
NAMED = ("Var", "Assign", "Let", "Param", "FnDecl")   # যেসব node-এ নাম থাকে

def subst(n, env, mark):
    """Template-এর একটি কপি: parameter-এর জায়গায় argument-এর গাছ, বাকি নামে #mark."""
    if isinstance(n, list): return [subst(x, env, mark) for x in n]
    c = type(n).__name__
    if c == "Var" and n.name in env: return deepcopy(env[n.name])
    if c == "ExprStmt" and type(n.expr).__name__ == "Var" and type(env.get(n.expr.name)).__name__ == "Block":
        return deepcopy(env[n.expr.name])                 # body; -> argument-এর block
    if not is_dataclass(n) or isinstance(n, (TypeName, FnType)): return n
    kids = {f.name: subst(getattr(n, f.name), env, mark) for f in fields(n)}
    if c == "Assign" and n.name in env: kids["name"] = env[n.name].name
    elif c in NAMED: kids["name"] = f"{n.name}#{mark}"
    return replace(n, **kids)

class Expander:
    def __init__(self, prog, limit=40):
        self.macros = {s.name: s for s in prog.stmts if type(s).__name__ == "MacroDef"}
        self.mark, self.limit, self.log = 0, limit, []
    def run(self, prog):
        return Program([self.walk(s, 0) for s in prog.stmts if type(s).__name__ != "MacroDef"])
    def walk(self, n, depth):
        if isinstance(n, list): return [self.walk(x, depth) for x in n]
        if type(n).__name__ == "ExprStmt" and type(n.expr).__name__ == "MacroCall":
            out = self.expand(n.expr, depth)               # statement macro -> একটি Block
            return out if type(out).__name__ == "Block" else ExprStmt(out, n.line, n.col)
        if type(n).__name__ == "MacroCall": return self.expand(n, depth)
        if not is_dataclass(n) or isinstance(n, (TypeName, FnType)): return n
        return replace(n, **{f.name: self.walk(getattr(n, f.name), depth) for f in fields(n)})
    def expand(self, call, depth):
        at = f"{call.line}:{call.col}: error:"
        m = self.macros.get(call.name)
        if m is None: raise SyntaxError(f"{at} unknown macro '{call.name}!'")
        if len(m.params) != len(call.args):
            raise SyntaxError(f"{at} macro '{call.name}!' expects {len(m.params)} arguments")
        if depth >= self.limit: raise RecursionError(f"{at} macro expansion too deep ('{call.name}!')")
        self.mark += 1
        out = subst(m.body, dict(zip(m.params, call.args)), self.mark)
        self.log.append((depth, f"{call.name}!#{self.mark}", out))
        return self.walk(out, depth + 1)                   # ফলের ভেতরের macro: পরে (outside-in)

def all_names(n, out):
    if isinstance(n, list): [all_names(x, out) for x in n]
    elif is_dataclass(n) and not isinstance(n, (TypeName, FnType)):
        if type(n).__name__ in NAMED: out.add(n.name.split("#")[0])
        for f in fields(n): all_names(getattr(n, f.name), out)
    return out

def rename(prog, mode="full"):
    """mark-ওয়ালা নাম থেকে সাধারণ Haat. mode: none (hygiene নেই), gensym, full."""
    base = lambda k: k.split("#")[0]
    used, marked = all_names(prog, set()), set()
    def scan(n):
        if isinstance(n, list): [scan(x) for x in n]
        elif is_dataclass(n) and not isinstance(n, (TypeName, FnType)):
            if type(n).__name__ in NAMED and "#" in n.name: marked.add(base(n.name))
            for f in fields(n): scan(getattr(n, f.name))
    scan(prog)
    top = {s.name for s in prog.stmts if type(s).__name__ in ("Let", "FnDecl")}
    scopes = [{t: t for t in top}]
    def fresh(b):
        k = 1
        while f"{b}_{k}" in used: k += 1
        used.add(f"{b}_{k}"); return f"{b}_{k}"
    def bind(key):
        b = base(key)
        if mode == "none": p = b
        elif "#" in key: p = fresh(b)                      # macro-র বানানো binding: gensym
        elif mode == "full" and b in top and b in marked: p = fresh(b)   # ব্যবহারকারীর local
        else: p = b
        scopes[-1][b if mode == "none" else key] = p; return p
    def look(key):
        k = base(key) if mode == "none" else key
        for s in reversed(scopes):
            if k in s: return s[k]
        return base(key)                                   # macro-র free নাম: top level-এর
    def go(n, top_level=False):
        if isinstance(n, list): return [go(x, top_level) for x in n]
        c = type(n).__name__
        if c == "Block":
            scopes.append({}); out = replace(n, stmts=go(n.stmts)); scopes.pop(); return out
        if c == "Let":
            init = go(n.init)
            return replace(n, init=init, name=n.name if top_level else bind(n.name))
        if c in ("FnDecl", "Lambda"):
            name = n.name if top_level or c == "Lambda" else bind(n.name)
            scopes.append({}); ps = [replace(p, name=bind(p.name)) for p in n.params]
            body = replace(n.body, stmts=go(n.body.stmts)); scopes.pop()
            return replace(n, params=ps, body=body, **({"name": name} if c == "FnDecl" else {}))
        if c in ("Var", "Assign"):
            kids = {f.name: go(getattr(n, f.name)) for f in fields(n) if f.name != "name"}
            return replace(n, name=look(n.name), **kids)
        if not is_dataclass(n) or isinstance(n, (TypeName, FnType)): return n
        return replace(n, **{f.name: go(getattr(n, f.name)) for f in fields(n)})
    return Program(go(prog.stmts, top_level=True))

def expand(src, mode="full"):
    prog = parse(src); ex_ = Expander(prog)
    return rename(ex_.run(prog), mode), ex_.log

Expander-এর মূল কাজ macro expansion: একটি MacroCall পেলে macro-র body (ছাঁচ)-এর একটি কপি বানানো, parameter-এর জায়গায় argument-এর গাছ বসানো। একটি বাড়তি কাজও করে: কপির প্রতিটি অন্য নামে একটি mark বসায়, এই expansion-এর ক্রমিক নম্বর দিয়ে। প্রথম expansion-এর i হয় i#1. # চিহ্নটি Haat-এর lexer কখনো তৈরি করে না, তাই mark-ওয়ালা নাম কখনো ব্যবহারকারীর লেখা নামের সঙ্গে গুলিয়ে যায় না।

নিয়ম ৭৮.১ — mark-সহ expansion

E⟦m!(a₁, …, aₙ)⟧ = E⟦ Tk[p₁ ↦ a₁, …, pₙ ↦ aₙ] ⟧, যেখানে T হলো m-এর ছাঁচ, p₁…pₙ তার parameter, k একটি নতুন mark, আর Tk মানে ছাঁচের প্রতিটি নাম (parameter ছাড়া) x-কে x#k বানানো।

এখানে E⟦…⟧ মানে “এই গাছের expansion”, আর [p ↦ a] মানে “p-এর জায়গায় a-র গাছ বসাও”. Argument a-র নামে কোনো নতুন mark পড়ে না। ডান পাশে আবার E: ফলের ভেতরে macro থাকলে সেগুলোও খোলা হয় (অংশ ৬)।

Mark দিয়ে কী হয়, সেটি দ্বিতীয় ধাপে ঠিক হয়: rename mark-ওয়ালা গাছকে সাধারণ Haat-এ ফেরায়। তিনটি নীতি তুলনা করা যায়: none (mark মুছে দেওয়া, অর্থাৎ hygiene নেই, C-র মতো), gensym (macro-র বানানো প্রতিটি ঘোষণার নাম নতুন), আর full (পুরো hygiene, অংশ ৫). নিচের ব্লক বাজারঘরের একটি program-এ তিনটিই চালায়, আর তৈরি কোডের দরকারি লাইনগুলো পাশাপাশি দেখায়:

from haat_macro import *                 # বর্ধিত Haat: parse, Expander, rename, fmt
src = """fn delivery(total: Int) -> Int {
    if total >= 1000 { return 0; } else { return 60; }
}
macro repeat!(n, body) { var i = 0; while i < n { body; i = i + 1; } }
macro with_delivery!(amt) => amt + delivery(amt);
var i = 100;
repeat!(3, { print(i); });
fn eid_order(p: Int) -> Int {
    fn delivery(days: Int) -> Int { return 3; }    // ডেলিভারির দিন
    return with_delivery!(p);
}
print(eid_order(936));"""

prog = parse(src)
marked = Expander(prog).run(prog)        # ধাপ ১: expansion; template-এর নামে #mark

def show(tree, label):                   # দরকারি চারটি লাইন পাশাপাশি
    rows = [l.strip() for l in fmt(tree).splitlines()
            if l.strip().startswith(("var i", "while", "return p")) or "days" in l]
    print(label.ljust(7), "|", " | ".join(r.rstrip(" {") for r in rows))

show(marked, "marked")
for mode in ("none", "gensym", "full"):  # ধাপ ২: mark থেকে সাধারণ Haat নাম
    show(rename(marked, mode), mode)

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

marked  | var i = 100; | var i#1 = 0; | while i#1 < 3 | fn delivery(days: Int) -> Int | return p + delivery#2(p);
none    | var i = 100; | var i = 0; | while i < 3 | fn delivery(days: Int) -> Int | return p + delivery(p);
gensym  | var i = 100; | var i_1 = 0; | while i_1 < 3 | fn delivery(days: Int) -> Int | return p + delivery(p);
full    | var i = 100; | var i_1 = 0; | while i_1 < 3 | fn delivery_1(days: Int) -> Int | return p + delivery(p);

প্রথম সারিতে mark দেখা যাচ্ছে: repeat!-এর expansion পেয়েছে #1, with_delivery!-এর #2. ব্যবহারকারীর i আর p-তে কোনো mark নেই। বাকি তিন সারির প্রতিটি পুরো program ল্যাবে reference-এ চালানো হয়েছে (run আর vm একই ফল দেয়):

none   : 0  1  2  939
gensym : 100  100  100  939
full   : 100  100  100  996

ঠিক উত্তর শেষ সারি: ব্যবহারকারী তিনবার নিজের i (১০০) ছাপতে চেয়েছিলেন, আর ৯৩৬ টাকার অর্ডারে ডেলিভারি চার্জ ৬০ যোগ হওয়ার কথা, ঠিক bazar.haat-এর প্রথম লাইনের ৯৯৬-এর মতো। none দুটিতেই ভুল, gensym প্রথমটি সারায় কিন্তু দ্বিতীয়টি নয়। কেন, তা পরের দুই stepper-এ।

1macro repeat!(n, body) {2    var i = 0;3    while i < n { body; i = i + 1; }4}5var i = 100;6repeat!(3, { print(i); });
Expander-এর হাতে
তৈরি কোড
print(i)-এর i
  1. ব্যবহারকারীর কোড. Top level-এ var i = 100;. Block argument { print(i); }-এর i মানে এই ১০০, কারণ ব্যবহারকারী তা-ই লিখেছেন যেখানে এটি দেখা যায়।
  2. Expansion #1. ছাঁচ কপি হয়: n-এর জায়গায় 3, body;-এর জায়গায় পুরো block. ছাঁচের নিজের নাম পায় mark: i#1. Argument-এর i mark পায় না, তাই গাছে এখন দুটি আলাদা নাম।
  3. Hygiene নেই (none). Mark মুছে দিলে দুটি নাম আবার এক: var i = 0; ভেতরের block-এ বাইরের i-কে ঢেকে দেয়। Haat-এ এটি বৈধ shadowing (decision 15), তাই কোনো error নেই।
  4. চালানো. print(i) সবচেয়ে কাছের i খোঁজে, আর পায় macro-র counter. Reference-এর run ছাপে 0, 1, 2: C-র REPEAT-এর হুবহু একই ভুল।
  5. Gensym. Mark-ওয়ালা ঘোষণা i#1 পায় একটি নতুন নাম i_1, যা program-এ কোথাও নেই; তার সব ব্যবহারও i_1. ব্যবহারকারীর i অপরিবর্তিত।
  6. ঠিক ফল. এখন print(i) শুধু ব্যবহারকারীর i দেখে। Reference-এর run আর vm দুটিই ছাপে 100 তিনবার। পর্ব ৫৫-এর for-loop-এ এই সমস্যা আর সমাধান দেখেছিলেন; macro-তে পার্থক্য হলো ছাঁচ লেখেন ব্যবহারকারী নিজে, compiler নয়।

একটি বোনাস: Haat-এর কঠোর নিয়ম কিছু capture-কে নীরব ভুল থেকে compile error-এ বদলায়। macro swap!(a, b) { let tmp = a; a = b; b = tmp; }, আর ব্যবহারকারী লিখলেন var tmp = 5; var qty = 9; swap!(tmp, qty);. Hygiene ছাড়া খোলা হয় { let tmp = tmp; tmp = qty; qty = tmp; }, আর reference বলে:

4:15: error: 'tmp' is used before its declaration
5:5: error: cannot assign to 'tmp': it is declared with 'let'

প্রথমটি decision 16 (নিজের initializer-এ নিজের নাম), দ্বিতীয়টি decision 19. C-তে একই macro int tmp = tmp; বানাত, যা একটি অনির্ধারিত মান পড়ে। কিন্তু বার্তাটি লক্ষ করুন: 4:15 খোলা কোডের অবস্থান। ব্যবহারকারীর ফাইলের ৪ নম্বর লাইনে আছে swap!(tmp, qty);, যার ১৫ নম্বর কলামে কোনো tmp নেই। পর্ব ৫০ (Error recovery আর diagnostic) আর ৫৫-এর শিক্ষা এখানেও খাটে: তৈরি node-এ macro-ডাকের অবস্থান রাখতে হয়। full নীতিতে খোলা হয় let tmp_1 = tmp; tmp = qty; qty = tmp_1;, আর reference ছাপে 9, 5.

৫ · Hygiene-এর দুই দিক — mark, rename আর referential transparency

Capture দুই দিক থেকে হয়। প্রথম দিক: macro একটি নাম ঘোষণা করে (var i), আর সেটি ব্যবহারকারীর নাম ধরে ফেলে। Gensym এটি সারায়, কারণ macro-র ঘোষণা নতুন নাম পায়। দ্বিতীয় দিক: macro একটি বাইরের নাম ব্যবহার করে (delivery), আর ব্যবহারকারী macro-ডাকের জায়গায় সেই নামে নিজের একটি local ঘোষণা রেখেছেন। তখন macro-র নামটি ভুল জিনিস ধরে। Macro-র ছাঁচে delivery একটি free variable; macro কোনো ঘোষণা বানায়নি, তাই gensym-এর নতুন নাম দেওয়ার কিছু নেই।

1fn delivery(total: Int) -> Int { … }2macro with_delivery!(amt) => amt + delivery(amt);3fn eid_order(p: Int) -> Int {4    fn delivery(days: Int) -> Int { return 3; }5    return with_delivery!(p);6}7print(eid_order(936));
Expander-এর হাতে
তৈরি কোড
delivery মানে
  1. Macro-র সংজ্ঞা. Macro top level-এ লেখা। সেখানে delivery মানে বাজারঘরের চার্জের function: ১০০০ টাকার নিচে ৬০. Macro-র লেখক এটিই বুঝিয়েছেন।
  2. ব্যবহারকারীর local. ঈদের অর্ডারের function-এ কেউ ডেলিভারির দিন গুনতে নিজের একটি fn delivery(days: Int) রেখেছেন, যা ৩ ফেরত দেয়। ভেতরের block-এ এটি বৈধ shadowing.
  3. Expansion #2. amt-এর জায়গায় p (mark ছাড়া), আর ছাঁচের delivery হয় delivery#2. এটি কোনো ঘোষণা নয়, একটি ব্যবহার: macro নিজে delivery#2 নামে কিছু ঘোষণা করেনি।
  4. None আর gensym. Mark মুছলে delivery(p) সবচেয়ে কাছের delivery পায়: দিনের হিসাব। ফল ৯৩৬ + ৩ = ৯৩৯. Gensym শুধু macro-র ঘোষণার নাম বদলায়; এখানে কোনো ঘোষণা নেই, তাই একই ৯৩৯. Reference-এ দুটিরই সত্যিকারের run ৯৩৯ ছাপে।
  5. Full hygiene. নিয়ম ৭৮.২: delivery#2-এর জন্য mark #2-ওয়ালা কোনো ঘোষণা নেই, তাই এটি macro-র সংজ্ঞার জায়গার (top level) delivery. সেই নাম যেন লেখায় ঢাকা না পড়ে, তাই ব্যবহারকারীর local-কে delivery_1 নাম দেওয়া হয় (তার সব ব্যবহারসহ)।
  6. ঠিক ফল. Reference-এর run আর vm: ৯৩৬ + ৬০ = 996, bazar.haat-এর প্রথম লাইনের সঙ্গে মেলে। নাম বদলেছে, কিন্তু program-এর অর্থ ব্যবহারকারী আর macro-লেখক দুজনের চোখেই একই রইল।
নিয়ম ৭৮.২ — mark-ওয়ালা নামের অর্থ (rename, full নীতি)

(ক) একটি ঘোষণা x#k শুধু x#k নামের ব্যবহারকে বাঁধে; mark ছাড়া x তাকে কখনো দেখে না, x#k-ও mark ছাড়া ঘোষণা দেখে না। (খ) x#k-এর জন্য কোনো x#k ঘোষণা না থাকলে x#k মানে macro-র সংজ্ঞার জায়গায় দেখা যায় এমন x, Haat-এ যা top level. (গ) শেষে প্রতিটি x#k ঘোষণা একটি নতুন নাম পায়, আর ব্যবহারকারীর যে local নাম কোনো (খ)-ধরনের নামের সঙ্গে মেলে, সেটিও নতুন নাম পায়।

(ক) প্রথম দিক সারায়, (খ) দ্বিতীয় দিক। (খ)-এর গুণটির নাম referential transparency-র সঙ্গে মিল রেখে প্রায়ই বলা হয় macro-র “referential transparency”: macro-র ছাঁচের একটি নাম সেটিই বোঝায়, যা লেখার জায়গায় বোঝাত, ঠিক যেমন একটি function-এর ভেতরের বাইরের নাম lexical scope মেনে চলে। (গ) একটি α-renaming: একটি ঘোষণা আর তার সব ব্যবহার একসঙ্গে নতুন নামে, তাই অর্থ বদলায় না। এই কারণেই ব্যবহারকারীর delivery-কে delivery_1 বানানো নিরাপদ।

প্রমাণের রূপরেখা (full নীতিতে কোনো capture নেই):

  1. নতুন নাম program-এর সব নামের তালিকা দেখে বানানো, তাই প্রতিটি নতুন নাম অনন্য; লেখায় কোনো নতুন নাম অন্য কোনো ঘোষণার নামের সঙ্গে মেলে না।
  2. ব্যবহারকারীর একটি নাম x (mark ছাড়া) rename-এর আগে যে ঘোষণা D-কে বাঁধত, (ক) অনুযায়ী D-ও mark ছাড়া। D-র নাম হয় অপরিবর্তিত, নয়তো (গ)-তে অনন্য নামে বদলানো (তার সব ব্যবহারসহ)। মাঝখানের কোনো x#k ঘোষণা নতুন অনন্য নাম পেয়েছে, তাই লেখায় x-কে আর ঢাকতে পারে না। ফলে x এখনো D-কে বাঁধে।
  3. ছাঁচের একটি free নাম x#k (খ) অনুযায়ী top-level x. লেখায় তার নাম x, আর x নামের যে local ঘোষণা মাঝখানে থাকতে পারত, (গ) তাকে নতুন নাম দিয়েছে। Top-level নাম কখনো বদলায় না। তাই x#k লেখাতেও top-level x-কে বাঁধে।
  4. ছাঁচের একটি বাঁধা নাম x#k-এর ঘোষণা আর ব্যবহার একসঙ্গে একই নতুন নাম পেয়েছে (ধাপ ১), তাই সম্পর্ক অক্ষত। তিন ধরনের নামই তাদের আগের ঘোষণা বাঁধে; অর্থাৎ rename অর্থ রাখে আর capture অসম্ভব। ∎

প্রমাণের পাশে differential testing. ল্যাবে একটি seed দেওয়া generator ৪০০টি এলোমেলো program বানিয়েছে, যেখানে ব্যবহারকারীর নাম ইচ্ছে করে macro-র ভেতরের নামের সঙ্গে মেলে (i, tmp, local delivery), আর macro একে অন্যের ভেতরে বসে। দুটি স্বাধীন expander: A হলো পাতার mark-ভিত্তিক expander, B একটি আলাদা কৌশল (আগে ব্যবহারকারীর প্রতিটি local-কে অনন্য নাম দেয়, তারপর সাধারণ substitution). প্রতিটি ফল reference-এ চালানো হয়েছে:

$ python -B fuzz.py 400        # seed 78; reference-এর run আর vm
programs 400: A run == A vm 400/400, A == B 400/400
no hygiene : 137 wrong (75 static error, 1 never stopped, 61 wrong output)
gensym only: 116 wrong (58 static error, 58 wrong output)
macro uses: repeat! 1350, swap! 47, with_delivery! 1458, square! 1388, twice! 1470

দুটি স্বাধীন পথ ৪০০টিতেই একমত, আর run-vm-ও। Hygiene ছাড়া ১৩৭টি program ভুল: ৭৫টিতে Haat-এর নিয়ম ভুলটি compile error-এ ধরেছে (যেমন swap!), ১টি কখনো থামেনি (body ব্যবহারকারীর ভেবে macro-র counter বদলেছে), আর ৬১টি নীরবে ভুল সংখ্যা ছেপেছে। শুধু gensym দিলে ভুল কমে ১১৬-তে, কারণ এখানে বেশিরভাগ ভুল দ্বিতীয় দিকের, local delivery থেকে। Generator যা বানাতে পারে, test শুধু সেটুকুই খোঁজে; তাই ওপরের দুটি হাতে-লেখা উদাহরণও রাখা হয়েছে।

বাস্তব ভাষাগুলো কী করে? Wandbox-এ Rust 1.82.0-এ একই দুই পরীক্ষার সত্যিকারের run (main একটি মন্তব্যে সংক্ষেপ করা):

macro_rules! repeat {
    ($n:expr, $body:block) => {{ let mut i = 0; while i < $n { $body; i += 1; } }};
}
fn delivery(t: i64) -> i64 { if t >= 1000 { 0 } else { 60 } }
macro_rules! with_delivery { ($a:expr) => { $a + delivery($a) }; }
fn eid_order(p: i64) -> i64 {
    fn delivery(_days: i64) -> i64 { 3 }
    with_delivery!(p)
}
// main: let i = 100; repeat!(3, { println!("i = {}", i); }); println!("{}", eid_order(936));

warning: function `delivery` is never used
 --> prog.rs:9:4
i = 100
i = 100
i = 100
939

Rust-এর macro_rules! local variable-এর ক্ষেত্রে hygienic (১০০ তিনবার), কিন্তু function-এর নামে নয়: delivery খোঁজা হয়েছে macro-ডাকের জায়গায়, ফল ৯৩৯, আর compiler নিজেই জানাচ্ছে top-level delivery “never used”. Rust-এর reference এই আচরণকে “mixed-site” hygiene বলে: local variable, label আর $crate সংজ্ঞার জায়গায় খোঁজা হয়, বাকি নাম ডাকের জায়গায়। Macro-লেখকরা তাই বাইরের function-এর পুরো path লেখেন ($crate::delivery). Scheme আর Racket-এর hygienic macro দুই দিকই সামলায়, আমাদের full-এর মতো।

৬ · Expansion-এর ক্রম — বাইরে থেকে ভেতরে, আবার পড়া আর থামা

একটি macro-র argument-এ আরেকটি macro থাকলে কোনটি আগে খুলবে? Function call-এ argument আগে হিসাব হয় (Haat-এর decision 12), কিন্তু macro সাধারণত উল্টো পথে চলে: বাইরে থেকে ভেতরে (outside-in). বাইরের macro তার argument পায় না-খোলা গাছ হিসেবে; খোলার পরে ফলটি আবার পড়া হয়, আর তখন ভেতরের macro খোলে। এর একটি কারণ: বাইরের macro-র কাছে argument-টি কোড, মান নয়; সে চাইলে সেটি একবারও না বসাতে পারে, দুবার বসাতে পারে, বা লেখা হিসেবে দেখতে পারে। পর্ব ১৯-এর (Evaluation strategy) call-by-name-এর সঙ্গে মিলটি লক্ষ করুন।

src2 = """var calls = 0;
fn next() -> Int { calls = calls + 1; return calls; }
macro square!(x) => x * x;
macro twice!(e) => e + e;
print(100 / square!(2 + 3));
print(twice!(square!(next())));
print(calls);"""

p2 = parse(src2)
exp = Expander(p2)
core = rename(exp.run(p2))
for depth, name, tree in exp.log:         # expansion-এর আসল ক্রম, গভীরতা অনুযায়ী সরানো
    print("  " * depth + f"{name:<10} -> {ex(tree)}")
print(fmt(core), end="")

runaway = parse("macro grow!(x) => grow!(x + 1);\nprint(grow!(0));")
try:
    Expander(runaway).run(runaway)       # নিজেকেই আবার ডাকে: কখনো শেষ হয় না
except RecursionError as err:
    print(err)

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

square!#1  -> (2 + 3) * (2 + 3)
twice!#2   -> square!(next()) + square!(next())
  square!#3  -> next() * next()
  square!#4  -> next() * next()
var calls = 0;
fn next() -> Int {
    calls = calls + 1;
    return calls;
}
print(100 / ((2 + 3) * (2 + 3)));
print(next() * next() + next() * next());
print(calls);
1:19: error: macro expansion too deep ('grow!')

Log-এর ক্রমই expansion-এর ক্রম। প্রথম square! (#1) গাছ হিসেবে argument পেয়েছে, তাই formatter নিজেই বন্ধনী বসিয়েছে, আর reference ছাপে 4: অংশ ২-এর ৫৯-এর ফাঁদ নেই। তারপর twice! (#2) আগে খুলেছে, ভেতরের square!-কে না ছুঁয়েই দুবার কপি করেছে; এরপর গভীরতা ১-এ দুটি square! (#3, #4). ফল: next() চারবার ডাকা হয়। Reference-এর সত্যিকারের run: 4, 14 (১×২ + ৩×৪), 4. গাছের macro precedence সারায়, double evaluation সারায় না। শেষ লাইন: grow! নিজেকে চিরকাল খুলত; expander ৪০ স্তর গভীরে গিয়ে থেমেছে, আর error দেখাচ্ছে ছাঁচের ভেতরের ডাকের অবস্থান।

1macro square!(x) => x * x;2macro twice!(e) => e + e;3print(twice!(square!(next())));
Expander-এর হাতে
এই expansion
গাছ এখন
  1. প্রথম সাক্ষাৎ. Expander print-এর ভেতরে ঢুকে প্রথমে পায় twice!. ভেতরের square!(next()) এখন শুধু তার argument-এর একটি গাছ, খোলা হয়নি।
  2. twice! খোলে (#2). e-এর জায়গায় পুরো গাছ square!(next()), দুবার, দুটি আলাদা কপি। (#1 আগের লাইনের square! পেয়েছিল।)
  3. আবার পড়া, বাঁ দিক. ফলের ভেতরে macro আছে, তাই expander আবার হাঁটে। বাঁ দিকের square! খোলে (#3): next() * next().
  4. ডান দিক. একইভাবে ডান দিকের square! (#4). দুই কপি আলাদা mark পেয়েছে; এদের ভেতরে কোনো ঘোষণা থাকলে তারাও আলাদা নতুন নাম পেত।
  5. শেষ. গাছে আর কোনো MacroCall নেই। এবার rename, তারপর সাধারণ Haat হিসেবে resolver, type checker আর back end-এ যায়।
  6. চালানো. বাঁ থেকে ডানে (decision 12) next() দেয় ১, ২, ৩, ৪: ১×২ + ৩×৪ = ১৪, আর calls = ৪. Reference-এর run আর vm একই। একটি next() লিখে চারবার ডাক: ঠিক এ কারণে ভালো macro-লেখক argument আগে একটি নতুন নামে বাঁধেন (অনুশীলন ১)।

বাইরে থেকে ভেতরে খোলার ফল সবচেয়ে স্পষ্ট দেখা যায় যখন বাইরের macro argument-কে লেখা হিসেবে চায়। Rust-এ (একই Wandbox run) stringify!(square!(2 + 3)) ছাপে square!(2 + 3): ভেতরেরটি খোলার আগেই বাইরেরটি লেখা বানিয়েছে। C এখানে আলাদা: অংশ ২-এর prescan নিয়মে সাধারণ argument আগে খোলে, শুধু #-এর পাশে খোলে না। অর্থাৎ “macro কোন ক্রমে খোলে” প্রশ্নের উত্তর ভাষাভেদে আলাদা; প্রতিটির নিজের specification পড়তে হয়।

থামার প্রশ্নও আছে। Rust-এর sum!-এর মতো নিজেকে ডাকা macro দরকারি, তাই C-র “নিজেকে আর খোলে না” নিয়ম গাছের macro-তে চলে না। আবার একটি macro আদৌ থামবে কি না, তা আগে থেকে সাধারণভাবে বলা যায় না, কারণ macro ভাষাগুলো প্রায়ই যেকোনো হিসাব করতে পারে (গণনার তত্ত্ব কোর্সের পর্ব ৫৩-এ Rice-এর উপপাদ্য)। তাই বাস্তব compiler একটি সীমা রাখে: Rust-এ recursion_limit নামের একটি সেটিং আছে (সাধারণত ১২৮ বলে জানা যায়), আমাদের expander-এ ৪০.

৭ · Template আর constexpr — type আর মানের স্তরে হিসাব

C++-এর template শুরুতে ছিল type-নিরপেক্ষ কোড লেখার উপায় (পর্ব ৩৭-এ Generics-এর বাস্তবায়ন: monomorphization). কিন্তু template instantiation নিজেই একটি হিসাব: Fact<5> বানাতে compiler-কে Fact<4> বানাতে হয়, আর Fact<0>-এর specialization থামার নিয়ম। এভাবে compile-এর সময় হিসাব করাকে বলে template metaprogramming. পরে C++11 আনে constexpr: সাধারণ function, যা compile-এর সময়েও চলতে পারে। দুটিই নিচে, বাজারঘরের দামের নিয়ম দিয়ে:

#include <array>
#include <cstdio>
// constexpr: এই function compile-এর সময়েও চলতে পারে
constexpr long price(long qty, long unit) {
    long p = qty * unit;
    return p >= 1000 ? p - p / 10 : p;
}
constexpr long delivery(long total) { return total >= 1000 ? 0 : 60; }

constexpr std::array<long, 5> make_table() {      // ১ থেকে ৫টি, প্রতিটি ৫২০ টাকা
    std::array<long, 5> t{};
    for (int q = 1; q <= 5; ++q) t[q - 1] = price(q, 520) + delivery(price(q, 520));
    return t;
}
constexpr auto TABLE = make_table();                // compile-এর সময়ে হিসাব
static_assert(TABLE[1] == 996, "bazar.haat-er prothom line");

template <int N> struct Fact { static constexpr long value = N * Fact<N - 1>::value; };
template <> struct Fact<0> { static constexpr long value = 1; };   // থামার নিয়ম
static_assert(Fact<5>::value == 120);

int main() {
    for (long v : TABLE) std::printf("%ld ", v);
    std::printf("\nFact<5> = %ld, Fact<20> = %ld\n", Fact<5>::value, Fact<20>::value);
}

আসল আউটপুট (Wandbox-এর GCC, C++2b):

580 996 1404 1872 2340
Fact<5> = 120, Fact<20> = 2432902008176640000

দ্বিতীয় সংখ্যা ৯৯৬: bazar.haat-এর প্রথম লাইন, এবার compile-এর সময় হিসাব করা। দুটি static_assert compile-এর সময়েই শর্ত দেখে; শর্ত মিথ্যা হলে program তৈরিই হয় না। হিসাব যে সত্যিই compile-এর সময় হয়েছে, তার প্রমাণ assembly-তে। একই টেবিল (header ছাড়া, extern const হিসেবে) zig-এর Clang 22.1.8-এ -O0 -S দিয়ে x86-64-এর জন্য compile করলে পুরো ফাইল ১৬ লাইনের, তার মূল অংশ:

TABLE:
	.quad	580                             # 0x244
	.quad	996                             # 0x3e4
	.quad	1404                            # 0x57c
	.quad	1872                            # 0x750
	.quad	2340                            # 0x924
	.size	TABLE, 40

কোনো call, কোনো গুণ বা loop নেই, এমনকি -O0-তেও। price আর delivery-র কোনো machine code-ও নেই: সব হিসাব compiler-এর ভেতরে শেষ, ফাইলে শুধু পাঁচটি ধ্রুবক।

এখানে metaprogram চলে type আর মানের স্তরে, আর দুটি পুরোনো প্রশ্ন আবার আসে। প্রথম, থামা: template দিয়ে যেকোনো হিসাব লেখা যায় বলে ধরা হয় (Todd Veldhuizen-এর একটি পরিচিত লেখায় এর যুক্তি আছে), তাই compiler গভীরতা আর ধাপের সীমা রাখে। দ্বিতীয়, error message: template-এর ভুল একসময় শত লাইনের বার্তা দিত; C++20-এর concepts এর একটি উত্তর। ভাষার বিস্তারিত C++ কোর্সে: পর্ব ৩৯ (constexpr) আর পর্ব ৪১ (উন্নত template). একটি আধুনিক ধারা হলো একই ভাষা দুই সময়ে চালানো: Zig-এর comptime সাধারণ Zig কোডকে compile-এর সময় চালায়, আর গবেষণায় একে বলে multi-stage programming (MetaOCaml এর পরিচিত উদাহরণ), যেখানে quasi-quotation দিয়ে “পরের ধাপের কোড” বানানো হয় আর type checker নিশ্চিত করে সেই কোড সবসময় well-typed.

৮ · Run time-এর metaprogramming — reflection, annotation আর decorator

ছবি ৭৮.১-এর নিচের স্তরে program চলার সময় নিজেকে দেখে বা বদলায়। Python-এ একটি decorator আসলে f = rule("delivery")(f)-এর sugar, আর সেটি চলে def statement চলার সময়, প্রতিটি ডাকে নয়। Introspection function-এর parameter পড়তে দেয়, আর ast module দিয়ে চলার সময়ই গাছ বানিয়ে compile করা যায়। ল্যাবে CPython 3.14.4-এ সত্যিকারের run (import আর NodeTransformer-এর কয়েক লাইন একটি মন্তব্যে সংক্ষেপ করা):

RULES = {}
def rule(name):                         # decorator: run time-এ নিয়ম নথিভুক্ত
    def register(f):
        RULES[name] = f
        return f
    return register

@rule("delivery")
def delivery(total: int) -> int:
    return 0 if total >= 1000 else 60

print(list(RULES), inspect.signature(delivery))
tmpl = ast.parse("def gen(q):\n    return q * UNIT")     # ফাঁকা ঘরসহ ছাঁচ
# NodeTransformer: UNIT নামের জায়গায় ast.Constant(520), তারপর compile আর exec

['delivery'] (total: int) -> int
def gen(q): |     return q * 520
1040

শেষ তিন লাইন আউটপুট। দ্বিতীয় অংশটি quasi-quotation-এর একটি হাতে-বানানো রূপ: ছাঁচ parse, ফাঁকা ঘর ভরা, তারপর compile. Python-এ কোনো macro system নেই; এ ধরনের রূপান্তর চলার সময় হয়, আর ভুল ধরা পড়ে চলার সময়ই। বিস্তারিত ভাষার কোর্সে: Python-এর decorator (পর্ব ৩৭) আর metaclass (পর্ব ৩৮), Java-র annotation আর reflection (পর্ব ৪৫), JavaScript-এর Proxy আর Reflect (পর্ব ২৮).

Java-র annotation দুই সময়েই কাজে লাগে, আর পার্থক্যটি compiler-লেখকের জন্য গুরুত্বপূর্ণ। চলার সময় একটি framework reflection দিয়ে @Test-ওয়ালা method খুঁজে ডাকে: সহজ, কিন্তু প্রতিবার program শুরুতে খোঁজার খরচ, আর compiler আগে থেকে জানে না কোন method নাম ধরে ডাকা হবে। Compile-এর সময় একটি annotation processor একই annotation পড়ে নতুন source ফাইল তৈরি করে, যা সাধারণ কোডের মতো type check হয়। নিচের টেবিলে পুরো তুলনা:

প্রশ্নCompile time (macro, template, constexpr)Run time (reflection, decorator, eval)
ভুল কখন ধরা পড়েBuild-এর সময়, ব্যবহারকারীর কাছে পৌঁছানোর আগেসেই লাইন চলার সময়, হয়তো অনেক পরে
গতির খরচCompile ধীর হতে পারে; চলার সময় খরচ প্রায় নেইপ্রতিবার খোঁজা আর পরোক্ষ ডাক; JIT কিছুটা সারায়
কী জানেকোড আর type; চলার সময়ের মান নয়আসল object, মান আর বাইরের ইনপুট
Tool আর IDEExpansion জানতে হয়, নইলে নাম খোঁজা আর autocomplete ভুলনাম string-এ থাকলে tool অনুসরণ করতে পারে না
নিরাপত্তাProc macro build machine-এ কোড চালায়বাইরের লেখা eval-এ গেলে code injection (পর্ব ১২)

আরও গভীরে: Hygienic macro expansion-এর আনুষ্ঠানিক সমাধান সাধারণত Kohlbecker, Friedman, Felleisen আর Duba-র ১৯৮৬ সালের কাজকে কৃতিত্ব দেওয়া হয়; তাঁদের কৌশলও প্রতিটি expansion-এ নামের গায়ে একটি “সময়-চিহ্ন” বসানো, আমাদের mark-এর মতো। পরে Racket নামের সঙ্গে scope-এর একটি সেট রাখার মডেলে গেছে (Matthew Flatt-এর “sets of scopes”, ২০১৬ সালের দিকে)। Template Haskell (Sheard আর Peyton Jones, ২০০২) Haskell-এ compile time-এর metaprogramming আনে। আর partial evaluation-এর বিখ্যাত ফল, Futamura projection (১৯৭১): একটি interpreter-কে একটি নির্দিষ্ট program দিয়ে বিশেষায়িত করলে সেই program-এর compile করা রূপ পাওয়া যায়।

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

  • #define SQUARE(x) x*x দিয়ে 100 / SQUARE(2+3) কত? ৫৯: preprocessor লেখা বদলায়, তাই 100 / 2+3*2+3; প্রতিকার ((x)*(x)), তবু double evaluation থাকে।
  • Macro আর function-এর পার্থক্য? Macro compile-এর আগে বা সময়ে কোড বদলায়, argument কোড হিসেবে পায় (হিসাব হয় না); function চলার সময় ডাকা হয়, argument একবার হিসাব হয়।
  • Hygienic macro কী? যে expansion-এ macro-র নাম ব্যবহারকারীর নাম ধরে না, আর macro-র ব্যবহৃত বাইরের নাম সংজ্ঞার জায়গার অর্থ রাখে; gensym শুধু প্রথম দিক সারায়।
  • Template metaprogramming আর constexpr-এর পার্থক্য? প্রথমটি template instantiation দিয়ে হিসাব করে, দ্বিতীয়টি সাধারণ function compile-এর সময় চালায়; দুটিরই ফল ধ্রুবক।
  • Reflection-এর দাম কী? চলার সময় নাম ধরে খোঁজা ধীর, compiler আর tool আগে থেকে দেখে না, আর বাইরের ইনপুটে ঝুঁকি।

৯ · AI-এর যুগে metaprogramming

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

AI-এর ভুলকীভাবে ধরবেন
C macro-তে বন্ধনী ভুলে যাওয়া, বা argument দুবার বসানো-E দিয়ে আসল expansion পড়া; 2+3 আর i++ দিয়ে test
“Rust-এর macro পুরো hygienic” বা “C macro hygienic করা যায়” জাতীয় সাধারণ দাবিভাষা আর সংস্করণসহ আসল run: local নাম আর function-এর নাম দুটিই পরীক্ষা (১০০ বনাম ৯৩৯)
Gensym দিয়েই hygiene শেষ মনে করাব্যবহারকারীর local-এ macro-র ব্যবহৃত বাইরের নাম রেখে চালানো
Expansion-এর ক্রম ভুল বলা (C-র prescan আর Rust-এর outside-in গুলিয়ে ফেলা)#/stringify! দিয়ে ছোট পরীক্ষা; specification পড়া
Compile time-এর হিসাব “নিশ্চয়ই হয়েছে” ধরে নেওয়াstatic_assert, আর -S-এর assembly-তে ধ্রুবক খোঁজা
Reflection বা eval দিয়ে এমন কাজ, যা সাধারণ function-এই হয়প্রশ্ন করা: এটি কি compile time-এ বা সাধারণ কোডে করা যায়? বাইরের ইনপুট কি কোডে ঢুকছে?

AI-কে কাজে লাগানোর ভালো উপায়: macro-র অর্থ আগে নিজে লিখুন (কোন argument কতবার, কোন নাম কার), ভাষা আর সংস্করণ বলুন, আর expansion-সহ test চান, যা আপনি নিজে চালিয়ে মেলাবেন।

আমি Haat নামের একটি ছোট ভাষার জন্য Python-এ একটি macro expander লিখছি (AST-এর ওপর, macro শুধু top level-এ)। চাই: macro max_into!(dst, a, b), যা a আর b ঠিক একবার করে, বাঁ থেকে ডানে হিসাব করে, বড়টি dst-এ বসাবে। ১. আগে expansion-টি লিখে বলো, প্রতিটি নতুন নাম কোথা থেকে আসছে। ২. Hygiene দুই দিকেই চাই: macro-র নাম যেন ব্যবহারকারীর নাম না ধরে, আর macro-র ব্যবহৃত বাইরের নাম যেন ব্যবহারকারীর local-এ ধরা না পড়ে। Gensym কোনটি সারায় আর কোনটি সারায় না, বলো। ৩. ৬টি test দাও প্রত্যাশিত আউটপুটসহ: ব্যবহারকারীর variable-এর নাম x বা y, side effect-ওয়ালা argument, nested macro, আর একটি macro যা নিজেকে ডাকে। ৪. কোনো ভাষার আচরণ নিয়ে নিশ্চিত না হলে “নিশ্চিত নই” লেখো, অনুমান করবে না।

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

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

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

প্র ০১এত ফাঁদ থাকা সত্ত্বেও C preprocessor আজও কেন টিকে আছে, আর C++ ও Rust এর কোন কোন কাজের বিকল্প দিয়েছে?

Preprocessor C-র প্রথম দিকেই (১৯৭০-এর দশকের শুরুতে) যোগ হয়েছিল, মূলত তিনটি কাজের জন্য: অন্য ফাইল জোড়া (#include), ধ্রুবকের নাম (#define N 100), আর পরিস্থিতি অনুযায়ী কোড বাছাই (#ifdef _WIN32). তখনকার compiler ছোট আর ধীর যন্ত্রে চলত, আর একটি আলাদা লেখা-বদলের ধাপ বানানো সহজ ছিল। এর শক্তি ঠিক এর দুর্বলতা থেকেই: ভাষা না বুঝে লেখা বদলায় বলে যেকোনো কিছু করতে পারে, এমনকি অসম্পূর্ণ কোডের টুকরো জোড়া।

টিকে থাকার কারণ প্রধানত সামঞ্জস্য। কোটি কোটি লাইনের C কোড, operating system আর library-র header এর ওপর দাঁড়িয়ে; বিভিন্ন platform-এর জন্য conditional compilation-এর আর কোনো মানসম্মত পথ C-তে নেই। C23 constexpr object আর আরও কিছু সুবিধা এনেছে, তবু macro সরানোর মতো নয়।

C++ একটি একটি করে কাজ কেড়ে নিয়েছে: ধ্রুবকের জন্য const আর constexpr (type আর scope-সহ), ছোট function-এর জন্য inline function আর template (argument একবার হিসাব, type check-সহ), compile-time হিসাবের জন্য constexpr আর consteval, আর C++20 থেকে module, যা #include-এর লেখা-জোড়ার বদলে compile করা interface দেয়। Rust আরও এগিয়ে: কোনো লেখা-বদলের preprocessor নেই; conditional compilation হয় #[cfg(…)] attribute দিয়ে, যা parser চেনে, আর macro চলে token-এর গাছে।

তবু preprocessor-এর শিক্ষা মূল্যবান, কারণ ঠিক কোন তথ্য হারালে কী ভাঙে, তা এর তিনটি ফাঁদ দেখায়: গঠন (precedence), হিসাবের সংখ্যা (double evaluation), আর নামের অর্থ (capture). পরের প্রতিটি নকশা এই তিনটির কোনো একটির উত্তর।

মূল উপলব্ধি: একটি দুর্বল কিন্তু সর্বজনীন যন্ত্র সামঞ্জস্যের জোরে টিকে থাকে; নতুন ভাষা সেটি সরায় একেকটি কাজের জন্য একেকটি নিরাপদ, ভাষা-সচেতন বিকল্প দিয়ে।

প্র ০২LISP থেকে Scheme আর Racket — macro আর hygiene-এর ইতিহাস ভাষা-নকশা সম্পর্কে কী শেখায়?

LISP-এ কোড আর ডেটা একই list, তাই ১৯৬০-এর দশকেই macro এসেছে একটি স্বাভাবিক ধারণা হিসেবে: compile-এর সময় চলা একটি function, যা list নেয় আর list দেয়। Backquote দিয়ে quasi-quotation ছাঁচ লেখা সহজ করেছে। কিন্তু দ্রুতই নামের সমস্যা দেখা দেয়, আর তার প্রথম উত্তর ছিল শৃঙ্খলা: gensym দিয়ে নিজের temp-এর নাম বানানো। Common Lisp এই পথেই থেকেছে; তার ব্যবহারকারীরা package system দিয়ে দ্বিতীয় দিকের ঝুঁকিও কমান, কারণ list-এর মতো standard function-এর নাম local function হিসেবে নতুন করে বাঁধা নিষেধ।

Scheme-এর সমস্যা ছিল কঠিন: একটি ছোট ভাষা, যেখানে সব নাম, এমনকি if বা list, local-এ নতুন করে বাঁধা যায়। তাই macro-লেখকের শৃঙ্খলা যথেষ্ট নয়। Kohlbecker ও সহলেখকদের ১৯৮৬ সালের কাজ দেখাল, expander নিজেই নামের উৎস মনে রাখতে পারে, প্রতিটি expansion-এ চিহ্ন বসিয়ে। পরে syntax-rules Scheme-এর report-এ আসে (R5RS, ১৯৯৮-এ মূল অংশে বলে জানা যায়), আর syntax-case pattern-এর বাইরে যেকোনো হিসাব করার সুযোগ দেয়, hygiene রেখে।

Racket এই ধারাকে সবচেয়ে দূরে নিয়ে গেছে: প্রতিটি নামের সঙ্গে একটি “syntax object” থাকে, যাতে আছে অবস্থান আর scope-এর তথ্য। ফলে Racket-এ পুরো নতুন ভাষা (type-সহ ভাষা পর্যন্ত) macro দিয়ে বানানো যায়, আর error message-ও সঠিক জায়গা দেখায়। এই পর্বের ছোট expander একই ধারণার খেলনা রূপ: mark মানে “এই নাম কোন expansion থেকে এল”, আর rename মানে শেষে সেই তথ্য দিয়ে অর্থ ঠিক করা।

নকশার শিক্ষা দুটি। এক, যে ভাষায় সব নাম বদলানো যায়, সেখানে নিরাপত্তার দায়িত্ব যন্ত্রের, মানুষের নয়। দুই, hygiene আসলে lexical scope-এর নিয়মকে macro পর্যন্ত বাড়ানো: একটি নাম সেটিই বোঝায়, যা লেখার জায়গায় বোঝাত।

মূল উপলব্ধি: macro-র ইতিহাস হলো ধীরে ধীরে লেখা থেকে অর্থের দিকে যাত্রা: প্রথমে list, তারপর নামের উৎস, তারপর পুরো scope-এর তথ্য।

প্র ০৩Rust কেন “mixed-site” hygiene বেছে নিল, আর কখন একজন macro-লেখক ইচ্ছে করেই capture চান?

এই পর্বের Wandbox run দেখাল, Rust 1.82.0-এর macro_rules!-এ macro-র let i ব্যবহারকারীর i ধরে না (১০০ তিনবার), কিন্তু macro-র লেখা delivery(…) ডাকের জায়গার local function পায় (৯৩৯)। এটি দুর্ঘটনা নয়, নকশা। Rust-এ function, type বা module-এর নাম সাধারণত path দিয়ে লেখা হয়, আর library-র macro নিজের crate-এর জিনিস বোঝাতে $crate:: লেখে, যা সবসময় macro-র crate-কে বোঝায়। তাই local variable-এর মতো সবচেয়ে সাধারণ দুর্ঘটনা ভাষা আটকায়, বাকিটা path-এর শৃঙ্খলায় ছাড়ে।

ইচ্ছে করে capture-ও দরকার হয়। একটি macro যদি ব্যবহারকারীর জন্য একটি function বা struct বানায় (যেমন make_getter!(price), যা fn price() তৈরি করে), তাহলে সেই নামটি ব্যবহারকারীর কোড থেকে দেখা যেতেই হবে; পুরো hygiene সেটি লুকিয়ে ফেলত। LISP-এর জগতে এর পরিচিত উদাহরণ “anaphoric” macro, যেমন একটি aif, যা শর্তের মান it নামে body-কে দেখায়। Scheme-এ এমন কাজে hygiene ইচ্ছাকৃতভাবে ভাঙার আলাদা উপায় আছে (datum->syntax), যাতে ভাঙাটা স্পষ্ট আর একটি জায়গায় সীমিত থাকে।

Rust-এর proc macro আরও খোলা: সে token নিয়ে কাজ করে, আর প্রতিটি token-এর সঙ্গে একটি “span” থাকে যা ঠিক করে নামটি কোথা থেকে খোঁজা হবে। Proc macro-লেখক চাইলে ডাকের জায়গার span দেন (ব্যবহারকারীর নামের মতো আচরণ) বা mixed-site span. অর্থাৎ hygiene এখানে একটি সুইচ, macro-লেখকের হাতে।

Haat-এর জন্য কী বেছে নেব? আমাদের macro শুধু top level-এ আর শুধু expression বা block বানায়, তাই full hygiene সবচেয়ে নিরাপদ আর সহজে ব্যাখ্যাযোগ্য। Haat যদি কখনো এমন macro চায় যা নতুন function ঘোষণা করে, তখন একটি স্পষ্ট চিহ্ন লাগবে (“এই নামটি ব্যবহারকারীর”)।

মূল উপলব্ধি: hygiene সাদা-কালো নয়; প্রতিটি ভাষা ঠিক করে কোন নাম কোথায় খোঁজা হবে, আর ইচ্ছাকৃত capture-এর জন্য একটি স্পষ্ট দরজা রাখে। দাবি নয়, run দিয়ে জানুন আপনার ভাষা কী করে।

প্র ০৪Template দিয়ে যেকোনো হিসাব করা যায় — এ কথা কীভাবে আবিষ্কৃত হলো, আর compile time-এর হিসাবের দাম কী?

C++-এর template নকশা করা হয়েছিল type-নিরপেক্ষ container আর algorithm-এর জন্য, হিসাবের ভাষা হিসেবে নয়। ১৯৯৪ সালের দিকে Erwin Unruh একটি C++ standardization সভায় একটি program দেখান বলে জানা যায়, যা চলে না, কিন্তু compile হওয়ার সময় error message-এ মৌলিক সংখ্যাগুলো ছাপে। এরপর Todd Veldhuizen আর অন্যরা দেখান, template specialization আর recursion দিয়ে যেকোনো হিসাব লেখা যায়; template ব্যবস্থা কার্যত Turing-complete.

এর তাত্ত্বিক ফল সরাসরি: compile হবে কি না, অর্থাৎ compiler আদৌ থামবে কি না, তা সাধারণভাবে আগে বলা অসম্ভব, halting problem-এর কারণে। তাই compiler গভীরতা আর constexpr হিসাবের ধাপের সীমা রাখে, আর সীমা পার হলে error দেয়। অংশ ৬-এর grow!-এর ৪০ স্তরের সীমা একই কারণে।

ব্যবহারিক দাম তিনটি। এক, compile-এর সময়: ভারী template কোড build অনেক ধীর করে, আর প্রতিটি নতুন type-এর জন্য নতুন কপি (monomorphization) binary বড় করে। দুই, error message: পুরোনো template error-এ instantiation-এর পুরো ইতিহাস ছাপা হতো, যা পড়া কঠিন; C++20-এর concepts শুরুতেই শর্ত লিখতে দেয়, তাই বার্তা ছোট আর স্পষ্ট হয়। তিন, পড়ার ক্ষমতা: template-এর কৌশল (SFINAE ইত্যাদি) সাধারণ কোড থেকে অনেক আলাদা। Constexpr এই তৃতীয় দামটি অনেক কমিয়েছে, কারণ compile-time হিসাব এখন সাধারণ function-এর ভাষায় লেখা যায়, যেমন এই পর্বের make_table.

লাভও স্পষ্ট: চলার সময় খরচ শূন্য (assembly-তে শুধু পাঁচটি .quad), আর static_assert দিয়ে ভুল build-এর সময়েই ধরা পড়ে। Embedded system বা লুকআপ টেবিলের মতো জায়গায় এটি বড় সুবিধা।

মূল উপলব্ধি: যে ব্যবস্থা যথেষ্ট শক্তিশালী, সে কখন থামবে তা বলা যায় না; তাই compile time-এর হিসাবে সবসময় একটি সীমা, আর পড়ার ক্ষমতার জন্য সাধারণ function-ধাঁচের লেখা (constexpr) ভালো।

প্র ০৫একই কাজ macro দিয়ে বা reflection দিয়ে করা যায়। কখন কোনটি বেছে নেবেন, আর ahead-of-time compilation এই সিদ্ধান্তে কী বদলায়?

ধরুন বাজারঘরের প্রতিটি পণ্যের class থেকে JSON বানানোর কোড চাই। Run time-এর পথ: একটি সাধারণ function reflection দিয়ে object-এর field-এর তালিকা পড়ে, প্রতিটির নাম আর মান লেখে। একবার লিখলেই সব class-এ চলে, নতুন field-এ কিছু বদলাতে হয় না। দাম: প্রতিবার field খোঁজা, compiler জানে না কোন field পড়া হবে, আর নামের বানান ভুল ধরা পড়ে চলার সময়। Compile time-এর পথ: Rust-এর #[derive(…)]-এর মতো একটি proc macro, বা Java-র annotation processor, প্রতিটি class-এর জন্য সাধারণ কোড তৈরি করে। চলার সময় সেটি হাতে-লেখা কোডের মতো দ্রুত, আর type checker তৈরি কোডও পরীক্ষা করে। দাম: build ধীর, আর expansion দেখতে বাড়তি tool লাগে।

Ahead-of-time compilation (program চলার আগেই পুরো native code বানানো) এখানে পাল্লা ভারী করে। Reflection-নির্ভর কোডে compiler জানে না কোন class বা method পরে নাম ধরে ডাকা হবে, তাই সবকিছু রেখে দিতে হয় বা আলাদা একটি তালিকা লিখে জানাতে হয়। JVM-এর native-image ধরনের tool এ কারণেই reflection-এর জন্য বাড়তি configuration চায় বলে জানা যায়। Compile time-এ তৈরি কোড সাধারণ কোড, তাই সেই সমস্যা নেই।

Python-এর জগতে মজার একটি মাঝামাঝি আছে: standard library-র dataclasses একটি class দেখে __init__-এর মতো method-এর source লেখা বানিয়ে চলার সময় compile করে বলে জানা যায়। অর্থাৎ run time-এ, কিন্তু একবার, class তৈরির সময়; প্রতিটি object-এ নয়। এই পর্বের ast উদাহরণও একই কৌশল।

সিদ্ধান্তের নিয়ম মোটামুটি এরকম: তথ্য compile-এর সময় জানা থাকলে (class-এর গঠন, ধ্রুবক) compile time বেছে নিন; তথ্য শুধু চলার সময় আসে (plugin, বাইরের config) হলে reflection; আর বাইরের লেখা থেকে কোড চালানো (eval) প্রায় কখনো নয়।

মূল উপলব্ধি: metaprogramming কখন চলবে, তা ঠিক করে কোন তথ্য কখন পাওয়া যায়। যত আগে চলে, তত দ্রুত আর নিরাপদ, কিন্তু তত কম নমনীয়।

অনুশীলন

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

  1. নকশা ও বাস্তবায়ন — max_into!: Haat-এ if একটি statement, তাই একটি expression macro দিয়ে “দুটির বড়টি” লেখা যায় না। একটি statement macro max_into!(dst, a, b) লিখুন, যা বড়টি dst-এ বসায়, আর a, b ঠিক একবার করে, বাঁ থেকে ডানে হিসাব করে। var calls = 0; fn next() -> Int { calls = calls + 1; return calls * 10; }, var x = 3; var big = 0; থাকলে max_into!(big, x + 5, next()); print(big); max_into!(big, next(), x); print(big); print(calls); কী ছাপবে? সরল সংস্করণ if a > b { dst = a; } else { dst = b; } কী ছাপত?

    Argument আগে নতুন নামে বাঁধুন: macro max_into!(dst, a, b) { let x = a; let y = b; if x > y { dst = x; } else { dst = y; } }. ব্যবহারকারীর নিজের x আছে, তাই hygiene জরুরি। Full নীতিতে প্রথম ডাক খোলে:

    {
        let x_1 = x + 5;
        let y_1 = next();
        if x_1 > y_1 {
            big = x_1;
        } else {
            big = y_1;
        }
    }

    ৮ বনাম ১০, তাই ১০; দ্বিতীয় ডাকে ২০ বনাম ৩, তাই ২০; next দুবার। Reference-এর run আর vm: 10, 20, 2. সরল সংস্করণ প্রতিটি argument দুবার বসায়: শর্তে next() দেয় ১০, ফলে আবার next() দেয় ২০; reference ছাপে 20, 40, 4. আর hygiene ছাড়া let x = x + 5; হতো, যা reference আটকায়: 9:13: error: 'x' is used before its declaration.

  2. ভুল খুঁজুন — mark কোথায় বসল? একজন expander-এর subst উল্টো ক্রমে লিখলেন: আগে parameter-এর জায়গায় argument বসালেন, তারপর পুরো ফলের সব নামে mark দিলেন। অংশ ৪-এর program (var i = 100; repeat!(3, { print(i); }); আর eid_order) full নীতিতে কী ছাপবে, আর ভুলটি কোথায়?

    এখন argument-এর i-ও i#1 হয়ে যায়, ঠিক macro-র counter-এর মতো। নিয়ম ৭৮.২-এর (ক) অনুযায়ী i#1 বাঁধে var i#1-কে, তাই rename-এর পরে লেখা হয় print(i_1);. ল্যাবে এই ভুল expander-এর ফল reference-এ: 0, 1, 2, 996. দ্বিতীয় দিকটি কাকতালীয়ভাবে ঠিক থেকেছে, প্রথমটি আবার ভেঙেছে, যদিও “full hygiene” চালু।

    ভুলের মূল: mark-এর অর্থ “এই নাম এই expansion-এর ছাঁচ থেকে এসেছে”. Argument ছাঁচ থেকে আসে না, আসে ব্যবহারকারীর কোড থেকে, তাই তার নামে নতুন mark পড়া চলবে না (নিয়ম ৭৮.১: “argument a-র নামে কোনো নতুন mark পড়ে না”)। সঠিক subst ছাঁচের node-এ mark দেয় আর argument-এর গাছ হুবহু কপি করে। এই ভুল ধরার test: ছাঁচের ভেতরের নামের সমান নাম argument-এ ব্যবহার করা।

  3. আউটপুট বলুন: Haat-এর বর্ধিত রূপে নিচের program কী ছাপবে? কোন macro কোন mark পাবে?
    macro twice!(e) => e + e;
    macro square!(x) => x * x;
    var calls = 0;
    fn next() -> Int { calls = calls + 1; return calls; }
    print(square!(twice!(next())));
    print(calls);

    বাইরে থেকে ভেতরে: square! আগে (#1), argument twice!(next()) না খুলে দুবার কপি: twice!(next()) * twice!(next()). তারপর বাঁয়েরটি #2, ডানেরটি #3, প্রতিটি next() + next(). Expander-এর log:

    0 square!#1 twice!(next()) * twice!(next())
    1 twice!#2 next() + next()
    1 twice!#3 next() + next()

    তৈরি কোড print((next() + next()) * (next() + next()));: formatter বন্ধনী বসিয়েছে, কারণ গাছে যোগ দুটি গুণের নিচে। হিসাব বাঁ থেকে ডানে: (১ + ২) × (৩ + ৪) = ২১. Reference-এর run আর vm: 21, 4.

  4. প্রমাণ — gensym যথেষ্ট নয়, full যথেষ্ট: (ক) একটি program দিয়ে দেখান যে শুধু gensym (macro-র ঘোষণার নাম বদলানো) hygiene নিশ্চিত করে না। (খ) প্রমাণ করুন: full নীতিতে, macro-র ছাঁচের একটি free নাম x#k, যার কোনো x#k ঘোষণা নেই, তৈরি লেখায় সবসময় top-level x-কে বাঁধে।

    (ক) প্রতি-উদাহরণ: অংশ ৫-এর eid_order. ছাঁচে কোনো ঘোষণা নেই, তাই gensym কিছুই বদলায় না, আর লেখা হয় return p + delivery(p);, যা local delivery বাঁধে। Reference-এর run ছাপে ৯৩৯, ঠিক উত্তর ৯৯৬. একটি প্রতি-উদাহরণই দাবিটি মিথ্যা প্রমাণ করে।

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

    1. (খ)-নিয়মে x#k খোঁজার সময় কোনো scope-এ x#k চাবি পাওয়া যায় না, তাই তার লেখা হয় x, আর অর্থ top-level x (Haat-এ macro শুধু top level-এ লেখা, তাই সংজ্ঞার জায়গায় দেখা যায় শুধু top level).
    2. লেখায় x নামটিকে মাঝখানে ঢাকতে পারে শুধু x নামের একটি local ঘোষণা। তিন রকম local ঘোষণা আছে: mark-ওয়ালা y#j (সবসময় নতুন, অনন্য নাম পায়, তাই লেখায় x নয়), ব্যবহারকারীর x (x top-level নাম আর x কোনো mark-ওয়ালা নামের ভিত্তি, তাই (গ) তাকে নতুন অনন্য নাম দেয়), আর ব্যবহারকারীর অন্য নাম (লেখায় x নয়)।
    3. Top-level ঘোষণা কখনো নতুন নাম পায় না, তাই top-level x-এর লেখা x-ই থাকে।
    4. ফলে x#k-এর জায়গা থেকে বাইরে খুঁজলে লেখায় x নামের প্রথম ঘোষণা top-level x. ∎

    সংখ্যায় মেলান: full নীতিতে লেখা হয় fn delivery_1(days: Int) আর return p + delivery(p);, আর reference ছাপে 996; ৪০০টি এলোমেলো program-এ দুটি স্বাধীন expander একমত।

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

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

ক্রমএকটি গাছ-ভিত্তিক hygienic macro expander একটি m!(a, b) ডাক যে ধাপে সামলায়, সেগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Parser একটি MacroCall node বানায়, argument-গুলো গাছ হিসেবে
  2. Expander বাইরের দিক থেকে প্রথম macro ডাকটি পায়
  3. ছাঁচ কপি করে parameter-এর জায়গায় argument-এর গাছ বসায়
  4. ছাঁচ থেকে আসা প্রতিটি নামে এই expansion-এর নতুন mark বসায়
  5. ফলটি আবার পড়ে ভেতরের macro ডাকগুলো খোলে
  6. Rename: mark-ওয়ালা ঘোষণা নতুন নাম পায়, free নাম top level বোঝায়

C-তে #define SQUARE(x) x*x থাকলে printf("%d", 100 / SQUARE(2+3)); কী ছাপবে?

  • 4
  • 25
  • 59
  • Compile error

একটি macro repeat!(n, body) ভেতরে var i = 0; ঘোষণা করে counter রাখে। ব্যবহারকারী লিখলেন var i = 100; repeat!(3, { print(i); });. Hygiene ছাড়া কী ছাপবে, আর কোন কৌশল এই নির্দিষ্ট সমস্যা সারায়?

  • 100, 100, 100 — কোনো কৌশল লাগে না
  • 0, 1, 2 — gensym দিয়ে macro-র counter-কে নতুন নাম দেওয়া
  • Redeclaration error — নাম বদলানো ছাড়া উপায় নেই
  • Loop কখনো থামে না — expansion-এর সীমা দেওয়া

Rust 1.82-এ fn delivery(t: i64) -> i64 top level-এ ৬০ দেয় (১০০০-এর নিচে)। macro_rules! with_delivery { ($a:expr) => { $a + delivery($a) }; }. একটি function-এর ভেতরে fn delivery(_d: i64) -> i64 { 3 } রেখে with_delivery!(936) ডাকলে কী ফল?

  • 996, কারণ macro_rules! পুরো hygienic
  • Compile error: দুটি delivery
  • 1872, কারণ $a দুবার যোগ হয়
  • 939, কারণ function-এর নাম ডাকের জায়গায় খোঁজা হয়

বাইরে থেকে ভেতরে খোলা একটি expander-এ macro square!(x) => x * x; আর macro twice!(e) => e + e;. print(twice!(square!(next())));-এ next() কতবার ডাকা হবে?

  • 4 বার
  • 1 বার
  • 2 বার
  • অসীম বার, expansion থামে না

C++-এ constexpr auto TABLE = make_table();, যেখানে make_table একটি constexpr function, আর static_assert(TABLE[1] == 996) আছে। Clang-এর -O0 -S assembly-তে কী দেখার কথা?

  • make_table-এর একটি call, program শুরুর সময়
  • একটি loop, যা টেবিল ভরে
  • শুধু ধ্রুবক মানগুলো, যেমন .quad 996
  • কিছুই না, কারণ static_assert compile থামিয়ে দেয়

Python-এ @rule("delivery") লেখা একটি decorator, যা function-কে একটি dictionary-তে নথিভুক্ত করে। Decorator-এর কোড কখন চলে?

  • Python compile-এর সময়, program চলার আগেই
  • def statement চলার সময় একবার, function তৈরির পরে
  • প্রতিবার function ডাকার সময়
  • কখনো না, যতক্ষণ না reflection দিয়ে ডাকা হয়

শব্দকোষ

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

মনে রাখুন

  1. স্তর আর সময়: metaprogramming কাজ করে লেখা, token, গাছ, type-মান বা চলমান program-এ; ওপরের স্তর compile time-এ, নিচেরটি run time-এ।
  2. লেখা নয়, গাছ: লেখা-বদলের macro গঠন হারায় (৫৯ বনাম ৪); গাছের macro precedence রাখে, কিন্তু argument কপি করলে double evaluation থাকে, তাই আগে নতুন নামে বাঁধুন।
  3. Hygiene-এর দুই দিক: macro-র ঘোষণা ব্যবহারকারীর নাম ধরতে পারে (gensym সারায়), আর macro-র free নাম ব্যবহারকারীর local-এ ধরা পড়তে পারে (সংজ্ঞার জায়গায় খোঁজা লাগে); mark আর rename দুটিই সারায়।
  4. ক্রম আর থামা: গাছের macro সাধারণত বাইরে থেকে ভেতরে খোলে আর ফল আবার পড়ে; নিজেকে ডাকা macro-র জন্য গভীরতার সীমা লাগে, আর C-র prescan ভিন্ন নিয়ম মানে।
  5. যাচাই: expansion চোখে দেখুন (-E, log), compile-time হিসাব assembly-তে খুঁজুন, আর তৈরি কোড আসল compiler বা reference-এ চালিয়ে দুটি স্বাধীন বাস্তবায়নে মেলান।

পরের পর্বে: পর্ব ৭৯-এ (Domain-specific language নকশা — internal বনাম external DSL) macro আর ছোট parser দিয়ে বাজারঘরের দামের নিয়মের জন্য একটি নিজস্ব ভাষা বানাবেন, আর সেটি Haat-এ অনুবাদ করে reference-এ চালাবেন।

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

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