এই পর্বে যা শিখবেন
- পর্ব ৩৪-এর নিয়ম থেকে একটি recursive type checker লেখা, প্রতিটি শাখার পাশে নিয়মের নাম রেখে
- Function type, call, argument-এর সংখ্যা, operator আর equality-র নিয়ম কোডে বসানো (decision 7, 11)
let-এর inference বনাম annotation,printআর Unit-এর নিয়ম, আরreturn-কে ρ-এর সঙ্গে মেলানো- Missing return-এর syntactic pass লেখা, আর Java, C ও Rust-এর সঙ্গে তুলনা
- সব error জমানো, cascade ঠেকানো, আর golden file, mutant ও differential test দিয়ে checker যাচাই
১ · Type checker কোথায় বসে, আর তার কাজের ছক
পর্ব ৫১-এ (Symbol table আর name resolution) Haat-এর প্রতিটি নাম তার ঘোষণার সঙ্গে জোড়া হয়েছে। কিন্তু price(2, true) তখনো কেউ আটকায়নি: নাম ঠিক, argument-এর সংখ্যাও ঠিক, শুধু দ্বিতীয় argument একটি সংখ্যা হওয়ার কথা ছিল। এই ভুল ধরে semantic analysis-এর দ্বিতীয় অংশ, type checker. নিয়মগুলো পর্ব ৩৪-এ (Typing rule আর type judgment) নামসহ লেখা হয়েছে (T-Var, T-Add, T-Call …); এখানে সেগুলো আবার শেখানো হবে না। কাজ হলো নিয়মগুলোকে চালানো যায় এমন কোডে নামানো, প্রতিটি শাখার পাশে নিয়মের নাম রেখে।
বাজারঘরের গুদামের একজন যাচাইকারীর কথা ভাবুন। প্রতিটি প্যাকেট খুলে তিনি ভেতরের জিনিস দেখে লেবেল লেখেন (“চাল”), তারপর অর্ডার স্লিপের সঙ্গে মেলান। স্লিপে “ডাল” থাকলে খাতায় লেখেন “তাক ৪, ঘর ২২: চাওয়া ডাল, পাওয়া চাল”, আর পরের প্যাকেটে যান; প্রথম ভুলেই গুদাম বন্ধ করেন না। লেবেল পড়াই না গেলে একটি “?” স্টিকার লাগান, যাতে পরে কেউ সেই প্যাকেট নিয়ে আবার অভিযোগ না করে। দিনের শেষে খাতাটি তাক আর ঘরের ক্রমে সাজিয়ে জমা দেন। Type checker-এ লেবেল হলো expr()-এর বের করা type, স্লিপ হলো চাওয়া type, খাতা error-এর তালিকা, আর “?” হলো None.
Reference-এর haat.py check-এ পুরো front end তিন ধাপ: parse → resolve → check, আর প্রতিটি ধাপ চলে কেবল আগের ধাপ পরিষ্কার হলে (decision 2). তাই checker ধরে নিতে পারে যে প্রতিটি নাম resolve হয়ে গেছে, আর শুধু type নিয়ে ভাবে। ইনপুট দুটি: AST, আর resolver-এর Resolution, যার uses টেবিল প্রতিটি নাম-ব্যবহারকে (id(node) দিয়ে) একটি Binding-এ পৌঁছে দেয়: AST না বদলে পাশের একটি dict, অর্থাৎ side table. আউটপুট ok, নয়তো সাজানো error-এর তালিকা। পথে checker প্রতিটি Binding-এর type ঘর ভরে, যা পর্ব ৫১-এ ফাঁকা ছিল। অর্থাৎ symbol table-ই এখানে পর্ব ৩৪-এর typing context Γ.
পর্ব ৩৪-এর দুই ধরনের typing judgment কোডে দুই ধরনের method হয়:
| পর্ব ৩৪-এ (গণিত) | checker-এ (কোড) | মানে |
|---|---|---|
| Γ ⊢ e : τ | expr(e) ফেরত দেয় τ | expression-এর type বের করা (synthesis) |
| premise “Γ ⊢ e : T”, যেখানে T আগে থেকে জানা | expect(e, T, expr(e)) | জানা type-এর সঙ্গে মেলানো (checking) |
| Γ(x) | res.uses[id(x)].type | নামের type, symbol table থেকে |
| Γ ⊢ρ s ⇒ Γ′ | stmt(s), যখন self.ret = ρ | statement যাচাই; Γ′ মানে নতুন Binding.type ভরা |
| returns(body) | always_returns(stmts) | missing return-এর syntactic যাচাই |
নিয়মগুলো syntax-directed (পর্ব ৩৪-এর অংশ ৪): node-এর ধরন দেখেই ঠিক হয় কোন নিয়ম খাটবে, তাই checker একটি সাধারণ recursive function. Synthesis আর checking-এর এই ভাগকে বলে bidirectional type checking; Haat-এর checker তার সবচেয়ে সরল রূপ, কারণ checking মানে শুধু “বের করা আর চাওয়া type সমান কি না”। নিচের ছবিতে দুই দিকের প্রবাহ দেখুন।
ছবি ৫২.১ — price(2, true) + 60-এ checker-এর দুই দিকের প্রবাহ
Γ-তে price : (Int, Int) -> Int. পুরু তির: expr() যে type ওপরে তোলে। ড্যাশ তির: expect() যে type চায়। লাল বাক্সে মেলেনি।
ছবির তিনটি জিনিস পুরো পর্বে ফিরে আসবে। এক, type তৈরি হয় পাতা থেকে গোড়ার দিকে। দুই, “চাই Int” আসে নিয়ম থেকে, এখানে T-Call-এর premise, যা আবার আসে price-এর লেখা function type থেকে। তিন, ভুল ধরা পড়ার পরও call তার ঘোষিত ফল-type ওপরে পাঠায়, তাই + ঠিকঠাক চলে আর দ্বিতীয় বার্তা আসে না।
(১) expr(e) ফেরত দেয় একটি type, অথবা None; None শুধু তখনই, যখন এই expression-এর ভেতরে বা আগে কোথাও একটি error জমা হয়েছে (অনুশীলন ৪-এ এর প্রমাণ)। (২) expect চুপ থাকে, যদি চাওয়া বা পাওয়া type-এর কোনোটি None হয়: একটি ভুলের জন্য একবারই বকা। (৩) Type mismatch জানানো হয় ভুল expression-এর শুরুর ঘরে (decision 24); call-এর argument-সংখ্যার ভুল callee-র শুরুতে।
২ · Expression — প্রতিটি শাখা একটি নিয়ম
এই পাতার Python ব্লকগুলো একটি সহায়ক module, haat_front.py, import করে: checker-এর আগের সব ধাপের সংক্ষিপ্ত রূপ, অর্থাৎ tokenize (পর্ব ৪৬), reference-এর একই নামের AST class আর type (পর্ব ৪৯), Parser (পর্ব ৪৭–৪৮), আর পর্ব ৫১-এর resolver, একই Binding, declare, lookup নিয়ে। সঙ্গে দুটি পরীক্ষা-সহায়ক, expr_env আর run_top, যারা অসম্পূর্ণ checker-কে চালাতে সাহায্য করে। এই parser প্রথম syntax error-এ থামে, reference থামে না (পর্ব ৫০, Parser-এর error recovery).
সহায়ক module haat_front.py দেখুন (ব্লকগুলো এটি import করে)
# haat_front.py — সহায়ক অংশ: type checker-এর আগের সব ধাপ, সংক্ষেপে।
# Reference-এর errors.py, tokens.py + lexer.py (পর্ব ৪৬), ast_nodes.py (পর্ব ৪৯),
# parser.py (পর্ব ৪৭–৪৮) আর resolver.py (পর্ব ৫১)-এর সংক্ষিপ্ত রূপ; নাম আর বার্তা reference-এর মতো।
# পার্থক্য: lexer আর parser প্রথম error-এ থামে (reference-এর parser recovery করে, পর্ব ৫০)।
import re
from dataclasses import dataclass, field, make_dataclass
class HaatError(Exception): # errors.py
def __init__(self, line, col, message):
super().__init__(message); self.line, self.col, self.message = line, col, message
def __str__(self): return f"{self.line}:{self.col}: error: {self.message}"
class HaatErrors(Exception): # all errors of one phase, sorted by position
def __init__(self, errors):
self.errors = sorted(errors, key=lambda e: (e.line, e.col))
super().__init__("\n".join(str(e) for e in self.errors))
@dataclass(frozen=True)
class Token:
kind: str; text: str; line: int; col: int
KW = "let var fn if else while return true false print".split()
OPS = dict(zip("== != <= >= && || -> + - * / % < > ! = ( ) { } , ; :".split(),
"EQ_EQ BANG_EQ LT_EQ GT_EQ AND_AND OR_OR ARROW PLUS MINUS STAR SLASH PERCENT LT GT "
"BANG EQ LPAREN RPAREN LBRACE RBRACE COMMA SEMI COLON".split()))
SPEC = (r'(?P<skip>//[^\n]*|[ \t\r\n]+)|(?P<IDENT>[A-Za-z_][A-Za-z0-9_]*)|(?P<INT>[0-9]+)'
r'|(?P<STRING>"(?:\\["\\n]|[^"\\\n])*")|(?P<op>==|!=|<=|>=|&&|\|\||->|[-+*/%<>!=(){},;:])|(?P<bad>.)')
def tokenize(src): # lexer stand-in: the first lexical error stops it
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 HaatError(line, col, "unterminated string literal" if t == '"' else f"unexpected character '{t}'")
if g == "skip": continue
kind = OPS[t] if g == "op" else t.upper() if g == "IDENT" and t in KW else g
toks.append(Token(kind, t, line, col))
return toks + [Token("EOF", "", src.count("\n") + 1, len(src) - src.rfind("\n"))]
NODES = {"Num": "value", "Str": "value", "Bool": "value", "Var": "name", "Unary": "op operand",
"Binary": "op left right", "Call": "callee args", "Param": "name type",
"Lambda": "params ret body", "Let": "name mutable type init", "Assign": "name value",
"If": "cond then else_", "While": "cond body", "Return": "value", "Print": "value",
"ExprStmt": "expr", "Block": "stmts", "FnDecl": "name params ret body"}
for _name, _fields in NODES.items(): # ast_nodes.py: same names and fields; line, col last
globals()[_name] = make_dataclass(_name, _fields.split() + ["line", "col"], eq=False)
Program = make_dataclass("Program", ["stmts"], eq=False)
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"))
def start(e): # where an expression begins (for error positions)
while isinstance(e, (Binary, Call)): e = e.left if isinstance(e, Binary) else e.callee
return e.line, e.col
INFIX = {"OR_OR": 10, "AND_AND": 20, "EQ_EQ": 30, "BANG_EQ": 30, "LT": 40, "LT_EQ": 40,
"GT": 40, "GT_EQ": 40, "PLUS": 50, "MINUS": 50, "STAR": 60, "SLASH": 60, "PERCENT": 60}
class Parser: # parser.py: recursive descent + Pratt
def __init__(self, tokens): self.toks, self.pos = tokens, 0
def peek(self, ahead=0): return self.toks[min(self.pos + ahead, len(self.toks) - 1)]
def check(self, kind): return self.peek().kind == kind
def advance(self):
tok = self.peek()
if tok.kind != "EOF": self.pos += 1
return tok
def match(self, kind): return self.advance() if self.check(kind) else None
def expect(self, kind, message):
if self.check(kind): return self.advance()
if kind == "SEMI" and self.pos > 0:
prev = self.toks[self.pos - 1]; self.fail(message, (prev.line, prev.col + len(prev.text)))
self.fail(message)
def fail(self, message, where=None):
line, col = where or (self.peek().line, self.peek().col)
raise HaatError(line, col, message)
def statements_until(self, end):
stmts = []
while not self.check(end) and not self.check("EOF"): stmts.append(self.statement())
return stmts
def statement(self):
kind = self.peek().kind
if kind in ("LET", "VAR"):
mutable = self.advance().kind == "VAR"; kw = "var" if mutable else "let"
name = self.expect("IDENT", f"expected variable name after '{kw}'")
ann = self.parse_type() if self.match("COLON") else None
self.expect("EQ", f"expected '=' after variable name in '{kw}'"); init = self.expression()
self.expect("SEMI", "expected ';' after variable declaration")
return Let(name.text, mutable, ann, init, name.line, name.col)
if kind == "FN" and self.peek(1).kind == "IDENT":
self.advance(); name = self.advance()
return FnDecl(name.text, *self.function_rest("expected '(' after function name"), name.line, name.col)
if kind == "IF": return self.if_stmt()
if kind == "WHILE":
kw = self.advance(); cond = self.expression()
return While(cond, self.block("expected '{' after while condition"), kw.line, kw.col)
if kind == "RETURN":
kw = self.advance(); value = None if self.check("SEMI") else self.expression()
self.expect("SEMI", "expected ';' after return"); return Return(value, kw.line, kw.col)
if kind == "PRINT":
kw = self.advance(); self.expect("LPAREN", "expected '(' after 'print'")
value = self.expression(); self.expect("RPAREN", "expected ')' after print argument")
self.expect("SEMI", "expected ';' after print statement"); return Print(value, kw.line, kw.col)
if kind == "LBRACE": return self.block("expected '{'")
first = self.peek(); e = self.expression()
if self.check("EQ"):
if not isinstance(e, Var): self.fail("invalid assignment target")
self.advance(); value = self.expression()
self.expect("SEMI", "expected ';' after assignment"); return Assign(e.name, value, e.line, e.col)
self.expect("SEMI", "expected ';' after expression"); return ExprStmt(e, first.line, first.col)
def block(self, message):
lb = self.expect("LBRACE", message); stmts = self.statements_until("RBRACE")
self.expect("RBRACE", "expected '}' at end of block"); return Block(stmts, lb.line, lb.col)
def if_stmt(self):
kw = self.advance(); cond = self.expression(); then = self.block("expected '{' after if condition")
else_ = None
if self.match("ELSE"):
else_ = self.if_stmt() if self.check("IF") else self.block("expected '{' or 'if' after 'else'")
return If(cond, then, else_, kw.line, kw.col)
def function_rest(self, lparen_message):
self.expect("LPAREN", lparen_message); params = []
if not self.check("RPAREN"):
while True:
p = self.expect("IDENT", "expected parameter name")
self.expect("COLON", f"expected ':' and a type after parameter '{p.text}'")
params.append(Param(p.text, self.parse_type(), p.line, p.col))
if not self.match("COMMA"): break
self.expect("RPAREN", "expected ')' after parameters")
ret = self.parse_type() if self.match("ARROW") else UNIT
return params, ret, self.block("expected '{' before function body")
def parse_type(self):
tok = self.peek()
if tok.kind == "IDENT":
if tok.text not in ("Int", "Bool", "Str", "Unit"): self.fail(f"unknown type '{tok.text}'")
self.advance(); return TypeName(tok.text)
if not self.match("LPAREN"): self.fail("expected a type")
params = [] if self.check("RPAREN") else [self.parse_type()]
while self.match("COMMA"): params.append(self.parse_type())
self.expect("RPAREN", "expected ')' in function type"); self.expect("ARROW", "expected '->' in function type")
return FnType(tuple(params), self.parse_type())
def expression(self, min_bp=0):
t = self.peek()
if t.kind not in ("INT", "STRING", "TRUE", "FALSE", "IDENT", "LPAREN", "MINUS", "BANG", "FN"):
self.fail("expected expression")
self.advance()
if t.kind == "INT": left = Num(int(t.text), t.line, t.col)
elif t.kind == "STRING":
left = Str(re.sub(r'\\(.)', lambda m: "\n" if m[1] == "n" else m[1], t.text[1:-1]), t.line, t.col)
elif t.kind in ("TRUE", "FALSE"): left = Bool(t.kind == "TRUE", t.line, t.col)
elif t.kind == "IDENT": left = Var(t.text, t.line, t.col)
elif t.kind in ("MINUS", "BANG"): left = Unary(t.text, self.expression(70), t.line, t.col)
elif t.kind == "FN": left = Lambda(*self.function_rest("expected '(' after 'fn'"), t.line, t.col)
else:
left = self.expression(); self.expect("RPAREN", "expected ')' after expression")
last_cmp = None
while True:
t = self.peek()
if t.kind == "LPAREN":
if min_bp > 80: return left
self.advance(); args = [] if self.check("RPAREN") else [self.expression()]
while self.match("COMMA"): args.append(self.expression())
self.expect("RPAREN", "expected ')' after arguments")
left = Call(left, args, *start(left)); continue
bp = INFIX.get(t.kind, -1)
if bp < min_bp: return left
if bp in (30, 40) and last_cmp == bp: self.fail("comparison operators cannot be chained")
self.advance()
left = Binary(t.text, left, self.expression(bp + 1), t.line, t.col); last_cmp = bp
@dataclass(eq=False)
class Binding: # resolver.py (পর্ব ৫১): one per declaration
name: str; kind: str; depth: int; slot: int; is_global: bool; owner: object
line: int; col: int; captured: bool = False
type: object = None # the type checker fills this in
@dataclass
class Scope:
names: dict = field(default_factory=dict); pending: set = field(default_factory=set)
@dataclass
class Resolution:
uses: dict; decls: dict # id(Var/Assign) -> Binding; id(Let/FnDecl/Param) -> Binding
def declared(stmts): return {s.name for s in stmts if isinstance(s, (Let, FnDecl))}
class Resolver: # resolver.py, slots/nslots left out
def __init__(self): self.scopes, self.errors, self.uses, self.decls, self.owner, self.depth = [], [], {}, {}, None, 0
def error(self, n, msg): self.errors.append(HaatError(n.line, n.col, msg))
def declare(self, n, name, kind):
scope = self.scopes[-1]
if name in scope.names: self.error(n, f"'{name}' is already declared in this scope")
b = Binding(name, kind, self.depth, 0, len(self.scopes) == 1, self.owner, n.line, n.col)
scope.names[name] = b; scope.pending.discard(name); self.decls[id(n)] = b
def lookup(self, n, name):
for scope in reversed(self.scopes):
if name in scope.names:
b = scope.names[name]
if not b.is_global and b.owner is not self.owner: b.captured = True
self.uses[id(n)] = b; return b
if name in scope.pending: return self.error(n, f"'{name}' is used before its declaration")
self.error(n, f"undefined variable '{name}'")
def program(self, prog):
self.scopes.append(Scope(pending=declared(prog.stmts)))
for s in prog.stmts:
if isinstance(s, FnDecl): self.declare(s, s.name, "fn")
for s in prog.stmts:
self.function(s) if isinstance(s, FnDecl) else self.stmt(s)
if self.errors: raise HaatErrors(self.errors)
return Resolution(self.uses, self.decls)
def block(self, stmts):
self.scopes.append(Scope(pending=declared(stmts)))
for s in stmts: self.stmt(s)
self.scopes.pop()
def stmt(self, s):
if isinstance(s, Let): self.expr(s.init); self.declare(s, s.name, "var" if s.mutable else "let")
elif isinstance(s, FnDecl): self.declare(s, s.name, "fn"); self.function(s)
elif isinstance(s, Assign):
self.expr(s.value); b = self.lookup(s, s.name)
if b and b.kind != "var":
what = {"let": f"'{s.name}': it is declared with 'let'", "param": f"parameter '{s.name}'",
"fn": f"function '{s.name}'"}[b.kind]
self.error(s, f"cannot assign to {what}")
elif isinstance(s, If):
self.expr(s.cond); self.block(s.then.stmts)
if isinstance(s.else_, If): self.stmt(s.else_)
elif s.else_ is not None: self.block(s.else_.stmts)
elif isinstance(s, While): self.expr(s.cond); self.block(s.body.stmts)
elif isinstance(s, Return):
if self.owner is None: self.error(s, "'return' outside of a function")
if s.value is not None: self.expr(s.value)
elif isinstance(s, Print): self.expr(s.value)
elif isinstance(s, ExprStmt): self.expr(s.expr)
elif isinstance(s, Block): self.block(s.stmts)
def function(self, f):
saved = self.owner, self.depth; self.owner, self.depth = f, self.depth + 1
self.scopes.append(Scope(pending=declared(f.body.stmts)))
for p in f.params: self.declare(p, p.name, "param")
for s in f.body.stmts: self.stmt(s)
self.scopes.pop(); self.owner, self.depth = saved
def expr(self, e):
if isinstance(e, Var): self.lookup(e, e.name)
elif isinstance(e, Unary): self.expr(e.operand)
elif isinstance(e, Binary): self.expr(e.left); self.expr(e.right)
elif isinstance(e, Call):
self.expr(e.callee)
for a in e.args: self.expr(a)
elif isinstance(e, Lambda): self.function(e)
def front(src): # lexer + parser + resolver; returns (program, resolution)
toks = tokenize(src); p = Parser(toks); stmts = p.statements_until("EOF")
program = Program(stmts)
return program, Resolver().program(program)
PRINTABLE = (INT, BOOL, STR) # decision 8: what print accepts; also what == compares
def fn_type(f): return FnType(tuple(p.type for p in f.params), f.ret)
def expr_env(decls, src): # test helper: declarations on line 1, the expression on line 2
program, res = front(decls + "\n" + src + ";")
for s in program.stmts[:-1]: res.decls[id(s)].type = s.type # annotated lets: Γ filled by hand
return program.stmts[-1].expr, res
def run_top(TC, src): # test helper until block 3 exists: hoisted function
program, res = front(src); tc = TC(res) # types by hand, then only top-level non-fn statements
for s in program.stmts:
if isinstance(s, FnDecl): res.decls[id(s)].type = fn_type(s)
for s in program.stmts:
if not isinstance(s, FnDecl): tc.stmt(s)
return sorted(tc.errors, key=lambda e: (e.line, e.col))প্রথম ব্লক reference-এর typechecker.py-র expr, binary আর expect; প্রতিটি শাখার মন্তব্যে পর্ব ৩৪-এর নিয়মের নাম। চারটি ব্লক একই namespace ভাগ করে (পরের ব্লক আগে চালালে আগেরগুলো নিজে চলে নেবে), আর পরের ব্লকগুলো class TypeChecker(TypeChecker) লিখে class-টি বাড়ায়। পরীক্ষায় প্রথম লাইনের তিনটি ঘোষণা Γ বানায় (qty : Int, vip : Bool, name : Str), আর প্রতিটি expression দ্বিতীয় লাইনে, যাতে অবস্থান reference-এর সঙ্গে সরাসরি মেলানো যায়।
from haat_front import * # lexer, parser, AST, resolver (Binding), types, start()
class TypeChecker: # typechecker.py: expressions (rule names from পর্ব ৩৪)
def __init__(self, res): self.res, self.errors, self.ret = res, [], None
def error(self, pos, message): self.errors.append(HaatError(*pos, message))
def expect(self, e, want, found): # None means "already reported": stay silent
if found is not None and want is not None and found != want:
self.error(start(e), f"type mismatch: expected {want}, found {found}")
def expr(self, e): # returns the type, or None after an error
if isinstance(e, (Num, Str, Bool)): # T-Int, T-Str, T-Bool
return {Num: INT, Str: STR, Bool: BOOL}[type(e)]
if isinstance(e, Var): # T-Var: Γ(x) = Binding.type
b = self.res.uses.get(id(e)); return b.type if b else None
if isinstance(e, Unary): # T-Neg, T-Not
want = INT if e.op == "-" else BOOL
self.expect(e.operand, want, self.expr(e.operand)); return want
if isinstance(e, Binary): return self.binary(e)
if isinstance(e, Call): return self.call(e) # T-Call: next block
def binary(self, e): # decision 11: operand types
lt, rt = self.expr(e.left), self.expr(e.right)
if e.op in ("&&", "||"): # T-And, T-Or
self.expect(e.left, BOOL, lt); self.expect(e.right, BOOL, rt); return BOOL
if e.op in ("==", "!="): # T-Eq
if lt is not None and lt not in PRINTABLE:
self.error(start(e.left), f"operator '{e.op}' cannot compare values of type {lt}")
return BOOL
self.expect(e.right, lt, rt); return BOOL
if e.op == "+" and lt == STR: # T-Concat: the left decides
self.expect(e.right, STR, rt); return STR
self.expect(e.left, INT, lt); self.expect(e.right, INT, rt) # T-Add, T-Arith, T-Cmp
return BOOL if e.op in ("<", "<=", ">", ">=") else INT
D = 'let qty: Int = 2; let vip: Bool = true; let name: Str = "Rahim";' # line 1: Γ
for src in ["qty * 520 + 60", 'name + "!"', "qty + vip", '"a" < "b"', "-vip",
"qty == name", "!(qty > 0) || vip", 'vip + 1 == "x"']:
e, res = expr_env(D, src); tc = TypeChecker(res) # src is on line 2
print(f"{src:18} : {tc.expr(e)}", *tc.errors, sep="\n ")আসল আউটপুট (ব্রাউজারের Python):
qty * 520 + 60 : Int
name + "!" : Str
qty + vip : Int
2:7: error: type mismatch: expected Int, found Bool
"a" < "b" : Bool
2:1: error: type mismatch: expected Int, found Str
2:7: error: type mismatch: expected Int, found Str
-vip : Int
2:2: error: type mismatch: expected Int, found Bool
qty == name : Bool
2:8: error: type mismatch: expected Int, found Str
!(qty > 0) || vip : Bool
vip + 1 == "x" : Bool
2:1: error: type mismatch: expected Int, found Bool
2:12: error: type mismatch: expected Int, found Str
প্রথম দুটি সরল: T-Arith/T-Add দিয়ে Int, আর বাঁ পাশ Str বলে T-Concat. qty + vip-এ বাঁ পাশ Int, তাই ডান পাশেও Int চাওয়া হলো; পাওয়া গেল Bool, error vip-এর শুরুতে, 2:7, অথচ ফল তবু Int, কারণ T-Add-এর ফল সবসময় Int. "a" < "b"-এ দুটি error, কারণ দুটি operand-ই আলাদা করে ভুল (decision 11: Str-এর কোনো ক্রম নেই)। -vip-এর error operand-এর শুরুতে, 2:2-এ। শেষটিতে নিয়মগুলো স্তরে স্তরে কাজ করে: vip + 1-এ একটি ভুল, তবু ফল Int, তাই == "x"-এ আবার Int চাওয়া হয় আর "x"-এ দ্বিতীয় ভুল; দুটিই আসল ভুল। আটটি expression প্রথম লাইনের ঘোষণাসহ ফাইলে লিখে reference-এর check চালানো হয়েছে: বার্তা আর অবস্থান অক্ষরে অক্ষরে এক।
এবার পুরো “নিয়ম থেকে কোড” মানচিত্র: পর্ব ৩৪-এর প্রতিটি নিয়ম কোডের কোথায়, কী যাচাই করে, কোন বার্তা দেয়। Reference-এর কোডে এর বাইরে আর কিছু নেই।
| নিয়ম (পর্ব ৩৪) | কোডের শাখা | যা যাচাই হয় | বার্তা |
|---|---|---|---|
| T-Int, T-Str, T-Bool | expr: literal | কিছু না (axiom) | — |
| T-Var | expr: Var | Γ(x) = Binding.type | — (জানা না থাকলে None) |
| T-Neg, T-Not | expr: Unary | operand Int বা Bool | type mismatch |
| T-And, T-Or | binary: && || | দুই পাশ Bool | type mismatch |
| T-Eq | binary: == != | বাঁ পাশ Int/Bool/Str; ডান পাশ বাঁয়ের সমান | operator '==' cannot compare values of type T; type mismatch |
| T-Concat | binary: +, বাঁ পাশ Str | ডান পাশ Str | type mismatch |
| T-Add, T-Arith, T-Cmp | binary: বাকি সব | দুই পাশ Int | type mismatch |
| T-Call | call | callee function কি না; argument-এর সংখ্যা; প্রতিটি argument | cannot call a value of type T; expected n arguments, found m; type mismatch |
| T-Fn | expr: Lambda → function | দেহ, ρ = লেখা ফেরত-type | missing return … anonymous function … |
| T-Let, T-LetAnn | stmt: Let | annotation থাকলে মান তার সঙ্গে | type mismatch |
| T-Assign | stmt: Assign | মান = variable-এর type | type mismatch |
| T-If, T-While | stmt: If, While | শর্ত Bool | type mismatch |
| T-Return | stmt: Return | মান = ρ (return; মানে Unit) | type mismatch |
| T-Print | stmt: Print | Int, Bool বা Str | cannot print a value of type T |
T-Block; e; | stmt: Block, ExprStmt | ভেতরের statement; e;-এ যেকোনো type | — |
| T-FnDecl + returns(body) | stmt: FnDecl → function, always_returns | দেহ, ρ = R; প্রতিটি পথে return | missing return: not every path of function 'f' returns T |
তিনটি নকশা-সিদ্ধান্ত কোডে সরাসরি চোখে পড়ে। +-এর দুটি নিয়মের মধ্যে বাছাই করে বাঁ পাশ (decision 11), তাই "a" + 1-এ বার্তা “expected Str, found Int” আর 1 + "a"-এ “expected Int, found Str”. T-Eq-এর শর্ত τ ∈ {Int, Bool, Str} একটি আগাম পরীক্ষা: বাঁ পাশ function বা Unit হলে আলাদা বার্তা, ডান পাশ আর দেখা হয় না। আর কোথাও কোনো implicit conversion নেই; থাকলে প্রতিটি শাখায় “রূপান্তর করা যায় কি?” প্রশ্ন যোগ হতো, আর পর্ব ৩৪-এর অনন্যতার প্রমাণ ভেঙে যেত।
৩ · Function type আর call — argument গোনা, মেলানো আর ফল
Haat-এ function প্রথম শ্রেণির মান, তাই তার type-ও একটি সাধারণ মান: FnType(params, ret), লেখায় (Int, Int) -> Int (decision 7). এটি একটি frozen dataclass, তাই দুটি function type-এর তুলনা পাইথনের ==, অংশে অংশে: অর্থাৎ structural equivalence. তাই shop.haat-এ (অংশ ৮) apply(coupon, 800) চলে: parameter চায় (Int) -> Int, আর নামহীন coupon-এর লেখা type ঠিক তাই।
T-Call কোডে চারটি ধাপ, এই ক্রমে (reference-এর call, পরের ব্লকে):
- Type জোগাড়: আগে callee, তারপর বাঁ থেকে ডানে প্রতিটি argument (decision 12-এর ক্রমে); callee ভুল হলেও argument-এর ভেতরের ভুল হারায় না।
- Callee কি function? Type
Noneহলে চুপচাপNone; function type না হলেcannot call a value of type Int, callee-র শুরুতে, আর ফলNone. - সংখ্যা: argument-এর সংখ্যা parameter-এর সংখ্যার (arity) সমান না হলে
expected 2 arguments, found 1(১ হলে একবচন), অবস্থান callee-র শুরু (decision 24). - জোড়ায় জোড়ায়:
zipদিয়েexpect; সংখ্যা না মিললে যতগুলো জোড়া আছে, ততগুলোই মেলানো হয়।
শেষে ফল লেখা ফেরত-type ft.ret, argument-এ ভুল থাকলেও। নিচের stepper-এ price(2, true) + 60 যাচাইয়ের প্রতিটি ধাপ; method-এর পথ আর মানগুলো পাতার checker-এ একটি tracing wrapper লাগিয়ে আসল run থেকে, শেষের বার্তা reference-এর check-এর সত্যিকারের আউটপুট।
1fn price(qty: Int, unit: Int) -> Int {2 return qty * unit;3}4let first = price(2, true) + 60;5print(first);
| পথ (method) | |
| এই ধাপের ফল | |
| জমা error |
- Γ তৈরি.
program-এর প্রথম pass সব top-level function-এর type বসায়:price : (Int, Int) -> Int, লেখা annotation থেকে। দ্বিতীয় pass-এprice-এর দেহ যাচাই হয়:qty * unitT-Arith দিয়ে Int, আর ρ = Int, তাই T-Return ঠিক আছে। - Let-এর মান.
stmt(Let)মানটির জন্যexprডাকে। মান একটিBinary(+, অবস্থান 4:28), তাইbinary(). সে আগে বাঁ পাশ দেখে, কারণ+-এর নিয়ম বাছাই বাঁ পাশের type-এর ওপর নির্ভর করে। - Callee. বাঁ পাশ একটি
Call(অবস্থান 4:13, callee-র শুরু)।call()প্রথমে calleeprice-এর type চায়: T-Var, অর্থাৎusesটেবিল থেকেBinding, আর তারtypeঘরে প্রথম ধাপে বসানো function type. - Argument-গুলো. বাঁ থেকে ডানে:
2T-Int দিয়ে Int,trueT-Bool দিয়ে Bool. এখনো কোনো তুলনা হয়নি; শুধু type জোগাড় হলো। - দুটি আগাম পরীক্ষা. Callee-র type
Noneনয়, আর এটি একটিFnType; argument ২টি, parameter-ও ২টি। তাই “cannot call” বা “expected … arguments” কোনো বার্তা নেই। - জোড়ায় জোড়ায় মেলানো. প্রথম জোড়া: চাই Int, পেল Int, ঠিক। দ্বিতীয় জোড়া: চাই Int, পেল Bool.
expecterror জমা করেstart(true)= 4:22-এ, অর্থাৎ ভুল argument-এর শুরুতে, callee বা(-এ নয়। - ফল তবু Int.
call()ফেরত দেয়ft.ret= Int. এবারbinary()ডান পাশ দেখে:60Int. বাঁ পাশ Str নয়, তাই T-Add: দুই পাশ Int চাওয়া হলো, পাওয়াও গেল, ফল Int. কোনো দ্বিতীয় বার্তা নেই। - Γ বাড়ে. T-Let:
first : Int, তারBinding.type-এ লেখা হলো। লাইন ৫-এরprint(first)T-Print-এর শর্ত মানে। শেষে একটি error, আর reference-এরcheckএই ফাইলে ঠিক এই একটি লাইন ছাপে।
ধাপ ৭ একটি নকশা-পছন্দ। Argument-এ ভুল পেলে call None ফেরত দিলে first-এর type হতো None, আর পরের সব first-ব্যবহার চুপচাপ পার পেত, সত্যিকারের নতুন ভুলসহ। ঘোষিত ফল-type ফেরত দিলে এই ঝুঁকি নেই, কারণ ফল কী হবে তা ঘোষণাই বলে দিয়েছে।
৪ · Statement — Γ ভরে ওঠে, return মেলে ρ-এর সঙ্গে
Statement-এর type থাকে না; সে শুধু “ঠিক” বা “ভুল”। তবে পর্ব ৩৪-এর Γ ⊢ρ s ⇒ Γ′ অনুযায়ী সে Γ বাড়ায় আর ρ-এর সঙ্গে return মেলায়। কোডে Γ বাড়ানো মানে Binding.type ভরা (কোন নাম কোথায় দেখা যায়, resolver আগেই ঠিক করেছে, তাই Γ-এর কপি লাগে না), আর ρ হলো self.ret, top level-এ None. দ্বিতীয় ব্লক reference-এর call আর stmt; পরীক্ষার ফাইল order.haat ইচ্ছা করে ভুলে ভরা:
// বাজারঘর: ভুলে ভরা একটি অর্ডার
fn price(qty: Int, unit: Int) -> Int { return qty * unit; }
let first = price(2, true) + 60;
var total: Int = "0";
if first { total = total + price(1); }
print(price);
let n = 3;
n(1);
let note = "Taka " + first;
class TypeChecker(TypeChecker): # typechecker.py: calls and statements
def call(self, e): # T-Call, decision 7
ft, arg_types = self.expr(e.callee), [self.expr(a) for a in e.args] # callee, then args
if ft is None: return None
if not isinstance(ft, FnType):
self.error(start(e.callee), f"cannot call a value of type {ft}"); return None
if len(e.args) != (n := len(ft.params)):
self.error((e.line, e.col), f"expected {n} argument{'' if n == 1 else 's'}, found {len(e.args)}")
for a, want, found in zip(e.args, ft.params, arg_types): self.expect(a, want, found)
return ft.ret # the declared result type
def stmt(self, s):
if isinstance(s, Let): # T-Let, T-LetAnn
t = self.expr(s.init)
if s.type is not None: self.expect(s.init, s.type, t); t = s.type
self.res.decls[id(s)].type = t # Γ, x : τ
elif isinstance(s, FnDecl): # T-FnDecl: block 3
self.res.decls[id(s)].type = fn_type(s); self.function(s, f"function '{s.name}'")
elif isinstance(s, Assign): # T-Assign
b = self.res.uses.get(id(s)); self.expect(s.value, b.type if b else None, self.expr(s.value))
elif isinstance(s, (If, While)): # T-If, T-While
self.expect(s.cond, BOOL, self.expr(s.cond))
for part in ([s.then, s.else_] if isinstance(s, If) else [s.body]):
if part is not None: self.stmt(part)
elif isinstance(s, Return): # T-Return, decision 22
t = UNIT if s.value is None else self.expr(s.value)
if t is not None and self.ret is not None and t != self.ret:
pos = (s.line, s.col) if s.value is None else start(s.value)
self.error(pos, f"type mismatch: expected {self.ret}, found {t}")
elif isinstance(s, Print): # T-Print, decision 8
t = self.expr(s.value)
if t is not None and t not in PRINTABLE: self.error(start(s.value), f"cannot print a value of type {t}")
elif isinstance(s, ExprStmt): self.expr(s.expr) # any type; the value is dropped
elif isinstance(s, Block): # T-Block
for inner in s.stmts: self.stmt(inner)
for err in run_top(TypeChecker, open("order.haat", encoding="utf-8").read()): print(err)আসল আউটপুট (ব্রাউজারের Python):
3:22: error: type mismatch: expected Int, found Bool
4:18: error: type mismatch: expected Int, found Str
5:4: error: type mismatch: expected Bool, found Int
5:28: error: expected 2 arguments, found 1
6:7: error: cannot print a value of type (Int, Int) -> Int
8:1: error: cannot call a value of type Int
9:22: error: type mismatch: expected Str, found Int
সাতটি লাইন, সাতটি নিয়ম। 3:22: T-Call-এর argument. 4:18: T-LetAnn, annotation Int কিন্তু মান "0". 5:4: T-If, শর্ত একটি Int; Haat-এ C বা Python-এর মতো “শূন্য নয় মানে সত্য” নেই। 5:28: price(1), একটি argument কম, অবস্থান callee-র শুরু। 6:7: function ছাপা যায় না (decision 8). 8:1: Int-কে ডাকা যায় না। 9:22: বাঁ পাশ Str বলে T-Concat. run_top শুধু top-level statement চালিয়েছে (function-এর দেহ যাচাই আসবে পরের ব্লকে), তবু পুরো ফাইলে reference-এর check ঠিক এই সাতটি লাইনই দেয়।
Let: inference বনাম annotation. let x = e;-এ x-এর type শুধু e-এর type (T-Let). এটি type inference-এর সবচেয়ে সরল রূপ: কোনো অজানা চলক বা সমীকরণ নেই, কারণ Haat-এ প্রতিটি parameter আর ফেরত-type লেখা থাকে; পর্ব ৩৫-এর (Hindley–Milner) unification লাগত কেবল সেগুলো না লেখা থাকলে। let x: T = e;-এ (type annotation, T-LetAnn) আগে e মেলানো হয় T-র সঙ্গে, তারপর x পায় T, মিলুক বা না মিলুক। তাই var total: Int = "0"; ভুল হলেও total Int থাকে, আর লাইন ৫-এর total + price(1) নতুন অভিযোগ তোলে না: লেখা ঘোষণাকে বিশ্বাস করা cascade কমানোর প্রথম কৌশল। Annotation ছাড়া মান ব্যর্থ হলে নামটির type None, আর পরে সেই নাম যেখানেই আসুক, চুপ।
Assignment আর return. x = e;-এ checker শুধু type মেলায়; x যে var, তা resolver আগেই দেখেছে (decision 19). “কে বদলাতে পারে” নামের প্রশ্ন, “কী রাখা যায়” type-এর প্রশ্ন। return e;-এ e মেলে self.ret-এর সঙ্গে, আর return; মানে Unit; অবস্থান মানের শুরু, মান না থাকলে return শব্দ। যেমন fn f() -> Int { return; } দেয় 1:17: error: type mismatch: expected Int, found Unit (reference-এর নিজের test থেকে)।
Print আর Unit. print একটি statement (decision 8), আর এর argument হতে হবে Int, Bool বা Str. Unit-এর মান বোঝায় “কিছু নেই”: return; বা দেহের শেষে পৌঁছালে ফল Unit (decision 22). Unit-এর কোনো literal নেই, তবে Unit মান রাখা যায় (let u = f();), শুধু ছাপা আর == দিয়ে তুলনা চলে না। -> T না লিখলে ফেরত-type Unit, নামওয়ালা হোক বা নামহীন (decision 23). আর e;-এ e-এর যেকোনো type চলে, মানটি ফেলে দেওয়া হয়।
৫ · Function, lambda আর পুরো program — দুই pass আর ρ-এর বদল
বাকি তিনটি অংশ: function-এর দেহ, নামহীন function (lambda), আর পুরো program. তৃতীয় ব্লক reference-এর function, program আর always_returns, সঙ্গে check(src): পুরো front end চালিয়ে ঠিক সেই লেখা ফেরত দেয়, যা python haat.py check ছাপে।
def always_returns(stmts): # decision 21: a syntactic pass, no types involved
for s in stmts:
if isinstance(s, Return): return True
if isinstance(s, Block) and always_returns(s.stmts): return True
if isinstance(s, If) and s.else_ is not None:
other = [s.else_] if isinstance(s.else_, If) else s.else_.stmts
if always_returns(s.then.stmts) and always_returns(other): return True
return False # a while never counts, not even `while true`
class TypeChecker(TypeChecker): # typechecker.py: functions and the whole program
def expr(self, e): # T-Fn: fn(x: Int) -> Int { … }
if isinstance(e, Lambda): self.function(e, "anonymous function"); return fn_type(e)
return super().expr(e)
def function(self, f, what): # T-FnDecl, T-Fn
for p in f.params: self.res.decls[id(p)].type = p.type # Γ, x1 : T1, …, xn : Tn
saved, self.ret = self.ret, f.ret # ρ = R inside this body
for s in f.body.stmts: self.stmt(s)
self.ret = saved
if f.ret != UNIT and not always_returns(f.body.stmts):
self.error((f.line, f.col), f"missing return: not every path of {what} returns {f.ret}")
def program(self, prog):
for s in prog.stmts: # pass 1: hoisted top-level functions get their types
if isinstance(s, FnDecl): self.res.decls[id(s)].type = fn_type(s)
for s in prog.stmts: self.stmt(s) # pass 2: every statement, top to bottom
if self.errors: raise HaatErrors(self.errors) # all errors, sorted (decision 2)
def check(src): # what `python haat.py check` prints
try:
program, res = front(src); TypeChecker(res).program(program); return "ok"
except (HaatError, HaatErrors) as err: return str(err)
for name in ("bazar.haat", "err_types.haat", "order.haat"):
print(f"== {name}\n" + check(open(name, encoding="utf-8").read()))আসল আউটপুট (ব্রাউজারের Python):
== bazar.haat
ok
== err_types.haat
2:14: error: type mismatch: expected Int, found Bool
3:13: error: type mismatch: expected Int, found Str
4:4: error: type mismatch: expected Bool, found Int
5:4: error: missing return: not every path of function 'half' returns Int
8:7: error: expected 1 argument, found 2
9:15: error: type mismatch: expected Str, found Int
10:8: error: type mismatch: expected Int, found Bool
11:14: error: type mismatch: expected Str, found Int
12:7: error: cannot print a value of type Unit
== order.haat
3:22: error: type mismatch: expected Int, found Bool
4:18: error: type mismatch: expected Int, found Str
5:4: error: type mismatch: expected Bool, found Int
5:28: error: expected 2 arguments, found 1
6:7: error: cannot print a value of type (Int, Int) -> Int
8:1: error: cannot call a value of type Int
9:22: error: type mismatch: expected Str, found Int
bazar.haat পরিষ্কার। err_types.haat reference-এর নিজের ভুলের উদাহরণ-ফাইল, আর এর নয়টি লাইন reference-এর test (TypeCheckerTest.test_errors) আর check-এর আউটপুটের সঙ্গে অক্ষরে অক্ষরে এক। দুটি বার্তা শুধু এই ব্লকেই সম্ভব: 5:4-এ missing return, আর 12:7-এ Unit ছাপার চেষ্টা। print_nothing ঘোষিত ফাইলের শেষ লাইনে, অথচ লাইন ১২-তে তার type জানা: প্রথম pass-এর কাজ। আর order.haat-এর সাতটি লাইন আগের ব্লকের মতোই, কারণ price-এর দেহে ভুল নেই।
দুই pass. program প্রথমে শুধু top-level fn-গুলোর type বসায়, তারপর সব statement লেখার ক্রমে যাচাই করে: resolver-এর hoisting-এর (decision 17) type-সংস্করণ। তাই দুটি top-level function একে অপরকে ডাকতে পারে (reference-এর mutual.haat). Nested function hoisted নয়; তার type বসে stmt(FnDecl)-এ, দেহের ঠিক আগে, তাই সে নিজেকে ডাকতে পারে।
একটি সূক্ষ্ম প্রশ্ন: function-এর দেহ একটি top-level variable ব্যবহার করলে তার type কি তখন জানা? হ্যাঁ: দেহ শুধু ফাইলে function-এর আগে ঘোষিত top-level variable দেখতে পারে (decision 18), আর checker ফাইলের ক্রমে চলে, তাই সেই let-এর Binding.type আগেই ভরে গেছে। দুই pass-এর নিয়ম মিলে নিশ্চয়তা দেয়: কোনো নামের type পড়ার আগে লেখা হয়ে যায় (অনুশীলন ৪)।
ρ বদলানো আর ফিরিয়ে আনা. function parameter-এর type বসায়, পুরোনো self.ret রেখে নতুনটি বসায় f.ret, দেহ যাচাই করে, তারপর পুরোনোটি ফিরিয়ে আনে: পর্ব ৩৪-এর T-FnDecl-এর ছোট অক্ষর R. তাই shop.haat-এর coupon lambda-র return মেলে lambda-র Int-এর সঙ্গে, যদিও lambda-টি top level-এ। Lambda (T-Fn) একটি expression; ফল তার লেখা fn_type. Reference শাখাটি সরাসরি expr-এ রাখে, এখানে তৃতীয় ব্লক expr-কে বাড়িয়ে যোগ করেছে; আচরণ একই। দেহ যাচাইয়ের পরে আসে missing return-এর প্রশ্ন, পরের অংশের বিষয়।
৬ · Missing return — type ছাড়া একটি syntactic pass
পর্ব ৩৪-এর T-FnDecl-এর তৃতীয় premise returns(body) type-এর নিয়ম নয়, আর কোডে তা স্পষ্ট: always_returns কোনো type বা self.res ছোঁয় না, শুধু statement-এর গঠন দেখে। তাই missing return-এর যাচাই একটি আলাদা ছোট pass, যা দেহ যাচাইয়ের পরে চলে। নিয়মটি (decision 21): একটি statement-তালিকা “return করে”, যদি তাতে থাকে (ক) একটি return, (খ) একটি block যা return করে, বা (গ) একটি if যার else আছে আর দুই শাখাই return করে। else if-এ else_ একটি If, তাই কোড সেটিকে এক-উপাদানের তালিকায় মুড়ে নিজেকে ডাকে। while কখনো গোনা হয় না।
নিচের stepper-এ একটি পরিচিত ভুল: ডেলিভারি চার্জের তিনটি ধাপ লিখতে গিয়ে শেষ else বাদ পড়েছে। প্রতিটি return type-এর দিক থেকে নিখুঁত, তবু ৫০০ টাকার কম অর্ডারে function-টি কোনো মান ছাড়াই শেষ হতো।
1fn delivery(total: Int) -> Int {2 if total >= 1000 { return 0; }3 else if total >= 500 { return 30; }4}
| ডাক | |
| যা দেখা হলো | |
| ফল |
- আগে type, পরে গঠন.
functionদেহের প্রতিটি statement যাচাই করে: দুটিreturn-ই Int, ρ-ও Int, কোনো ভুল নেই। ফেরত-type Unit নয়, তাই এবারalways_returns(দেহ). দেহে একটিমাত্র statement: 2:5-এরIf. - বাইরের if. এর
else_আছে, তবে সেটি একটিIf(else if), তাইother = [If 3:10]. নিয়ম (গ)-এর জন্য দুই শাখাই লাগবে; প্রথমটি[return 0], নিয়ম (ক) দিয়ে সঙ্গে সঙ্গে True. - ভেতরের if. নতুন ডাক, তালিকা
[If 3:10]. এটিreturnনয়, block নয়, আর এরelse_নেই: তিনটি নিয়মের কোনোটি খাটে না। তালিকা শেষ, ফল False. এখানেই আসল ফাঁক:total৫০০-এর কম হলে কোনো শাখা চলে না। - বাইরে ফেরা. then-শাখা True, অন্য শাখা False, তাই বাইরের
If-ও গোনা হলো না। দেহে আর কোনো statement নেই, তাই দেহের ফল False. - Error. অবস্থান function-এর নামের ঘর, 1:4 (decision 21; নামহীন function হলে
fnশব্দে), আর বার্তায় লেখা ফেরত-type. Reference-এরcheckএই ফাইলে ঠিক এই লাইনটি দেয়। - ঠিক করা. লাইন ৩-এর পরে
else { return 60; }যোগ করলে ভেতরেরIf-এর দুই শাখাই return করে, তাই সে True; তাহলে বাইরেরটিও True. Reference-এরcheckঠিক করা ফাইলে দেয়ok.
নিয়মটি ইচ্ছা করে রক্ষণশীল: কোনো সত্যিকারের ফাঁকওয়ালা function কখনো গ্রহণ করে না (একটি sound analysis), বিনিময়ে কিছু নির্দোষ function বাতিল করে। যেমন while true { if n >= 1000 { return n; } n = n * 2; } কখনো return ছাড়া শেষ হয় না, তবু reference বলে missing return, কারণ নিয়ম while-এর শর্ত পড়ে না। নিয়মটি আরও চালাক করা যায় (অনুশীলন ১), কিন্তু নিখুঁত নয়: “এই function কি সব ইনপুটে return করে?” program-এর আচরণ নিয়ে প্রশ্ন, আর গণনার তত্ত্বের পর্ব ৫৩-এ (Rice-এর theorem) দেখেছেন এমন প্রশ্নের সাধারণ উত্তরদাতা algorithm নেই। তাই প্রতিটি compiler কোথাও একটি সীমা টানে; সত্যিকারের compiler-এ একই ভুল চালিয়ে দেখা যাক।
Java 21 (সত্যিকারের run, Wandbox-এ OpenJDK jdk-21+35), সঙ্গে একটি while (true) function, যা Haat বাতিল করত:
static int delivery(int total) { // লাইন ২–৫
if (total >= 1000) { return 0; }
else if (total >= 500) { return 30; }
}
static int firstPositive(int x) { // লাইন ৬–৮
while (true) { if (x > 0) return x; x = x + 1; }
}
$ javac prog.java
prog.java:5: error: missing return statement
}
^
1 error
Java-ও একে error বলে, কিন্তু firstPositive নিয়ে আপত্তি নেই: Java-র ভাষা-নির্দেশিকার (JLS) “can complete normally” নিয়মে break-ছাড়া while (true) কখনো স্বাভাবিকভাবে শেষ হয় না। Java শর্তের মান পড়ে, তবে শুধু constant expression-এর।
C (সত্যিকারের run, Wandbox-এ Clang 17.0.1 আর GCC 13.2.0, -Wall). একই delivery, C-তে:
$ clang -Wall prog.c
prog.c:4:1: warning: non-void function does not return a value in all control paths [-Wreturn-type]
4 | }
| ^
1 warning generated.
$ gcc -Wall prog.c
prog.c: In function 'delivery':
prog.c:4:1: warning: control reaches end of non-void function [-Wreturn-type]
দুটি compiler-ই শুধু warning দেয়, আর program তৈরি হয়ে যায়। C17 মান অনুযায়ী শেষের }-এ পৌঁছানো নিজে ভুল নয়; caller সেই না-থাকা মান ব্যবহার করলে তবেই আচরণ undefined.
Rust 1.82.0 (সত্যিকারের run, Wandbox-এ):
error[E0317]: `if` may be missing an `else` clause
--> prog.rs:3:10
|
3 | else if total >= 500 { return 30; }
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `i64`, found `()`
Rust-এ if একটি expression আর দেহের শেষ expression-ই ফল। else-ছাড়া if-এর type () (Rust-এর Unit), আর function চায় i64: missing return এখানে একটি সাধারণ type mismatch (পর্ব ৩৪-এর T-IfExpr মনে করুন)। চারটি ভাষা, চারটি নকশা: Haat সরল syntactic নিয়ম, Java constant-সচেতন নিয়ম, C শুধু warning, Rust type দিয়েই।
৭ · অনেক ভুল একসঙ্গে — error জমানো আর cascade ঠেকানো
Decision 2 বলে: parser, resolver আর type checker প্রত্যেকে নিজের সব error জানায়, অবস্থান অনুযায়ী সাজিয়ে, আর পরের ধাপ চলে কেবল আগের ধাপ পরিষ্কার হলে। কোডে self.errors একটি তালিকা, প্রতিটি ভুল সেখানে যোগ হয় আর কাজ চলে; program-এর শেষে তালিকা খালি না হলে একটিই HaatErrors, যা (line, col) অনুযায়ী সাজায়। পাইথনের sorted stable, তাই একই ঘরের দুটি error ধরা পড়ার ক্রমেই থাকে।
সব ভুল একবারে জানানোর বিপদ error cascade: একটি আসল ভুল থেকে পরপর বানানো বার্তা। Haat অংশ ১-এর তিন চুক্তি দিয়ে এটি ঠেকায়: ব্যর্থ অংশের type None, None দেখলে expect চুপ, আর যেখানে নিয়ম নিজেই ফলের type ঠিক করে (operator, call, annotation), সেখানে ভুলের পরেও সেই type ওপরে যায়। নিচের stepper-এ একটি function-এর চারটি ভুল থেকে পাঁচটি বার্তা; একটি কেন বাড়তি, সেটিই শিক্ষা।
1fn receipt(qty: Int, vip: Bool) -> Str {2 let total = qty * "520";3 if vip + 1 { print(total); }4 let tag = total(2) + 1;5 return "Taka " + total;6}
| এই লাইনে | |
| জমা error |
- Function-এ ঢোকা. Parameter-গুলোর type বসে annotation থেকে, আর ρ = Str. খাতা খালি।
- লাইন ২.
*-এর নিয়ম T-Arith দুই পাশেই Int চায়; ডান পাশ Str, তাই একটি error"520"-এর শুরুতে, 2:23. কিন্তু T-Arith-এর ফল সবসময় Int, তাইtotal : Int,Noneনয়। পরের লাইনগুলোtotal-কে একটি স্বাভাবিক Int হিসেবে দেখবে। - লাইন ৩, একটি ভুল থেকে দুটি বার্তা.
vip + 1: বাঁ পাশ Bool, Str নয়, তাই T-Add, আর বাঁ পাশে চাওয়া Int: error 3:8. T-Add-এর ফল Int, তাই এবার T-If শর্তে চায় Bool, পেল Int: শর্তের শুরু সেই একই 3:8, দ্বিতীয় error. ভুল আসলে একটি (লেখক সম্ভবতvipবাqty + 1 > 2বোঝাতে চেয়েছিলেন), বার্তা দুটি। এটিই cascade-এর ছোট একটি রূপ, যা reference-এর নকশা ঠেকায় না। - লাইন ৪, None-এর কাজ.
totalএকটি Int, তাকে ডাকা যায় না:cannot call a value of type Int, callee-র শুরুতে, 4:15, আর call-এর ফলNone. তারপর+ 1: বাঁ পাশNone, তাইexpectচুপ; ডান পাশ Int ঠিক। একটি ভুল, একটি বার্তা। - লাইন ৫. বাঁ পাশ Str, তাই T-Concat: ডান পাশ চায় Str, পেল Int (
total), error 5:22. ফল Str, যা ρ-এর সমান, তাই T-Return চুপ। - শেষে. দেহের তালিকায় একটি
returnআছে, তাই missing return নেই।program-এর শেষে পাঁচটি error সাজিয়ে একসঙ্গে ছাপা হয়; 3:8-এর দুটি ধরা পড়ার ক্রমেই থাকে। Reference-এরcheckএই ফাইলে হুবহু এই পাঁচটি লাইন দেয়।
3:8-এর দ্বিতীয় বার্তা ঠেকাতে binary ভুল operand পেলে নিজেই None দিতে পারত; কিন্তু তখন লাইন ২-এ total-ও None হতো, আর লাইন ৫-এর আসল ভুলটি চুপচাপ হারাত। Reference উল্টোটি বেছেছে: নিয়ম যেখানে ফলের type বলে দেয়, সেটি ওপরে পাঠানো, আর মাঝে মাঝে একটি বাড়তি বার্তা মেনে নেওয়া। নিখুঁত উত্তর নেই, প্রতিটি compiler কোথাও আপস করে।
সত্যিকারের compiler-এ জমানোর সীমাও থাকে। ২২টি একই রকম type error-ওয়ালা একটি C ফাইল (সত্যিকারের run, Wandbox-এ):
$ clang prog.c # Clang 17.0.1
prog.c:4:7: error: assigning to 'struct order' from incompatible type 'int'
... (মোট ২০টি এমন লাইন)
fatal error: too many errors emitted, stopping now [-ferror-limit=]
20 errors generated.
$ gcc prog.c # GCC 13.2.0
prog.c:4:9: error: incompatible types when assigning to type 'struct order' from type 'int'
... (২২টি লাইনই আসে)
Clang ২০টির পরে থামে (-ferror-limit; Clang-এর manual অনুযায়ী এর ডিফল্ট মান ২০, আর -ferror-limit=0 দিলে সীমা থাকে না), GCC সবগুলো দেখায়। আর একই ভুলের জন্য Clang দেখায় column 7 (=), GCC column 9 (ডান পাশের মান): error-এর “সঠিক” ঘর প্রতিটি বাস্তবায়নের নিজের সিদ্ধান্ত। Haat সেটি লিখে রেখেছে decision 24-এ, তাই golden file-এ অবস্থানসহ মেলানো যায়।
আরও গভীরে। Haat-এর None একটি পুরোনো কৌশলের সবচেয়ে ছোট রূপ: ভুল অংশের জন্য একটি বিশেষ “error type”, যা যেকোনো type-এর সঙ্গে মিলে যায় বলে ধরা হয়। Rust-এর compiler-এর ভেতরে এমন একটি error type আছে, আর Clang ভুল expression ফেলে না দিয়ে একটি “recovery” node রেখে পরের যাচাই চালায় (দুটিই সংক্ষেপে বলা, খুঁটিনাটি সংস্করণভেদে বদলায়)। আজকের editor প্রতি কয়েক মুহূর্তে checker চালায়, তাই cascade-এর দাম আরও চোখে পড়ে, আর বার্তার মান হয়ে উঠেছে ভাষার নকশারই অংশ।
৮ · Checker-কে পরীক্ষা — golden file, mutant আর differential test
Type checker-এর ভুল দুই রকম: ভালো program বাতিল করা, আর খারাপ program পার করে দেওয়া; দ্বিতীয়টি বেশি বিপজ্জনক, কারণ তা চুপচাপ থাকে। তাই তিন স্তরে পরীক্ষা।
এক, golden file: হাতে লেখা ফাইল আর তার প্রত্যাশিত পুরো আউটপুট। Reference-এর একটি test-এ err_types.haat-এর নয়টি লাইন লেখা, আর আরেকটি দেখে দশটি ভালো উদাহরণ-ফাইল সবই ok কি না। Golden file সস্তা আর সহজপাঠ্য, কিন্তু শুধু আগে থেকে ভেবে রাখা ভুলই ধরে।
দুই, mutant: একটি ভালো program-এ ইচ্ছা করে ছোট বদল এনে অনেকগুলো সামান্য-ভুল program বানানো, আর দেখা checker কতটি ধরে। এটি mutation testing-এর ধারণা (Software Testing & QA কোর্সের পর্ব ৫৯), তবে উল্টো দিক থেকে: সাধারণত mutant বানানো হয় পরীক্ষাধীন কোডে; এখানে বানানো হয় checker-এর ইনপুটে, আর checker নিজেই “test”. শেষ ব্লক bazar.haat আর shop.haat-এর প্রতিটি token ধরে সব একক-বদলের mutant বানায়: অন্য operator, অন্য type-এর literal, Int-এর জায়গায় Bool বা Str, অন্য function-এর নাম, আর একটি পুরো return মুছে ফেলা।
// বাজারঘর: কুপন, ডেলিভারি আর রসিদ
fn fee(total: Int, express: Bool) -> Int {
if total >= 1000 { return 0; } else if express { return 120; } else { return 60; }
}
fn label(vip: Bool) -> Str {
if vip { return "VIP"; }
return "regular";
}
fn apply(f: (Int) -> Int, x: Int) -> Int { return f(x); }
let coupon = fn(p: Int) -> Int { return p - p / 20; };
var total = apply(coupon, 800);
var rounds = 0;
while rounds < 2 { rounds = rounds + 1; total = total + fee(total, rounds == 2); }
print(label(total > 900) + " order");
print(total);
from collections import Counter
OPS = "+ - * / % < <= > >= == != && ||".split()
SWAP = {"INT": ["true", '"7"'], "TRUE": ["1"], "FALSE": ["1"], "STRING": ["1"]}
def mutants(src): # every single-token mutant of src (mutation testing)
toks, starts = tokenize(src), [0]
for line in src.split("\n"): starts.append(starts[-1] + len(line) + 1)
at = lambda t: starts[t.line - 1] + t.col - 1 # (line, col) -> offset
fns = {toks[k + 1].text for k, t in enumerate(toks) if t.kind == "FN" and toks[k + 1].kind == "IDENT"}
for i, t in enumerate(toks):
a, b = at(t), at(t) + len(t.text)
if t.text in OPS: news = [op for op in OPS if op != t.text] # another operator
elif t.text in ("Int", "Bool", "Str"): news = [n for n in ("Int", "Bool", "Str") if n != t.text]
elif t.text in fns and toks[i - 1].kind != "FN": news = sorted(fns - {t.text}) # another function
else: news = SWAP.get(t.kind, []) # a literal of another type
for new in news: yield f"{t.text} -> {new} at {t.line}:{t.col}", src[:a] + new + src[b:]
if t.kind == "RETURN": # delete a whole return statement
j, depth = i, 0 # its own ';' (skip any { … } inside)
while toks[j].kind != "SEMI" or depth: depth += {"LBRACE": 1, "RBRACE": -1}.get(toks[j].kind, 0); j += 1
yield f"delete return at {t.line}:{t.col}", src[:a] + src[at(toks[j]) + 1:]
KINDS = ("type mismatch", "missing return", "argument", "cannot print", "cannot compare", "cannot call")
def kind(out): # group a result by its first message
if out == "ok": return "survived (accepted)"
msg = out.split("\n")[0].split("error: ")[1]
return next((k for k in KINDS if k in msg), msg)
for name in ("bazar.haat", "shop.haat"):
src = open(name, encoding="utf-8").read(); tally, alive = Counter(), []
for what, m in mutants(src):
r = kind(check(m)); tally[r] += 1
if r.startswith("survived"): alive.append(what)
print(f"== {name}: {sum(tally.values())} mutants")
for k, n in tally.most_common(): print(f" {n:4} {k}")
print(" e.g. survived:", "; ".join(alive[::len(alive) // 3][:3]))আসল আউটপুট (ব্রাউজারের Python):
== bazar.haat: 167 mutants
105 type mismatch
56 survived (accepted)
3 missing return
3 argument
e.g. survived: * -> + at 3:17; >= -> < at 8:14; < -> == at 14:13
== shop.haat: 168 mutants
119 type mismatch
39 survived (accepted)
6 missing return
4 argument
e.g. survived: >= -> < at 3:14; / -> % at 10:47; + -> % at 13:55
৩৩৫টি mutant-এর ২৪০টি checker-এ আটকায়, বেশিরভাগ type mismatch হিসেবে; return মোছাগুলো আটকায় missing return-এ, আর নাম বদলের কয়েকটি argument-সংখ্যায় (argument সারি)। বাকি ৯৫টি পার পায়, আর সেটিই ঠিক: * থেকে + বা >= থেকে < type-এর দিক থেকে নির্দোষ, শুধু হিসাব ভুল। Type checker ধরনের ভুল ধরে, মানের নয়। ল্যাবে এই survivor-গুলো reference-এর run দিয়ে চালিয়ে আসল আউটপুটের সঙ্গে মেলানো হয়েছে (সত্যিকারের run): bazar.haat-এর ৫৬টির ৪৭টির আউটপুট বদলায়, ৪টি অসীম loop-এ পড়ে (৩ সেকেন্ডের সময়সীমায় ধরা), ৫টির আউটপুট হুবহু এক; shop.haat-এ ৩৯টির ২৭টি বদলায়, ৪টি loop, ৮টি এক। শেষের ১৩টির সবই সীমার বদল, যেমন >= থেকে >: ইনপুটে কোনো অর্ডার ঠিক ১০০০ টাকার নয়। এরা checker-এর দুর্বলতা নয়; এরা বলে আউটপুট-test-এ একটি সীমার ইনপুট দরকার।
তিন, differential testing: পাতার checker আর reference-এর check-কে একই ইনপুট দিয়ে পুরো লেখা মেলানো: বার্তা, line, column আর ক্রম। ল্যাবে সত্যিকারের run:
| ইনপুট | সংখ্যা | reference-এর রায় | হুবহু এক |
|---|---|---|---|
| reference-এর ১৩টি উদাহরণ, এই পর্বের ৬টি ফাইল | ১৯ | ১২টি ok, ৭টি error | ১৮ (অমিল নিচে) |
| তাদের মধ্যে ok ফাইলগুলোর সব একক-বদলের mutant | ১,৫২৫ | ৪১২টি ok, ১,১১৩টি error | ১,৫২৫ |
| এলোমেলো program (seed 52), type-নির্দেশিত, প্রতিটি সিদ্ধান্তে ৪% সম্ভাবনায় ইচ্ছাকৃত ভুল | ৩,০০০ | ৫৪৬টি ok, ২,৪৫৪টি error (মোট ১০,৩৭৬টি বার্তা) | ৩,০০০ |
এলোমেলো program-এ প্রথম বার্তার ধরন: type mismatch ১,৯২৩, argument-সংখ্যা ২১১, missing return ১৫২, cannot print ১১০, ==-এ function তুলনা ৫৬, cannot call ২; আর ১,৯৫৯টিতে একাধিক বার্তা, তাই জমানো আর সাজানোও পরীক্ষিত। একমাত্র অমিল err_syntax.haat: চারটি syntax error, reference চারটিই দেয় (পর্ব ৫০-এর recovery), পাতার parser প্রথমটিতে থামে, আর প্রথম লাইন দুটিতে এক।
একটি সতর্কতা: দুটি বাস্তবায়ন একই ভুল করলে differential test তা ধরে না, আর পাতার checker reference দেখে লেখা। স্বাধীনতার কাজটি করে golden file (মানুষের লেখা প্রত্যাশা) আর mutant (কোনটি ধরা উচিত, তা ইনপুটের গঠন থেকে আসে)। তিন স্তর একে অপরের ফাঁক ঢাকে।
পরীক্ষা ও ইন্টারভিউতে। বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন সাধারণ:
- একটি expression-এর type-checking trace লিখুন। প্রতিটি node-এ নিয়মের নাম, চাওয়া আর পাওয়া type; ভুল থাকলে কোন node-এ, কোন বার্তা।
- Type checker কেন প্রথম ভুলে থামে না? একবারে বেশি ভুল দেখানো; তবে cascade ঠেকাতে ভুল অংশের জন্য একটি বিশেষ error type বা
None. - Missing return কীভাবে ধরা হয়? Control flow-এর একটি syntactic বা constant-সচেতন বিশ্লেষণ; সাধারণভাবে নিখুঁত হওয়া অসম্ভব (Rice), তাই রক্ষণশীল।
- Symbol table আর type checker-এর সম্পর্ক? Resolver নাম জোড়ে, checker প্রতিটি ঘোষণার type সেই entry-তেই লেখে; symbol table-ই typing context.
- নিজের checker কীভাবে test করবেন? Golden file, ইচ্ছাকৃত-ভুলের mutant, আর আরেকটি বাস্তবায়নের সঙ্গে differential test.
৯ · AI-এর যুগে type checker
“একটি ছোট ভাষার type checker লিখে দাও” চাইলে AI assistant কয়েক সেকেন্ডে পরিচ্ছন্ন কোড দেয়, আর সাধারণ উদাহরণে তা চলেও। সমস্যা থাকে নিয়মের কিনারায়। বারবার দেখা ভুল:
| AI-এর ভুল | কীভাবে ধরবেন |
|---|---|
অন্য ভাষার নিয়ম চাপিয়ে দেওয়া: 1 + "a"-কে Str ধরা (JavaScript-এর মতো), বা if 5 মেনে নেওয়া (C-র মতো) | নিয়ম-থেকে-কোড টেবিলের প্রতিটি সারির জন্য একটি ভালো আর একটি খারাপ উদাহরণ; reference-এর সঙ্গে মেলানো |
Argument-সংখ্যা না দেখে শুধু zip দিয়ে মেলানো, ফলে বাড়তি argument চুপচাপ পার | price(1) আর price(1, 2, 3)-এর মতো mutant |
None-এর নিয়ম না রাখা: হয় cascade-এর বন্যা, নয়তো None-এর ওপর attribute খুঁজতে গিয়ে checker নিজেই crash | একটি ভুল থেকে কয়টি বার্তা আসে, গুনে দেখা; error-ওয়ালা এলোমেলো program দিয়ে fuzzing |
Error-এর ভুল ঘর: operator-এর ঘরে বা call-এর (-এ, ভুল expression-এর শুরুতে নয় | Golden file-এ প্রতিটি বার্তা line:col সহ |
Nested function-এ ρ ফিরিয়ে না আনা, ফলে ভেতরের return বাইরের function-এর type-এর সঙ্গে মেলে | Function-এর ভেতরে lambda-ওয়ালা উদাহরণ (shop.haat-এর মতো) |
Missing return-কে নিজের মতো “চালাক” করা (while true গোনা), বা পুরো বাদ দেওয়া | Spec-এর decision 21 পাশে রেখে while true আর else if-শৃঙ্খলের উদাহরণ চালানো |
AI-কে কাজে লাগানোর ভালো উপায়: নিয়মের তালিকা আর বার্তার হুবহু লেখা নিজে দিন, প্রতিটি শাখার পাশে নিয়মের নাম চান, আর কোডের সঙ্গে test-ও চান, যাতে নিজে চালিয়ে মেলাতে পারেন।
AI-এর লেখা checker হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১প্রথম ভুলে থেমে যাওয়া সহজ। তবু প্রায় সব compiler কেন সব ভুল একবারে জানাতে চায়, আর তার দাম কী?
১৯৫০ আর ১৯৬০-এর দশকে program জমা দেওয়া হতো punch card-এর তাড়ায়, আর ফল আসত কয়েক ঘণ্টা, কখনো পরের দিন পরে। তখন এক compile-এ একটিমাত্র ভুল জানানো মানে প্রতিটি টাইপোর জন্য আরেকটি দিন। তাই শুরু থেকেই লক্ষ্য ছিল এক run-এ যত বেশি সম্ভব আসল ভুল জানানো: parser-এর জন্য error recovery (পর্ব ৫০), type checker-এর জন্য ভুল জমিয়ে কাজ চালিয়ে যাওয়া।
আজ প্রয়োজন আরও বেশি: editor-এর language server (পর্ব ৮০) প্রতি কয়েক মুহূর্তে checker চালায় একটি অর্ধেক-লেখা, ভুলে ভরা ফাইলে। প্রথম ভুলে থামলে বাকি ফাইলের লাল দাগ বা autocompletion-এর type কিছুই পাওয়া যেত না।
দাম হলো cascade, আর তার উত্তর একটি বিশেষ “error type”. ভাবনাটি সরল: ভুল অংশের type অজানা, তাই তাকে এমন একটি type দিন, যা সবকিছুর সঙ্গে মিলে যায়; তাহলে তার চারপাশে আর কোনো বার্তা জন্মায় না। Haat-এর None ঠিক এটি, সবচেয়ে ছোট আকারে। বাস্তব compiler-এ এটি অনেক বেশি সূক্ষ্ম: ভুল অংশটির কতটুকু জানা (যেমন “এটি নিশ্চয়ই কোনো সংখ্যা”), কোন বার্তা বাদ দেওয়া নিরাপদ, আর কোনটি বাদ দিলে আসল ভুল হারায়। অংশ ৭-এর stepper দেখিয়েছে দুই দিকেরই ঝুঁকি: বেশি None দিলে লাইন ৫-এর আসল ভুল হারাত, কম দিলে লাইন ৩-এ একটি বাড়তি বার্তা।
অনেক বার্তা নিজেও একটি সমস্যা: Clang একটি সীমার পরে থামে (অংশ ৭-এর run-এ ২০টি)। আর Haat-এর decision 2 ধাপগুলোর মাঝে একটি দেয়াল রাখে: parser ভুল পেলে resolver চলে না, resolver ভুল পেলে checker চলে না, যাতে ভাঙা গাছের ওপর type-এর অর্থহীন বার্তা না আসে। ধাপের ভেতরে সব ভুল, ধাপগুলোর মাঝে সাবধানতা।
মূল উপলব্ধি: সব ভুল জানানো একটি প্রতিশ্রুতি, আর সেই প্রতিশ্রুতি রাখতে হলে প্রতিটি নতুন বার্তা আলাদা একটি আসল ভুলের হতে হবে; error type বা None সেই শৃঙ্খলার যন্ত্র।
প্র ০২Missing return: Haat, Java, C আর Rust চারভাবে সামলায়। কোন নকশার পেছনে কী যুক্তি, আর Haat কি Java-র পথ নিতে পারত?
অংশ ৬-এর সত্যিকারের run-গুলো চারটি দর্শন দেখায়। C-র মূল প্রশ্ন ছিল দক্ষতা আর পুরোনো কোডের সামঞ্জস্য: প্রথম দিকের C-তে ফেরত-type প্রায়ই লেখা হতো না, আর অনেক caller ফেরত মান ব্যবহারই করত না। তাই মান বলে: শেষে পৌঁছানো নিজে অপরাধ নয়, মানটি ব্যবহার করলে তবেই আচরণ undefined. Compiler এখানে শুধু warning দিতে পারে, আর -Werror=return-type-এর মতো flag দিয়ে অনেক দল সেটিকে error বানিয়ে নেয়।
Java নিরাপত্তাকে আগে রেখেছে: প্রতিটি পথে মান না থাকলে program-ই হবে না। তবে বিশ্লেষণটি নির্দিষ্ট আর লিখিত (“can complete normally”): constant শর্ত চেনে, তাই break-ছাড়া while (true)-এর পরে কিছু লাগে না, কিন্তু while (x > 0) নিয়ে কিছু অনুমান করে না। ইচ্ছা করে সীমিত, যাতে প্রতিটি compiler একই program গ্রহণ করে।
Rust প্রশ্নটিকেই মুছে দিয়েছে: দেহ একটি expression, তার type ফেরত-type-এর সমান হতে হবে। else-ছাড়া if-এর type Unit, তাই ফাঁকটি একটি সাধারণ type mismatch হিসেবে ধরা পড়ে, আলাদা pass ছাড়াই। আর অসীম loop বা panic!-এর type “never” (!), যা যেকোনো type-এর জায়গায় বসতে পারে, তাই loop { … }-এর পরে কিছু লাগে না।
Haat সবচেয়ে সরলটি নিয়েছে: শর্ত কখনো পড়া হয় না। দাম অংশ ৬-এ দেখেছেন, নির্দোষ while true-ও বাতিল। Java-র পথ নেওয়া সহজ (অনুশীলন ১ ঠিক সেটি করে), আর Haat v1-এ break নেই বলে সেটি sound-ও থাকে। কিন্তু spec তখন আরও একটি সংজ্ঞা চাইবে: কোন expression “constant”? true শুধু, নাকি 1 < 2-ও? প্রতিটি নতুন শিথিলতা spec-এ একটি নতুন অনুচ্ছেদ আর প্রতিটি বাস্তবায়নে একটি নতুন শাখা আনে। শেখানোর ভাষার জন্য সরল নিয়মটি নিজেই একটি গুণ।
মূল উপলব্ধি: নিখুঁত missing-return যাচাই অসম্ভব, তাই প্রতিটি ভাষা জেনেশুনে একটি সীমা টানে; ভালো সীমা হলো যা লিখিত, সহজে ব্যাখ্যাযোগ্য, আর প্রতিটি বাস্তবায়নে একই ফল দেয়।
প্র ০৩Haat-এর checker প্রায় পুরোটাই নিচ থেকে type বের করে। “চাওয়া type” ওপর থেকে আরও বেশি পাঠালে কী লাভ হতো?
Haat-এ checking-এর রূপটি খুব সরল: একটি type বের করা হয়, তারপর চাওয়া type-এর সঙ্গে সমতা দেখা হয়। এটি সম্ভব কারণ Haat-এ প্রতিটি parameter-এর type লেখা বাধ্যতামূলক। লেখা না থাকলে কী হতো ভাবুন: let g: (Int) -> Int = fn(x) { return x + 1; }; লিখতে চাইলে lambda-র x-এর type নিচ থেকে বের করার কোনো উপায় নেই। দুটি সমাধান আছে।
প্রথমটি পূর্ণ inference, পর্ব ৩৫-এর Hindley–Milner: x-এর জন্য একটি অজানা চলক, তারপর সমীকরণ আর unification. ML আর Haskell এই পথে প্রায় annotation ছাড়াই চলে, কিন্তু subtyping বা overloading-এর সঙ্গে এটি সহজে মেশে না, আর সমীকরণের দ্বন্দ্ব যেখানে ধরা পড়ে, ভুল সেখানে নাও থাকতে পারে।
দ্বিতীয়টি bidirectional checking-কে পুরোপুরি কাজে লাগানো: annotation থেকে চাওয়া type (Int) -> Int নিচে পাঠানো, আর lambda সেটি দেখে জেনে নেয় x একটি Int. Pierce আর Turner-এর “Local Type Inference” (POPL ১৯৯৮, পরে TOPLAS ২০০০) এই ধারার একটি প্রভাবশালী কাজ, আর পর্ব ৩৪-এর “আরও গভীরে” অংশে এর উল্লেখ আছে। TypeScript-এর “contextual typing” বা Kotlin আর Scala-র lambda-র parameter type না লেখার সুবিধা এই ধারণার আত্মীয় (প্রতিটি ভাষার নিয়ম আলাদা, খুঁটিনাটি তাদের নিজের নির্দেশিকায়)। এখানে বার্তাও সাধারণত ভালো হয়, কারণ চাওয়া type যেখান থেকে এসেছে, ভুল সেখানের কাছেই ধরা পড়ে।
Haat-এর checker-এ এটি যোগ করতে লাগত expr(e)-এর পাশে একটি check(e, want), যা lambda-র জন্য চাওয়া type ব্যবহার করে আর বাকিদের পুরোনো পথে মেলায়। দাম spec-এ: কোন গঠনে চাওয়া type পৌঁছায়, তা লিখে দিতে হয়, নাহলে দুটি বাস্তবায়ন আলাদা program গ্রহণ করবে।
মূল উপলব্ধি: annotation যত বেশি বাধ্যতামূলক, checker তত সরল; annotation কমাতে চাইলে হয় পূর্ণ inference, নয়তো চাওয়া type-কে গাছের নিচে পাঠানো, আর দুটি পথই spec আর বার্তার মানে আলাদা দাম নেয়।
প্র ০৪Mutant আর এলোমেলো program দিয়ে compiler পরীক্ষার ধারণা কোথা থেকে এল, আর এর সীমা কোথায়?
Mutation testing-এর ভিত্তি সাধারণত ধরা হয় DeMillo, Lipton আর Sayward-এর ১৯৭৮ সালের প্রবন্ধ “Hints on Test Data Selection”-কে, যার মূল যুক্তি দুটি: দক্ষ programmer-এর ভুল সাধারণত ছোট (একটি operator, একটি সীমা), আর ছোট ভুল ধরতে পারা test বড় ভুলও প্রায়ই ধরে। একই সময়ে Hamlet-সহ আরও কয়েকজন কাছাকাছি ধারণা নিয়ে লিখেছিলেন, তাই “প্রথম” কে, তা নিয়ে উৎসভেদে ভিন্ন বর্ণনা আছে। এই পর্বের mutant ঠিক সেই “ছোট ভুল”: একটি operator, একটি literal, একটি নাম।
Compiler-এর ক্ষেত্রে differential testing-এর সবচেয়ে পরিচিত উদাহরণ Csmith (Yang, Chen, Eide আর Regehr, PLDI ২০১১): এটি এলোমেলো কিন্তু undefined behaviour-মুক্ত C program বানিয়ে GCC আর LLVM-সহ কয়েকটি compiler-এ চালাত আর আউটপুট মেলাত, আর এভাবে কয়েকশো আগে-অজানা bug পাওয়া গিয়েছিল বলে লেখকেরা জানিয়েছেন। পরে Le, Afshari আর Su-র EMI (PLDI ২০১৪) একটি program-এর এমন অংশ বদলাত, যা একটি নির্দিষ্ট ইনপুটে চলেই না; তাহলে আউটপুট একই থাকার কথা, আর না থাকলে compiler-এ bug.
এই পর্বের পরীক্ষা ছোট আকারে একই ধারার: type-নির্দেশিত generator, যা মাঝে মাঝে (৪%) ইচ্ছা করে ভুল type বাছে। পুরোপুরি এলোমেলো generator-এর প্রথম চেষ্টায় প্রায় প্রতিটি program resolver-এই আটকাত, আর checker-এর শাখাগুলো প্রায় পরীক্ষাই হতো না।
সীমা তিনটি। Equivalent mutant: >= থেকে > কখনো কখনো আচরণ বদলায় না, আর কোনটি বদলায় তা ঠিক করা সাধারণভাবে undecidable. Oracle-এর সমস্যা: differential test বলে “দুটি আলাদা”, কিন্তু কোনটি ঠিক তা বলে না, আর দুটি একই ভুল করলে কিছুই বলে না; এই পর্বে পাতার checker reference দেখে লেখা, তাই সেই ঝুঁকি বাস্তব। আর generator-এর পক্ষপাত: যে গঠন generator বানায় না (যেমন এখানে খুব গভীর nesting), তা পরীক্ষাও হয় না।
মূল উপলব্ধি: এলোমেলো আর mutant ইনপুট মানুষের চোখ এড়ানো কিনারা খুঁজে আনে, কিন্তু কোনটি সঠিক তা বলতে লাগে একটি স্বাধীন oracle: হাতে লেখা golden file, spec, বা একেবারে আলাদাভাবে লেখা আরেকটি বাস্তবায়ন।
প্র ০৫Reference checker শুধু ঘোষণার type রাখে, প্রতিটি expression-এর type ফেলে দেয়। পরের ধাপগুলোর জন্য এটি কি যথেষ্ট?
Haat reference-এর checker একটি “হ্যাঁ বা না” যন্ত্র: সে Binding.type ভরে, কিন্তু price(2, 520) + 60-এর মতো expression-এর বের করা type কোথাও লেখে না। পরের ধাপ, bytecode compiler আর VM (পর্ব ৫৮–৫৯), এতে অসুবিধায় পড়ে না, কারণ VM-এর ADD চলার সময় মান দেখে: দুটি Int হলে যোগ, দুটি Str হলে জোড়া। অর্থাৎ type-এর তথ্য চলার সময় মানের সঙ্গেই থাকে।
কিন্তু পর্ব ৭২-এর RISC-V back end বা পর্ব ৭৩-এর WebAssembly-তে অবস্থা আলাদা। সেখানে + হয় একটি integer-যোগের instruction, নয়তো একটি string-জোড়ার runtime function-এর ডাক, আর এই সিদ্ধান্ত নিতে হয় compile-এর সময়ে। তখন প্রতিটি Binary node-এর type জানা দরকার। উপায় দুটি। প্রথমটি typed AST: প্রতিটি node-এ একটি type field, checker যা ভরে। Clang এভাবে চলে বলে পরিচিত: তার AST-এর প্রতিটি expression নিজের type বহন করে। দ্বিতীয়টি side table: id(node) থেকে type-এর একটি dict, ঠিক যেমন resolver-এর uses. Rust-এর compiler type-checking-এর ফল আলাদা টেবিলে রাখে বলে জানা যায় (খুঁটিনাটি সংস্করণভেদে বদলায়)।
Typed AST সরল আর দ্রুত পড়া যায়, কিন্তু AST-এর সংজ্ঞা checker-এর ওপর নির্ভরশীল হয়ে পড়ে। Side table AST অপরিবর্তিত রাখে, তাই কয়েকটি analysis পাশাপাশি চলতে পারে, আর incremental compilation-এ (পর্ব ৮০) শুধু বদলানো অংশের টেবিল নতুন করে বানানো যায়; দাম প্রতিটি পড়ায় একটি খোঁজ আর node-এর পরিচয় স্থির রাখার দায়িত্ব।
Haat-এর checker-কে typed করতে কোড সামান্যই বদলায়: expr-এর শেষে ফলটি self.types[id(e)]-এ লিখে রাখা। পর্ব ৫৩-এর (Attribute grammar) ভাষায় এটি একটি synthesized attribute, যা গাছের নিচ থেকে ওপরে আসে; সেখানে এই ধারণাটিই সাধারণ রূপে দেখবেন।
মূল উপলব্ধি: type checker-এর আসল ফল শুধু “ok” নয়, প্রতিটি অংশের type-ও; কোন ধাপের কতটুকু লাগবে তা ঠিক করে back end, আর সেই অনুযায়ী typed AST বা side table বেছে নিতে হয়।
অনুশীলন
প্রথমে নিজে করুন, তারপর উত্তর খুলে মেলান। প্রতিটি আউটপুট Haat reference বা পাতার checker-এর সত্যিকারের run থেকে।
-
নকশা ও বাস্তবায়ন —
while trueগোনা (Haat-এর বর্ধিত রূপ): পাতারalways_returns-কে এমনভাবে বাড়ান যে literaltrueশর্তেরwhileএকটি “return করা” statement হিসেবে গণ্য হয়, Java-র মতো। নিচের ফাইলে reference কী বলে, আপনার সংস্করণ কী বলে? পরিবর্তনটি কি sound, আর কোন ভবিষ্যৎ বৈশিষ্ট্য এলে আবার ভাবতে হবে?fn first_big(x: Int) -> Int { var n = x; while true { if n >= 1000 { return n; } n = n * 2; } } print(first_big(3));একটি লাইন যোগ করলেই হয়,
Block-এর নিয়মের ঠিক পরে:if isinstance(s, While) and isinstance(s.cond, Bool) and s.cond.value: return Trueসত্যিকারের run: reference দেয়
1:4: error: missing return: not every path of function 'first_big' returns Int; বদলানো checker দেয়ok. পুরোনো আচরণ ভাঙেনি:bazar.haat,err_types.haatআরshop.haat-এ বদলানো checker-এর আউটপুট reference-এর সঙ্গে হুবহু এক। আর শর্তটিwhile n > 0করলে বদলানো checker-ও আবার missing return দেয়, কারণ শর্ত literaltrueনয়।Sound কি না: Haat v1-এ
breakনেই, তাইwhile trueথেকে বেরোনোর পথ শুধুreturn(বা runtime error, যেখানে কোনো মানই ফেরত আসে না); “শেষে পড়ে যাওয়া” অসম্ভব, আর নতুন নিয়ম কোনো সত্যিকারের ফাঁক মেনে নেয় না। কোনোদিনbreakএলে Java-র মতো শর্ত লাগবে (“এই loop-কে লক্ষ্য করা কোনোbreakনেই”), আর সেটিও spec-এ লিখতে হবে। -
ভুল খুঁজুন — AI-এর লেখা
+: একজন AI assistantbinary-এর+অংশ এভাবে লিখেছে, “যেকোনো পাশে Str থাকলেই string জোড়া”। কোন ইনপুটে এটি reference থেকে আলাদা আচরণ করে, কোন decision ভাঙে, আর এই পর্বের কোন পরীক্ষা এটি ধরে?if e.op == "+": lt, rt = self.expr(e.left), self.expr(e.right) if STR in (lt, rt): # "Str if either side is Str" self.expect(e.left, STR, lt); self.expect(e.right, STR, rt); return STR self.expect(e.left, INT, lt); self.expect(e.right, INT, rt); return INTপার্থক্য শুধু তখন, যখন বাঁ পাশ Int (বা Bool) আর ডান পাশ Str. Decision 11 বলে বাঁ পাশ নিয়ম বাছে; এই কোড ডান পাশকেও বাছতে দেয়। সত্যিকারের run,
let t: Int = 1 + "a";:reference : 1:18: error: type mismatch: expected Int, found Str AI-এর কোড: 1:14: error: type mismatch: expected Str, found Int 1:14: error: type mismatch: expected Int, found Strদুটি ক্ষতি। বার্তা ভুল জায়গায় আঙুল তোলে:
1-কে দোষী বলে, অথচ লেখক সম্ভবত Int-ই চেয়েছিলেন। আর ফল Str হওয়ায় annotationInt-এর সঙ্গে দ্বিতীয় একটি বানানো বার্তা, অর্থাৎ cascade."a" + 1বা"Taka " + 996-এ দুটি কোড একই আচরণ করে, তাই এমন সাধারণ উদাহরণে bug লুকিয়ে থাকে।কে ধরে: golden file
err_types.haat-এর লাইন ৩ (let b = 1 + "two";) সঙ্গে সঙ্গে ধরে, কারণ প্রত্যাশিত3:13: … expected Int, found Str-এর জায়গায় আসে3:9: … expected Str, found Int. আর mutant-এর differential test-ও ধরে: সত্যিকারের run-এbazar.haat-এর ১৬৭টি mutant-এর ৩টিতে আরshop.haat-এর ১৬৮টির ৭টিতে এই কোডের আউটপুট reference থেকে আলাদা। -
Trace আর আউটপুট অনুমান: নিচের ফাইলে
python -B haat.py checkঠিক কী ছাপবে? প্রতিটি লাইনের অবস্থান আর বার্তা লিখুন, তারপর কোন নিয়ম থেকে কোনটি এল তা বলুন।fn half(n: Int) -> Int { while n > 1 { return n / 2; } } let h = half(true, 2); print(h == "4"); print(half);সত্যিকারের run (পাতার checker-এর আউটপুটও হুবহু এক):
1:4: error: missing return: not every path of function 'half' returns Int 4:9: error: expected 1 argument, found 2 4:14: error: type mismatch: expected Int, found Bool 5:12: error: type mismatch: expected Int, found Str 6:7: error: cannot print a value of type (Int) -> Int1:4: দেহের একমাত্র statement একটিwhile, আরwhileকখনো গোনা হয় না (decision 21), তাই missing return, নামের ঘরে।4:9:half-এর একটি parameter, argument দুটি; বার্তা একবচনে “argument”, অবস্থান callee-র শুরু।4:14: সংখ্যা না মিললেওzipপ্রথম জোড়াটি মেলায়: চাই Int, পেল Bool, অবস্থানtrue. দ্বিতীয় argument2-এর কোনো জোড়া নেই, তাই তার কোনো বার্তা নেই। Call-এর ফল তবু Int, তাইh : Int.5:12:h == "4"-এ বাঁ পাশ Int, তাই ডান পাশও Int চাওয়া হলো (T-Eq).6:7: function ছাপা যায় না (T-Print, decision 8), আর type লেখা হয় পুরো function type হিসেবে। -
প্রমাণ —
Noneকখনো একা আসে না: দেখান যে reference checker-এexpr(e)যদিNoneফেরত দেয়, তাহলে ততক্ষণেself.errors-এ অন্তত একটি error আছে। এর ফল হিসেবে দেখান: checker কোনো error না দিলে প্রতিটি যাচাই-করা expression একটি সত্যিকারের type পেয়েছে।প্রমাণের রূপরেখা. দুটি দাবি একসঙ্গে, checker-এর চলার ক্রমের ওপর induction দিয়ে। দাবি A: কোনো মুহূর্তে কোনো
Binding.typeলেখা হলে তাNoneহতে পারে কেবল যদি তখনself.errorsখালি না থাকে। দাবি B:expr(e)Noneফেরত দিলে তখনself.errorsখালি নয়। তালিকা থেকে কিছু কখনো মোছা হয় না, তাই “খালি নয়” একবার সত্য হলে পরেও সত্য।- A, লেখার জায়গাগুলো: top-level আর nested function-এর type
fn_type(f), parameter-এর type annotation, কোনোটিইNoneনয়।Let-এ annotation থাকলে type সেই annotation; না থাকলেexpr(init)-এর ফল, যা B অনুযায়ীNoneহলে error আগেই জমা। - B, literal,
Unary,Binary,Lambda: কোড দেখলেই, এরা কখনোNoneফেরত দেয় না (INT,want,BOOL/STR/INT,fn_type). - B,
Call:Noneআসে দুই পথে।ft is Noneহলে callee-রexprNoneদিয়েছে, তাই callee-র ওপর B (ছোট expression) অনুযায়ী error আছে।ftfunction type না হলে ঠিক সেই লাইনেইcannot callজমা হয়। - B,
Var: resolver সফল, তাইuses-এ binding আছে, আর ফল তারtype. এটিNoneহতে পারে দুই কারণে: লেখা হয়েছিলNone(তখন A অনুযায়ী error আছে), অথবা এখনো লেখাই হয়নি। দ্বিতীয়টি অসম্ভব: hoisted function-এর type প্রথম pass-এ, nested function-এর type তার দেহের আগে, parameter-এর type দেহের আগে, আর resolver-এর নিয়ম (use-before-declaration, decision 16; শুধু আগে-ঘোষিত top-level variable, decision 18) নিশ্চিত করে যে একটিlet-এর ব্যবহার তার যাচাইয়ের পরেই আসে। - ফল: শেষে
self.errorsখালি হলে কোনো মুহূর্তে কোনোexprNoneদেয়নি (B-এর contrapositive). তাই প্রতিটি যাচাই-করা expression একটি type পেয়েছে, আর প্রতিটিexpectসত্যিকারের দুটি type তুলনা করেছে। ∎
লক্ষ করুন, ধাপ ৪-এর নিশ্চয়তা আসে resolver থেকে; resolver-এর নিয়ম বদলালে (যেমন nested function hoisting) প্রমাণটি আবার দেখতে হবে।
- A, লেখার জায়গাগুলো: top-level আর nested function-এর type
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমHaat-এর reference type checker let first = price(2, true) + 60; যাচাইয়ের সময় (Γ-তে price : (Int, Int) -> Int) যে কাজগুলো করে, সেগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)
stmtএকটিLetদেখে তার মানের জন্যexprডাকেbinaryআগে বাঁ পাশ দেখে, আরcallশুরু হয়- Callee
price-এর type আসে symbol table থেকে (T-Var) - দুটি argument-এর type বের হয়: Int আর Bool
- দ্বিতীয় জোড়ায়
expectব্যর্থ,true-এর ঘরে একটি error জমা হয় callInt ফেরত দেয়, T-Add সফল হয়, আরfirstপায় Int
Haat reference-এর check এক লাইনের ফাইল print("a" < "b");-এ কয়টি error দেয়?
- একটিও না, Str-এর অক্ষর-ক্রমে তুলনা হয়
- একটি, প্রথম operand-এ
- দুটি, প্রতিটি operand-এর শুরুতে একটি
- তিনটি: দুটি operand আর একটি print
Haat ফাইল: let n = 3; let m = n(1) + 1; print(m);. Reference-এর check কয়টি error দেয়?
- একটিও না
- একটি:
cannot call a value of type Int - দুটি: call আর
+-এর type mismatch - তিনটি: call,
+আরprint
Haat-এর missing-return নিয়মে (decision 21) নিচের কোন function বাতিল হয়?
fn f(n: Int) -> Int { if n > 0 { return 1; } return 2; }fn f(n: Int) -> Int { if n > 0 { return 1; } else { return 2; } }fn f(n: Int) { if n > 0 { print(n); } }fn f(n: Int) -> Int { while true { return n; } }
Haat ফাইল: fn log(m: Str) { } আর তার পরের লাইনে print(log("x"));. Reference-এর বার্তা কোনটি?
cannot print a value of type Unit, argument-এর শুরুতেmissing return: not every path of function 'log' returns Unitexpected 0 arguments, found 1- কোনো error নেই, ছাপা হয়
()
Haat-এ fn price(qty: Int, unit: Int) -> Int { … } ঘোষিত। লাইন ৯-এ print(price(1)); লেখা, যেখানে price শুরু column 7-এ। Reference কী জানায়?
9:13: error: type mismatch: expected Int, found Unit9:7: error: expected 2 arguments, found 19:12: error: expected 2 arguments, found 19:1: error: cannot print a value of type Int
একটি checker-এর mutation test-এ if p >= 1000-কে if p > 1000 করা mutant checker পার করেছে, আর program-এর আউটপুট-test-ও পার করেছে। এর সবচেয়ে যুক্তিসঙ্গত ব্যাখ্যা কোনটি?
- Checker-এ bug:
>আর>=-এর type আলাদা হওয়া উচিত - এই বদল সব ইনপুটে আচরণ একই রাখে, তাই মুছে ফেলা উচিত
- Test-এর ইনপুটে সীমার মান (ঠিক 1000) নেই; একটি সীমার test যোগ করা দরকার
- Interpreter-এ bug, কারণ দুটি শর্ত একই ফল দিচ্ছে
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- নিয়ম = শাখা: পর্ব ৩৪-এর প্রতিটি typing rule checker-এর একটি
isinstanceশাখা;exprtype বের করে,expectচাওয়া type-এর সঙ্গে মেলায়, আর symbol table-এরBinding.type-ই Γ. - Call: আগে callee আর সব argument, তারপর “function কি না”, তারপর সংখ্যা, তারপর জোড়ায় জোড়ায় মেলানো; ফল সবসময় ঘোষিত ফেরত-type.
- Statement:
let-এর type মান থেকে, annotation থাকলে annotation থেকে;returnমেলে ρ-এর সঙ্গে, যা প্রতিটি function-এ বদলায় আর ফিরে আসে;printশুধু Int, Bool, Str. - Missing return: type ছাড়া একটি রক্ষণশীল syntactic pass (decision 21); নিখুঁত হওয়া অসম্ভব, তাই প্রতিটি ভাষা একটি লিখিত সীমা বেছে নেয়।
- ভুল আর পরীক্ষা: সব error জমিয়ে সাজানো,
Noneদিয়ে cascade ঠেকানো; আর golden file, mutant ও differential test দিয়ে checker যাচাই।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ৫৩ · Attribute grammar আর syntax-directed translationপরবর্তী পর্বsynthesized আর inherited attribute, আর তাদের হিসাবের ক্রম।
- প্রোগ্রামিং ভাষা ও কম্পাইলার · কোর্স হোম৮৬টি পর্ব১৪টি মডিউলের পুরো মানচিত্র আর Haat প্রজেক্টের পথ।
- পর্ব ৩৪ · Typing rule আর type judgment — type checking-এর গণিতনিয়মের উৎসএই checker-এর প্রতিটি শাখার নিয়ম, derivation tree আর অনন্যতার প্রমাণ।
- পর্ব ৫১ · Symbol table আর name resolution — scope-এর বাস্তবায়নআগের ধাপresolver, Binding আর এই পর্বের Γ যেখান থেকে আসে।
- পর্ব ৩৮ · Type soundness — progress আর preservationতত্ত্বchecker যা গ্রহণ করে, তা চলার সময় কেন আটকায় না।
- গণনার তত্ত্ব · পর্ব ৫৩ · Rice-এর theorem — program-এর আচরণ নিয়ে প্রশ্নসীমাmissing return-এর মতো যাচাই কেন কখনো নিখুঁত হতে পারে না।
- Software Testing & QA · পর্ব ৫৯ · Mutation testingপাশের ট্র্যাকmutant, mutation score আর equivalent mutant বিস্তারিত।