এই পর্বে যা শিখবেন
- 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-এর পাঁচ স্তর
প্রতিটি বাক্সে কোডের একটি রূপ, আর সেই রূপের ওপর কাজ করে এমন পরিচিত উদাহরণ।
দুই প্রান্তের দুটি উদাহরণ। ওপরে 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);
| লেখা | |
| গাছ বা মান |
- Argument সংগ্রহ. Preprocessor
SQUARE(দেখে বন্ধনীর ভেতরের token-গুলো তোলে:2,+,3. এটি কোনো মান নয়, কোনো গাছও নয়, শুধু তিনটি টুকরো। - বসানো. সংজ্ঞার
x*x-এ প্রতিটিx-এর জায়গায় ওই তিনটি token. ফল2+3*2+3, আর লাইনটি হয়100 / 2+3*2+3: ঠিক এটিই-E-এর সত্যিকারের আউটপুটে আছে। - এবার compiler parse করে. Parser নতুন লেখাটি precedence মেনে পড়ে:
/আর*আগে, তাই গাছ হয়(100/2) + (3*2) + 3. Macro-র লেখক যে গঠন ভেবেছিলেন, তা preprocessor-এর ধাপেই হারিয়ে গেছে। - হিসাব. ৫০ + ৬ + ৩ = ৫৯. Run-এ ঠিক এই সংখ্যাই এসেছে। কোনো error বা warning নেই: ভুলটি নীরব।
- পুরোনো প্রতিকার. প্রতিটি parameter আর পুরো body বন্ধনীতে:
((2+3)*(2+3)), তাই ১০০ / ২৫ = ৪. প্রতিকার কাজ করে, কিন্তু প্রতিটি macro-লেখককে নিয়মটি মনে রাখতে হয়। - গাছের 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_.logExpander-এর মূল কাজ macro expansion: একটি MacroCall পেলে macro-র body (ছাঁচ)-এর একটি কপি বানানো, parameter-এর জায়গায় argument-এর গাছ বসানো। একটি বাড়তি কাজও করে: কপির প্রতিটি অন্য নামে একটি mark বসায়, এই expansion-এর ক্রমিক নম্বর দিয়ে। প্রথম expansion-এর i হয় i#1. # চিহ্নটি Haat-এর lexer কখনো তৈরি করে না, তাই mark-ওয়ালা নাম কখনো ব্যবহারকারীর লেখা নামের সঙ্গে গুলিয়ে যায় না।
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); });
| তৈরি কোড | |
| print(i)-এর i |
- ব্যবহারকারীর কোড. Top level-এ
var i = 100;. Block argument{ print(i); }-এরiমানে এই ১০০, কারণ ব্যবহারকারী তা-ই লিখেছেন যেখানে এটি দেখা যায়। - Expansion #1. ছাঁচ কপি হয়:
n-এর জায়গায়3,body;-এর জায়গায় পুরো block. ছাঁচের নিজের নাম পায় mark:i#1. Argument-এরimark পায় না, তাই গাছে এখন দুটি আলাদা নাম। - Hygiene নেই (none). Mark মুছে দিলে দুটি নাম আবার এক:
var i = 0;ভেতরের block-এ বাইরেরi-কে ঢেকে দেয়। Haat-এ এটি বৈধ shadowing (decision 15), তাই কোনো error নেই। - চালানো.
print(i)সবচেয়ে কাছেরiখোঁজে, আর পায় macro-র counter. Reference-এর run ছাপে0,1,2: C-রREPEAT-এর হুবহু একই ভুল। - Gensym. Mark-ওয়ালা ঘোষণা
i#1পায় একটি নতুন নামi_1, যা program-এ কোথাও নেই; তার সব ব্যবহারওi_1. ব্যবহারকারীরiঅপরিবর্তিত। - ঠিক ফল. এখন
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));
| তৈরি কোড | |
| delivery মানে |
- Macro-র সংজ্ঞা. Macro top level-এ লেখা। সেখানে
deliveryমানে বাজারঘরের চার্জের function: ১০০০ টাকার নিচে ৬০. Macro-র লেখক এটিই বুঝিয়েছেন। - ব্যবহারকারীর local. ঈদের অর্ডারের function-এ কেউ ডেলিভারির দিন গুনতে নিজের একটি
fn delivery(days: Int)রেখেছেন, যা ৩ ফেরত দেয়। ভেতরের block-এ এটি বৈধ shadowing. - Expansion #2.
amt-এর জায়গায়p(mark ছাড়া), আর ছাঁচেরdeliveryহয়delivery#2. এটি কোনো ঘোষণা নয়, একটি ব্যবহার: macro নিজেdelivery#2নামে কিছু ঘোষণা করেনি। - None আর gensym. Mark মুছলে
delivery(p)সবচেয়ে কাছেরdeliveryপায়: দিনের হিসাব। ফল ৯৩৬ + ৩ = ৯৩৯. Gensym শুধু macro-র ঘোষণার নাম বদলায়; এখানে কোনো ঘোষণা নেই, তাই একই ৯৩৯. Reference-এ দুটিরই সত্যিকারের run ৯৩৯ ছাপে। - Full hygiene. নিয়ম ৭৮.২:
delivery#2-এর জন্য mark #2-ওয়ালা কোনো ঘোষণা নেই, তাই এটি macro-র সংজ্ঞার জায়গার (top level)delivery. সেই নাম যেন লেখায় ঢাকা না পড়ে, তাই ব্যবহারকারীর local-কেdelivery_1নাম দেওয়া হয় (তার সব ব্যবহারসহ)। - ঠিক ফল. Reference-এর
runআরvm: ৯৩৬ + ৬০ =996,bazar.haat-এর প্রথম লাইনের সঙ্গে মেলে। নাম বদলেছে, কিন্তু program-এর অর্থ ব্যবহারকারী আর macro-লেখক দুজনের চোখেই একই রইল।
(ক) একটি ঘোষণা 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 নেই):
- নতুন নাম program-এর সব নামের তালিকা দেখে বানানো, তাই প্রতিটি নতুন নাম অনন্য; লেখায় কোনো নতুন নাম অন্য কোনো ঘোষণার নামের সঙ্গে মেলে না।
- ব্যবহারকারীর একটি নাম x (mark ছাড়া) rename-এর আগে যে ঘোষণা D-কে বাঁধত, (ক) অনুযায়ী D-ও mark ছাড়া। D-র নাম হয় অপরিবর্তিত, নয়তো (গ)-তে অনন্য নামে বদলানো (তার সব ব্যবহারসহ)। মাঝখানের কোনো x#k ঘোষণা নতুন অনন্য নাম পেয়েছে, তাই লেখায় x-কে আর ঢাকতে পারে না। ফলে x এখনো D-কে বাঁধে।
- ছাঁচের একটি free নাম x#k (খ) অনুযায়ী top-level x. লেখায় তার নাম x, আর x নামের যে local ঘোষণা মাঝখানে থাকতে পারত, (গ) তাকে নতুন নাম দিয়েছে। Top-level নাম কখনো বদলায় না। তাই x#k লেখাতেও top-level x-কে বাঁধে।
- ছাঁচের একটি বাঁধা নাম 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())));
| এই expansion | |
| গাছ এখন |
- প্রথম সাক্ষাৎ. Expander
print-এর ভেতরে ঢুকে প্রথমে পায়twice!. ভেতরেরsquare!(next())এখন শুধু তার argument-এর একটি গাছ, খোলা হয়নি। - twice! খোলে (#2).
e-এর জায়গায় পুরো গাছsquare!(next()), দুবার, দুটি আলাদা কপি। (#1 আগের লাইনেরsquare!পেয়েছিল।) - আবার পড়া, বাঁ দিক. ফলের ভেতরে macro আছে, তাই expander আবার হাঁটে। বাঁ দিকের
square!খোলে (#3):next() * next(). - ডান দিক. একইভাবে ডান দিকের
square!(#4). দুই কপি আলাদা mark পেয়েছে; এদের ভেতরে কোনো ঘোষণা থাকলে তারাও আলাদা নতুন নাম পেত। - শেষ. গাছে আর কোনো
MacroCallনেই। এবার rename, তারপর সাধারণ Haat হিসেবে resolver, type checker আর back end-এ যায়। - চালানো. বাঁ থেকে ডানে (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 আর IDE | Expansion জানতে হয়, নইলে নাম খোঁজা আর 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 চান, যা আপনি নিজে চালিয়ে মেলাবেন।
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 থেকে।
-
নকশা ও বাস্তবায়ন —
max_into!: Haat-এifএকটি statement, তাই একটি expression macro দিয়ে “দুটির বড়টি” লেখা যায় না। একটি statement macromax_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. -
ভুল খুঁজুন — 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-এ ব্যবহার করা। -
আউটপুট বলুন: 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), argumenttwice!(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. -
প্রমাণ — gensym যথেষ্ট নয়, full যথেষ্ট: (ক) একটি program দিয়ে দেখান যে শুধু gensym (macro-র ঘোষণার নাম বদলানো) hygiene নিশ্চিত করে না। (খ) প্রমাণ করুন: full নীতিতে, macro-র ছাঁচের একটি free নাম x#k, যার কোনো x#k ঘোষণা নেই, তৈরি লেখায় সবসময় top-level x-কে বাঁধে।
(ক) প্রতি-উদাহরণ: অংশ ৫-এর
eid_order. ছাঁচে কোনো ঘোষণা নেই, তাই gensym কিছুই বদলায় না, আর লেখা হয়return p + delivery(p);, যা localdeliveryবাঁধে। Reference-এর run ছাপে ৯৩৯, ঠিক উত্তর ৯৯৬. একটি প্রতি-উদাহরণই দাবিটি মিথ্যা প্রমাণ করে।(খ) প্রমাণের রূপরেখা:
- (খ)-নিয়মে x#k খোঁজার সময় কোনো scope-এ x#k চাবি পাওয়া যায় না, তাই তার লেখা হয় x, আর অর্থ top-level x (Haat-এ macro শুধু top level-এ লেখা, তাই সংজ্ঞার জায়গায় দেখা যায় শুধু top level).
- লেখায় x নামটিকে মাঝখানে ঢাকতে পারে শুধু x নামের একটি local ঘোষণা। তিন রকম local ঘোষণা আছে: mark-ওয়ালা y#j (সবসময় নতুন, অনন্য নাম পায়, তাই লেখায় x নয়), ব্যবহারকারীর x (x top-level নাম আর x কোনো mark-ওয়ালা নামের ভিত্তি, তাই (গ) তাকে নতুন অনন্য নাম দেয়), আর ব্যবহারকারীর অন্য নাম (লেখায় x নয়)।
- Top-level ঘোষণা কখনো নতুন নাম পায় না, তাই top-level x-এর লেখা x-ই থাকে।
- ফলে 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) ডাক যে ধাপে সামলায়, সেগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
- Parser একটি
MacroCallnode বানায়, argument-গুলো গাছ হিসেবে - Expander বাইরের দিক থেকে প্রথম macro ডাকটি পায়
- ছাঁচ কপি করে parameter-এর জায়গায় argument-এর গাছ বসায়
- ছাঁচ থেকে আসা প্রতিটি নামে এই expansion-এর নতুন mark বসায়
- ফলটি আবার পড়ে ভেতরের macro ডাকগুলো খোলে
- 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 চলার আগেই
defstatement চলার সময় একবার, function তৈরির পরে- প্রতিবার function ডাকার সময়
- কখনো না, যতক্ষণ না reflection দিয়ে ডাকা হয়
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- স্তর আর সময়: metaprogramming কাজ করে লেখা, token, গাছ, type-মান বা চলমান program-এ; ওপরের স্তর compile time-এ, নিচেরটি run time-এ।
- লেখা নয়, গাছ: লেখা-বদলের macro গঠন হারায় (৫৯ বনাম ৪); গাছের macro precedence রাখে, কিন্তু argument কপি করলে double evaluation থাকে, তাই আগে নতুন নামে বাঁধুন।
- Hygiene-এর দুই দিক: macro-র ঘোষণা ব্যবহারকারীর নাম ধরতে পারে (gensym সারায়), আর macro-র free নাম ব্যবহারকারীর local-এ ধরা পড়তে পারে (সংজ্ঞার জায়গায় খোঁজা লাগে); mark আর rename দুটিই সারায়।
- ক্রম আর থামা: গাছের macro সাধারণত বাইরে থেকে ভেতরে খোলে আর ফল আবার পড়ে; নিজেকে ডাকা macro-র জন্য গভীরতার সীমা লাগে, আর C-র prescan ভিন্ন নিয়ম মানে।
- যাচাই: expansion চোখে দেখুন (
-E, log), compile-time হিসাব assembly-তে খুঁজুন, আর তৈরি কোড আসল compiler বা reference-এ চালিয়ে দুটি স্বাধীন বাস্তবায়নে মেলান।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ৭৯ · Domain-specific language নকশা — internal বনাম external DSLপরবর্তী পর্ববাজারঘরের দামের নিয়মের ভাষা, Haat-এ অনুবাদ।
- প্রোগ্রামিং ভাষা ও কম্পাইলার · কোর্স হোম৮৬টি পর্ব১৪টি মডিউলের পুরো মানচিত্র আর Haat প্রজেক্টের পথ।
- পর্ব ৫৫ · Desugaring আর loweringভিত্তিcompiler-এর নিজের রূপান্তর, gensym আর hygiene-এর প্রথম দেখা।
- পর্ব ১২ · Scripting আর dynamic ভাষাভিত্তিreflection, introspection আর eval-এর বিপদ।
- C প্রোগ্রামিং · পর্ব ২৭ · প্রিপ্রসেসর ও ম্যাক্রোপাশের ট্র্যাক#define, #include আর conditional compilation-এর ব্যবহার।
- C++ · পর্ব ৩৯ · constexprপাশের ট্র্যাকcompile-এর সময় হিসাব, consteval আর static_assert.