এই পর্বে যা শিখবেন
- General-purpose আর domain-specific ভাষার পার্থক্য, আর SQL, regex, Make, CSS, template ও build ফাইলে DSL চেনা
- Internal আর external DSL-এর আপস, আর একই নিয়ম দুই পথে লিখে তুলনা
- একটি ছোট ভাষার শব্দভাণ্ডার, grammar (EBNF) আর অর্থ নকশা করা, বাংলা শব্দ আর Unicode-এর সমস্যাসহ
- DSL-কে Haat-এ অনুবাদ করে অর্থ দেওয়া, আর differential test দিয়ে অনুবাদ যাচাই
- প্রোগ্রামার নন এমন মানুষের জন্য error message লেখা, আর কখন DSL একেবারেই বানানো উচিত নয়
১ · DSL কী — এক কাজের জন্য ছোট ভাষা
রেস্তোরাঁর ওয়েটার অর্ডারের স্লিপে লেখেন: “টেবিল ৪ · ২ চা (চিনি কম) · ১ সিঙ্গারা”. রান্নাঘর এক নজরে বোঝে। এই স্লিপে চিঠি বা গল্প লেখা যায় না, আর কেউ চায়ও না: এর শব্দ কম, বাক্যের ধাঁচ বাঁধা, আর ঠিক সেই কারণেই ভুল কম হয়। নতুন ওয়েটার এক দিনে শিখে ফেলেন। প্রোগ্রামিং-এর জগতে এরকম ছোট, এক কাজের ভাষাকেই বলে domain-specific language.
Python, C, Java বা Haat হলো general-purpose ভাষা: যেকোনো হিসাব লেখা যায়। একটি DSL (domain-specific language) উল্টো পথে হাঁটে: একটি নির্দিষ্ট জগতের (domain) ধারণাগুলো সরাসরি ভাষার শব্দ বানায়, আর বাকি সব বাদ দেয়। ফলে সেই জগতের মানুষ, যিনি প্রোগ্রামার নাও হতে পারেন, নিজের কথা প্রায় নিজের ভাষায় লিখতে পারেন। পর্ব ০৩-এ (Syntax, semantics আর pragmatics) দেখেছেন একটি ভাষার তিন স্তর; DSL-এর নকশায় তিনটিই ছোট করে আনা হয়: কম শব্দ, সরল অর্থ, একটি নির্দিষ্ট ব্যবহার।
আপনি সম্ভবত প্রতিদিন কয়েকটি DSL ব্যবহার করেন, নাম না জেনেই:
| DSL | জগৎ | ছোট নমুনা |
|---|---|---|
| SQL | ডেটাবেসে খোঁজা | SELECT id FROM orders WHERE qty >= 10 |
| Regular expression | লেখার ধাঁচ মেলানো | 01[3-9][0-9]{8} (১১ অঙ্কের মোবাইল নম্বরের ধাঁচ) |
| Make | কোন ফাইল কোনটি থেকে বানাতে হয় | app: main.o util.o |
| CSS | পাতার চেহারা | .price { color: green; } |
| HTML template | ডেটা বসিয়ে পাতা বানানো | <p>মোট: {{ total }} টাকা</p> |
| Build ফাইল (CMake প্রভৃতি) | বড় project compile করা | add_executable(app main.cpp) |
| Gherkin | পরীক্ষার দৃশ্য, সাধারণ ভাষায় | Given a cart with 2 items |
এদের বেশিরভাগ declarative: আপনি বলেন কী চাই, কীভাবে পাওয়া যাবে সেটি ভাষার বাস্তবায়ন ঠিক করে। Regex-এর তত্ত্ব আর বাস্তব engine ToC কোর্সের পর্ব ২১-এ, CSS selector-এর ছোট ভাষা HTML & CSS কোর্সের পর্ব ১৭-এ, SQL নিজে DBMS কোর্সের পর্ব ১২ থেকে, CMake C++ কোর্সের পর্ব ৪৯-এ আর Gherkin Software Testing কোর্সের পর্ব ৪৩-এ। এখানে প্রশ্ন একজন নকশাকারের: এমন ভাষা কীভাবে বানাবেন।
একটি ছোট উদাহরণ দেখা যাক, যা পরে বারবার ফিরবে। বাজারঘরের একটি ছাড়ের নিয়ম SQL-এর CASE দিয়ে লেখা যায়। লেখকের lab-এ CPython 3.14.4-এর sqlite3 module দিয়ে সত্যিকারের run (SQLite 3.50.4):
SELECT id, qty * unit AS subtotal,
CASE WHEN qty * unit >= 1000 THEN qty * unit * 10 / 100
WHEN qty >= 10 AND member = 1 THEN 50
ELSE 0 END AS discount
FROM orders ORDER BY idsqlite 3.50.4
(1, 1040, 104)
(2, 480, 50)
(3, 480, 0)
(4, 1200, 120)
চারটি অর্ডারের (২×৫২০, ১২×৪০ সদস্য, ১২×৪০ সাধারণ, ৩×৪০০ সদস্য) ছাড় ঠিকঠাক বেরিয়েছে, আর CASE-এর অর্থ হলো “ওপর থেকে প্রথম যে শর্ত মেলে”। কিন্তু বাজারঘরের ম্যানেজার, যিনি দোকান চালান, এই লেখা নিজে বদলাবেন না: qty * unit, member = 1, ELSE 0 END তাঁর জগতের শব্দ নয়। এই পর্বের কাজ: তাঁর জন্য একটি ভাষা।
২ · Internal বনাম external DSL
DSL বানানোর দুটি বড় পথ। External DSL একটি পুরো আলাদা ভাষা: নিজের লেখার নিয়ম, নিজের lexer আর parser, নিজের error message. SQL, regex, CSS, Make সবাই এই দলে। Internal DSL (embedded DSL নামেও পরিচিত) কোনো general-purpose ভাষার ভেতরে বাঁচে: শুধু একটি library, যার function আর method এমনভাবে সাজানো যে ব্যবহার করলে প্রায় একটি নতুন ভাষার মতো পড়া যায়। যে ভাষার ভেতরে সে থাকে, তাকে বলে host language. Internal DSL-এর প্রধান কৌশল দুটি: method chaining, যা থেকে আসে fluent interface (.discount(…).when(…)), আর operator overloading (qty >= 10 লিখলে সংখ্যা নয়, একটি শর্তের object তৈরি হয়)।
| প্রশ্ন | External DSL | Internal DSL |
|---|---|---|
| লেখার ধরন | পুরো স্বাধীন: বাংলা শব্দ, নিজের চিহ্ন | Host-এর syntax-এর ভেতরে যতটা সম্ভব |
| Parser | নিজে লিখতে হয় (পর্ব ৪৬–৫০) | Host-এর parser বিনামূল্যে |
| Error message | নিজের হাতে, ব্যবহারকারীর ভাষায় | Host-এর, প্রায়ই অপরিচিত বা নীরব |
| Editor, debugger, test | নিজে বানাতে হয় | Host-এর সব tool কাজ করে |
| ক্ষমতা | যতটুকু দেন, ততটুকুই (নিরাপদ) | Host-এর পুরো ক্ষমতা হাতের কাছে (সুবিধা ও ঝুঁকি) |
| কে লেখেন | প্রোগ্রামার নন এমন মানুষও | সাধারণত host জানা প্রোগ্রামার |
একটু ইতিহাস। Bell Labs-এ Stuart Feldman ১৯৭৬ সালে Make লেখেন, আর সেখানেই awk (১৯৭৭, Aho, Weinberger, Kernighan)-এর মতো ছোট ভাষা জন্মায়; Jon Bentley ১৯৮৬ সালে Communications of the ACM-এর “Programming Pearls” কলামে এদের নাম দেন little language. SQL-এর পূর্বসূরি SEQUEL ১৯৭৪ সালে IBM-এ, Chamberlin আর Boyce-এর হাতে। Internal DSL নিয়ে Paul Hudak-এর ১৯৯৬ সালের “Building Domain-Specific Embedded Languages” প্রায়ই উদ্ধৃত হয়, আর “internal/external” শব্দজোড়া জনপ্রিয় হয় Martin Fowler-এর ২০১০ সালের বই “Domain-Specific Languages” থেকে; “fluent interface” কথাটিও Fowler আর Eric Evans-এর বলে জানা যায় (২০০৫-এর কাছাকাছি)।
ছবি ৭৯.১ — একটি নিয়ম, দুই পথ
ওপরে external DSL ছাড়লিপি: নিজের lexer, parser আর checker, তারপর দুই রকম অর্থ (Haat-এ অনুবাদ আর সরাসরি interpreter), যাদের ফল মিলিয়ে দেখা হয়। নিচে internal DSL: parser হলো host ভাষা নিজেই
৩ · বাজারঘরের জন্য একটি ভাষা — ছাড়লিপি নকশা
ভাষা নকশা শুরু হয় মানুষ দিয়ে, কোড দিয়ে নয়; পর্ব ০৬-এর (ভাষা নকশার লক্ষ্য আর আপস) মাপকাঠিগুলো এবার একজন সত্যিকারের ব্যবহারকারীর ওপর। বাজারঘরের ম্যানেজার প্রতি সপ্তাহে অফার বদলান, আর বাংলায় ভাবেন: “হাজার টাকার বেশি কিনলে দশ শতাংশ ছাড়”। লক্ষ্য: তিনি নিজে নিয়ম লিখবেন, ভুল করলে বুঝবেন কী ভুল, আর তাঁর লেখা দোকানের বাকি system ভাঙতে পারবে না। সিদ্ধান্তগুলো এই লক্ষ্য থেকে:
(ক) শব্দভাণ্ডার ছোট আর বাংলা। Keyword: যদি তাহলে এবং অথবা না ছাড় ডেলিভারি টাকা. অর্ডারের তথ্য পাঁচটি নামে: পরিমাণ (কয়টি), দর (একটির দাম), মোট (পরিমাণ × দর), সদস্য (হ্যাঁ/না), দাম (ছাড়ের পরের দাম)। নতুন নাম বানানো যায় না।
(খ) এক লাইনে এক নিয়ম। যদি শর্ত তাহলে কাজ, অথবা শর্ত ছাড়া শুধু কাজ (“বাকি সবার জন্য”)। কাজ তিন রকম: ছাড় N%, ছাড় N টাকা, ডেলিভারি N টাকা.
(গ) অর্থ: প্রতিটি ধরনের (ছাড়, ডেলিভারি) জন্য ওপর থেকে নিচে প্রথম যে নিয়মের শর্ত মেলে, শুধু সেটি খাটে; কোনোটি না মিললে ০। শতাংশ হিসাব হয় মোট-এর ওপর, পূর্ণসংখ্যায়, ভগ্নাংশ বাদ। দাম জানা যায় ছাড়ের পরে, তাই শুধু ডেলিভারির নিয়মে চলে।
(ঘ) Loop, variable বা function নেই। তাই প্রতিটি হিসাব নিশ্চিতভাবে থামে, আর একটি ভুল নিয়ম বড়জোর ভুল টাকা দেখায়।
(ঙ) অঙ্ক বাংলা বা ইংরেজি (১০ আর 10 একই); তুলনার চিহ্ন < <= > >= == != Haat-এর মতো।
ম্যানেজারের প্রথম ফাইল bazar.chhar; প্রথম আর শেষ দুটি নিয়ম canonical bazar.haat-এর price আর delivery-রই কথা, দ্বিতীয়টি নতুন সদস্য-অফার:
// বাজারঘর: অর্ডারের নিয়ম
যদি মোট >= 1000 তাহলে ছাড় 10%
যদি পরিমাণ >= 10 এবং সদস্য তাহলে ছাড় 50 টাকা
যদি দাম >= 1000 তাহলে ডেলিভারি 0 টাকা
ডেলিভারি 60 টাকা২টি পণ্য × ৫২০, সদস্য নন: মোট ১০৪০, প্রথম নিয়মে ছাড় ১০৪, দাম ৯৩৬ (১০০০-এর কম), তাই ডেলিভারি ৬০: মোট ৯৯৬, ঠিক bazar.haat-এর প্রথম লাইন।
এবার লেখার নিয়মটি আনুষ্ঠানিকভাবে লেখা যাক, EBNF-এ। Grammar নকশার তত্ত্ব (ambiguity এড়ানো, precedence-এর স্তর, LL(1)-এর উপযোগী রূপ) ToC কোর্সের পর্ব ৪২-এ; এখানে শুধু ফল:
file = { [ rule ] NEWLINE } ;
rule = [ "যদি" cond "তাহলে" ] action ;
action = "ছাড়" NUM ( "%" | "টাকা" )
| "ডেলিভারি" NUM "টাকা" ;
cond = or ;
or = and { "অথবা" and } ;
and = not { "এবং" not } ;
not = "না" not | compare ;
compare = atom [ ( "<" | "<=" | ">" | ">=" | "==" | "!=" ) atom ] ;
atom = NUM | FIELD | "(" cond ")" ;
FIELD = "পরিমাণ" | "দর" | "মোট" | "সদস্য" | "দাম" ;
NUM = digit { digit } ; (* 0–9 বা ০–৯ *)
(* "//" থেকে লাইনের শেষ পর্যন্ত মন্তব্য *)লক্ষ করুন: compare-এ [ … ] মানে বড়জোর একটি তুলনা, তাই 500 <= মোট < 1000 চলে না (Haat-এর spec decision 10-এর মতো)। আর না বসেছে এবং-এর নিচে কিন্তু তুলনার ওপরে: না পরিমাণ >= 10 মানে “পরিমাণ ১০ বা বেশি নয়”, যেভাবে মানুষ পড়েন, Python-এর not-এর মতো; Haat-এর ! কিন্তু বাঁধে সবচেয়ে শক্ত করে। এই পার্থক্য অংশ ৫-এ একটি bug হয়ে ফিরবে।
বাংলা শব্দের একটি লুকোনো ফাঁদ। “ছাড়”-এর ড় Unicode-এ দুইভাবে লেখা যায়: একটি একক code point U+09DC, অথবা ড (U+09A1) আর নুক্তা (U+09BC). চোখে দুটি এক, কিন্তু string তুলনায় আলাদা। লেখকের lab-এ CPython 3.14.4 (Unicode 16.0.0), সত্যিকারের run: একক-রূপের “ছাড়” তিনটি code point, ভাঙা-রূপেরটি চারটি, a == b হলো False, আর unicodedata.normalize("NFC", a) == b হলো True. য় আর ঢ়-এরও একই সমস্যা, আর keyboard-ভেদে রূপ আলাদা; তাই lexer প্রথমেই পুরো লেখা NFC normalization-এ এক রূপে আনে। দাম: column গোনা হয় normalize করা লেখায়, তাই একক-রূপের “ছাড়”-এর পরে column এক ঘর বেশি দেখায়। Bangla string আর Unicode-এর বিস্তারিত পর্ব ২১-এ।
৪ · Lexer আর parser — পর্ব ৪৬–৪৮-এর কৌশল আবার
একটি external DSL-এর front end নতুন কিছু নয়; Haat-এর জন্য যা বানিয়েছেন, তা-ই ছোট করে। পর্ব ৪৬-এর lexer থেকে আসে তিনটি অভ্যাস: প্রতিটি token-এর সঙ্গে line:col; maximal munch, অর্থাৎ >= আগে চেষ্টা, তারপর >; আর আগে পুরো শব্দ পড়ে তারপর keyword-এর টেবিলে খোঁজা। নতুন যা: শব্দের অক্ষর বাংলা ব্লকের (U+0980–U+09FF), বাংলা অঙ্ক পড়ার সময়েই সংখ্যায় বদলায়, লাইনের শেষ (NL) একটি token, আর অচেনা শব্দও token হয় (WORD), যাতে parser ঠিক জায়গায় বার্তা দিতে পারে।
Parser দুই ভাগে, ঠিক Haat-এর মতো: নিয়মের কাঠামো পর্ব ৪৭-এর recursive descent (rule(): ঐচ্ছিক যদি … তাহলে, তারপর কাজ), আর শর্ত পর্ব ৪৮-এর Pratt parsing. শুধু binding power-এর টেবিল বদলায়:
| Operator | ছাড়লিপি | Haat (reference) |
|---|---|---|
অথবা / || | 10 | 10 |
এবং / && | 20 | 20 |
prefix না / ! (ডান দিক) | 30 | 70 |
তুলনা < <= > >= == != | 40 (এক স্তর, non-associative) | 30 আর 40 (দুই স্তর) |
+ - * / % | নেই | 50, 60 |
পুরো front end সহায়ক module chhar_front.py-তে; node-এর নাম reference-এর ast_nodes.py-র মতো (Num, Var, Unary, Binary), নতুন শুধু Rule. এতে সরাসরি interpreter evaluate()-ও আছে, পর্ব ৫৬-এর tree-walking ধাঁচে, যা নকশা-সিদ্ধান্ত (গ) হুবহু কোডে লেখে।
সহায়ক module chhar_front.py দেখুন (ব্লকগুলো এটি import করে)
# chhar_front.py — সহায়ক অংশ: ছাড়লিপির lexer (পর্ব ৪৬), parser (৪৭ + ৪৮-এর Pratt) আর সরাসরি interpreter.
import re, unicodedata
from dataclasses import dataclass
class DslError(Exception):
def __init__(self, line, col, msg): super().__init__(f"{line}:{col}: ভুল: {msg}"); self.at = (line, col)
@dataclass
class Token:
kind: str; text: str; line: int; col: int
def node(name, *fields): # শেষ দুটি ঘর line, col (reference-এর মতো)
return dataclass(type(name, (), {"__annotations__": {f: object for f in (*fields, "line", "col")}}))
Num, Var, Unary, Binary = node("Num", "value"), node("Var", "name"), node("Unary", "op", "operand"), node("Binary", "op", "left", "right")
Rule = node("Rule", "cond", "kind", "amount", "unit") # kind: ছাড় বা ডেলিভারি; unit: % বা টাকা
NFC = lambda s: unicodedata.normalize("NFC", s)
KEYWORDS = {NFC(w): w for w in "যদি তাহলে এবং অথবা না ছাড় ডেলিভারি টাকা".split()}
FIELDS = {NFC(w): t for w, t in [("পরিমাণ", "Int"), ("দর", "Int"), ("মোট", "Int"), ("সদস্য", "Bool"), ("দাম", "Int")]}
TOKEN = re.compile(r"(?P<sp>[ \t\r]+|//[^\n]*)|(?P<NL>\n)|(?P<NUM>[0-9০-৯]+)"
r"|(?P<WORD>[ঀ-ৰ-A-Za-z_]+)|(?P<OP>>=|<=|==|!=|[<>%()])")
BP = {"অথবা": 10, "এবং": 20, "==": 40, "!=": 40, "<": 40, "<=": 40, ">": 40, ">=": 40}
NOT_BP = 30 # না-এর ডান দিক: তুলনা ধরে, কিন্তু এবং/অথবা নয় (Python-এর not-এর মতো)
def tokenize(src):
src, toks, line, start, pos = NFC(src), [], 1, 0, 0
while pos < len(src):
m = TOKEN.match(src, pos)
if not m: raise DslError(line, pos - start + 1, f"অচেনা চিহ্ন '{src[pos]}'")
kind, text, col = m.lastgroup, m.group(), pos - start + 1
if kind == "NUM": text = str(int(text.translate(str.maketrans("০১২৩৪৫৬৭৮৯", "0123456789"))))
if kind == "WORD": kind = "KW" if text in KEYWORDS else "FIELD" if text in FIELDS else "WORD"
if kind != "sp": toks.append(Token(kind, text, line, col))
if kind == "NL": line, start = line + 1, m.end()
pos = m.end()
if not toks or toks[-1].kind != "NL": toks.append(Token("NL", "\n", line, pos - start + 1)) # শেষ লাইনেও নিয়ম শেষ
return toks + [Token("EOF", "", line + (pos > start), 1)]
class Parser:
def __init__(self, src): self.t, self.i = tokenize(src), 0
def peek(self): return self.t[self.i]
def next(self): self.i += 1; return self.t[self.i - 1]
def fail(self, tok, want):
got = "লাইনের শেষ" if tok.kind == "NL" else f"'{tok.text}'"
if tok.kind == "WORD": raise DslError(tok.line, tok.col, f"অচেনা শব্দ '{tok.text}'" + hint(tok.text))
raise DslError(tok.line, tok.col, f"{want} আশা ছিল, পাওয়া গেল {got}")
def expect(self, text, want):
if self.peek().text != text: self.fail(self.peek(), want)
return self.next()
def rules(self):
out = []
while self.peek().kind != "EOF":
if self.peek().kind == "NL": self.next(); continue
out.append(self.rule()); self.expect("\n", "নিয়মের পরে লাইনের শেষ")
return out
def rule(self):
first, cond = self.peek(), None
if first.text == "যদি": self.next(); cond = self.cond(); self.expect("তাহলে", "শর্তের পরে 'তাহলে'")
kind = self.next()
if kind.text not in ("ছাড়", "ডেলিভারি"): self.fail(kind, "'ছাড়' বা 'ডেলিভারি'")
num = self.next()
if num.kind != "NUM": self.fail(num, "একটি সংখ্যা")
unit = self.next()
if unit.text not in (("%", "টাকা") if kind.text == "ছাড়" else ("টাকা",)):
self.fail(unit, "'%' বা 'টাকা'" if kind.text == "ছাড়" else "'টাকা'")
return Rule(cond, kind.text, int(num.text), unit.text, first.line, first.col)
def cond(self, min_bp=0): # Pratt (পর্ব ৪৮): prefix অংশ, তারপর infix loop
tok = self.next()
if tok.kind == "NUM": left = Num(int(tok.text), tok.line, tok.col)
elif tok.kind == "FIELD": left = Var(tok.text, tok.line, tok.col)
elif tok.text == "না": left = Unary("না", self.cond(NOT_BP), tok.line, tok.col)
elif tok.text == "(": left = self.cond(); self.expect(")", "')'")
else: self.fail(tok, "একটি শর্ত (যেমন পরিমাণ >= 10)")
last = None
while (op := self.peek()).text in BP and BP[op.text] >= min_bp:
if BP[op.text] == 40 and last == 40: raise DslError(op.line, op.col, "দুটি তুলনা পরপর লেখা যায় না; 'এবং' দিয়ে আলাদা করুন")
self.next(); last = BP[op.text]
left = Binary(op.text, left, self.cond(BP[op.text] + 1), op.line, op.col)
return left
def distance(a, b): # Levenshtein: কয়টি অক্ষর বদলালে, ঢোকালে বা মুছলে a থেকে b
row = list(range(len(b) + 1))
for i, x in enumerate(a, 1):
prev, row[0] = row[0], i
for j, y in enumerate(b, 1):
prev, row[j] = row[j], min(row[j] + 1, row[j - 1] + 1, prev + (x != y))
return row[-1]
def hint(word): # সবচেয়ে কাছের চেনা শব্দ, দূরত্ব ছোট হলে
best = min((distance(word, k), k) for k in [*KEYWORDS, *FIELDS])
return f"; আপনি কি '{best[1]}' লিখতে চেয়েছিলেন?" if best[0] <= max(1, len(word) // 3) else ""
def parse(src): return Parser(src).rules()
def value(e, env): # সরাসরি interpreter: শর্তের মান
if isinstance(e, Num): return e.value
if isinstance(e, Var): return env[e.name]
if isinstance(e, Unary): return not value(e.operand, env)
if e.op == "এবং": return value(e.left, env) and value(e.right, env)
if e.op == "অথবা": return value(e.left, env) or value(e.right, env)
a, b = value(e.left, env), value(e.right, env)
return {"==": a == b, "!=": a != b, "<": a < b, "<=": a <= b, ">": a > b, ">=": a >= b}[e.op]
def evaluate(rules, qty, unit, member): # নিয়মের অর্থ: প্রতিটি ধরনের প্রথম মিলে যাওয়া নিয়ম জেতে
env = {"পরিমাণ": qty, "দর": unit, "মোট": qty * unit, "সদস্য": member}
def first(kind):
for r in rules:
if r.kind == kind and (r.cond is None or value(r.cond, env)):
return env["মোট"] * r.amount // 100 if r.unit == "%" else r.amount
return 0
env["দাম"] = env["মোট"] - first("ছাড়")
return env["দাম"] + first("ডেলিভারি")চাবি দুটি লাইনে। cond()-এর while-এ operator বাঁধে যদি শক্তি ≥ min_bp, আর ডান দিক পড়া হয় BP + 1 দিয়ে (left-associative). না-এর ডান দিক cond(NOT_BP), শক্তি ৩০: তুলনা (৪০) সে গিলে নেয়, এবং (২০) নয়। নিচে bazar.chhar-এর তৃতীয় লাইনটি পুরো পথ পার হয়।
- উৎস
bazar.chhar:3ম্যানেজারের লেখা - Lexer
tokenশব্দ চেনা - Parser
ASTPratt-এর সিদ্ধান্ত - Checker
Bool?ধরন যাচাই - অনুবাদ
Haatreference-এ চলে
যদি পরিমাণ >= 10 এবং সদস্য তাহলে ছাড় 50 টাকা
3:1 KW যদি 3:5 FIELD পরিমাণ 3:12 OP >= 3:15 NUM 10 3:18 KW এবং 3:22 FIELD সদস্য 3:28 KW তাহলে 3:34 KW ছাড় 3:39 NUM 50 3:42 KW টাকা 3:46 NL
prefix: পরিমাণ → Var >= শক্তি 40 ≥ 0 → বাঁধে, ডান দিক cond(41) prefix: 10 → Num এবং 20 < 41 → থামে, ফেরত 10 বাঁ দিক এখন (>= পরিমাণ 10) এবং 20 ≥ 0 → বাঁধে, ডান দিক cond(21) prefix: সদস্য → Var তাহলে operator নয় → ফেরত তাহলে → শর্ত শেষ
Rule(kind=ছাড়, amount=50, unit=টাকা) └─ Binary এবং → Bool ├─ Binary >= → Bool │ ├─ Var পরিমাণ : Int │ └─ Num 10 : Int └─ Var সদস্য : Bool
if (qty >= 10) && member { return 50; } // bazar.chhar:3
- উৎস। ম্যানেজারের লেখা একটি বাংলা বাক্যের মতো: দশ বা বেশি, আর সদস্য হলে পঞ্চাশ টাকা ছাড়।
- Lexer-এর ধাপ। NFC-র পরে এগারোটি token. শব্দ আগে পুরো পড়া হয়, তারপর টেবিলে:
যদিkeyword,পরিমাণFIELD. Column গোনা code point-এ, তাই>=১২ নম্বর ঘরে। - Pratt-এর সিদ্ধান্ত।
>=-এর শক্তি ৪০ ≥ ০, তাই বাঁধে, ডান দিক ৪১ দিয়ে; সেখানেএবং-এর ২০ কম, তাই ১০ একা ফেরে। বাইরের loop-এএবংবাঁধে, ডানেসদস্য;তাহলে-তে শর্ত শেষ। - ধরন যাচাই। নিচ থেকে ওপরে: পরিমাণ আর ১০ সংখ্যা, তাই
>=হ্যাঁ/না;এবং-এর দুই পাশে হ্যাঁ/না. শর্ত Bool, ভুল নেই। - অনুবাদ। নামগুলো Haat-এর ASCII নামে (Haat-এর spec decision 4),
এবংহয়&&, ভেতরের তুলনা বন্ধনীতে, আর শেষে উৎসের ঠিকানা।
৫ · অর্থ দেওয়া — Haat-এ অনুবাদ
একটি ভাষার semantics (অর্থ) দেওয়ার দুটি সহজ পথ। এক, একটি interpreter: evaluate() নিয়ম পড়ে পড়ে হিসাব করে। দুই, অনুবাদের মাধ্যমে অর্থ: নিয়ম-ফাইলকে এমন একটি ভাষায় অনুবাদ করা যার অর্থ আগেই জানা, এখানে Haat. তখন ছাড়লিপির একটি program যা করে, তা হলো তার Haat-অনুবাদ যা করে। এটি একধরনের transpiler, আর ধারণাটি পর্ব ৫৫-এর desugaring-এর আত্মীয়: সেখানে বড় ভাষা নিজের ছোট core-এ নামত, এখানে একটি আলাদা ছোট ভাষা অন্য একটি ভাষায় যায়। লাভ: Haat-এর type checker, interpreter, VM আর পরের সব back end বিনামূল্যে।
# ছাড়লিপি → Haat: নিয়মের অর্থ দেওয়া হয় অনুবাদ দিয়ে (semantics by translation)
from chhar_front import *
NAME = {"পরিমাণ": "qty", "দর": "unit", "মোট": "subtotal", "সদস্য": "member", "দাম": "price"}
OP = {"এবং": "&&", "অথবা": "||"} # তুলনার চিহ্ন দুই ভাষায় এক
def expr(e): # শর্তের AST → Haat expression
if isinstance(e, Num): return str(e.value)
if isinstance(e, Var): return NAME[e.name]
if isinstance(e, Unary): return "!" + paren(e.operand)
return f"{paren(e.left)} {OP.get(e.op, e.op)} {paren(e.right)}"
def paren(e): return f"({expr(e)})" if isinstance(e, Binary) else expr(e) # দুই ভাষার precedence আলাদা
def function(rules, kind, name, params, file):
out = [f"fn {name}({params}) -> Int {{", " let subtotal = qty * unit;"]
for r in (r for r in rules if r.kind == kind):
amount = f"subtotal * {r.amount} / 100" if r.unit == "%" else str(r.amount)
where = f" // {file}:{r.line}" # উৎসের ঠিকানা, পরে খুঁজে পেতে
if r.cond is None: return out + [f" return {amount};{where}", "}"] # শর্তহীন: শেষ নিয়ম
out.append(f" if {expr(r.cond)} {{ return {amount}; }}{where}")
return out + [" return 0;", "}"]
def to_haat(rules, orders, file="bazar.chhar"):
p = "qty: Int, unit: Int, member: Bool"
lines = [f"// {file} থেকে তৈরি; হাতে বদলাবেন না"]
lines += function(rules, "ছাড়", "discount", p, file)
lines += function(rules, "ডেলিভারি", "delivery", p + ", price: Int", file)
lines += ["fn total(qty: Int, unit: Int, member: Bool) -> Int {",
" let price = qty * unit - discount(qty, unit, member);",
" return price + delivery(qty, unit, member, price);", "}"]
return "\n".join(lines + [f"print(total({q}, {u}, {str(m).lower()}));" for q, u, m in orders]) + "\n"
ORDERS = [(2, 520, False), (12, 40, True), (12, 40, False), (3, 400, True)]
rules = parse(open("bazar.chhar", encoding="utf-8").read())
print(to_haat(rules, ORDERS))
print("সরাসরি interpreter:", [evaluate(rules, *o) for o in ORDERS])আসল আউটপুট (ব্রাউজারের Python):
// bazar.chhar থেকে তৈরি; হাতে বদলাবেন না
fn discount(qty: Int, unit: Int, member: Bool) -> Int {
let subtotal = qty * unit;
if subtotal >= 1000 { return subtotal * 10 / 100; } // bazar.chhar:2
if (qty >= 10) && member { return 50; } // bazar.chhar:3
return 0;
}
fn delivery(qty: Int, unit: Int, member: Bool, price: Int) -> Int {
let subtotal = qty * unit;
if price >= 1000 { return 0; } // bazar.chhar:4
return 60; // bazar.chhar:5
}
fn total(qty: Int, unit: Int, member: Bool) -> Int {
let price = qty * unit - discount(qty, unit, member);
return price + delivery(qty, unit, member, price);
}
print(total(2, 520, false));
print(total(12, 40, true));
print(total(12, 40, false));
print(total(3, 400, true));
সরাসরি interpreter: [996, 490, 540, 1080]
প্রতিটি ধরনের নিয়ম একটি Haat function, আর নিয়মগুলো পরপর if … { return …; }: প্রথম সত্য শর্তের return বেরিয়ে যায়, তাই “প্রথম মিল জেতে” আপনাআপনি সত্য। শর্তহীন শেষ নিয়ম হয় সরাসরি return 60;, ফলে Haat-এর missing-return নিয়ম (spec decision 21) মানা হয়। লাইনের শেষের // bazar.chhar:3 একটি ছোট source map: উৎপন্ন কোডে ভুল দেখলে আসল নিয়ম খুঁজে পাওয়া যায়। সরাসরি interpreter-ও একই চারটি সংখ্যা দিয়েছে।
Haat-এর আসল অর্থ বলে reference implementation. উপরের Haat লেখাটি লেখকের lab-এ একটি ফাইলে রেখে সত্যিকারের run:
$ python -B haat.py check bazar_rules.haat
ok
$ python -B haat.py run bazar_rules.haat
996
490
540
1080
Reference-এর সব static check অনুবাদ গ্রহণ করেছে, আর একই চারটি সংখ্যা এসেছে। এবার paren()-এর কাজ দেখা যাক। ধরুন ম্যানেজার লিখলেন যদি না পরিমাণ >= 10 তাহলে ছাড় 20 টাকা, “বারোর কম কিনলে বিশ টাকা”। ছাড়লিপিতে না পুরো তুলনাকে ঘিরে ধরে। কিন্তু অনুবাদক যদি অন্ধভাবে "!" + expr(…) লিখত, ফল হতো !qty >= 10, আর Haat-এ ! সবচেয়ে শক্ত করে বাঁধে। সেই এক লাইনের Haat ফাইল reference-এ, সত্যিকারের run:
$ python -B haat.py run naive_not.haat
3:8: error: type mismatch: expected Int, found Bool
3:9: error: type mismatch: expected Bool, found Int
Haat !qty-কে আগে বেঁধেছে: !-এর Bool লাগে (3:9), আর !qty-এর Bool ফল >=-এ Int-এর জায়গায় (3:8). বন্ধনী দিলে (!(qty >= 10)) একই ফাইল চলে আর ছাপে 20. শিক্ষা: উৎস আর লক্ষ্য ভাষার precedence আলাদা হলে অনুবাদককে বন্ধনী দিয়ে গাছের আকার রক্ষা করতে হয়; paren() প্রতিটি Binary সন্তানকে বন্ধনীতে মোড়ে। এখানে type মেলেনি বলে ভুল ধরা পড়ল; অংশ ৭-এ দেখবেন কিছু রূপ type মেলায় আর চুপচাপ ভুল টাকা দেখায়।
৬ · ভুল হলে — প্রোগ্রামার নন এমন মানুষের জন্য error message
DSL-এর ব্যবহারকারী compiler-এর বার্তায় অভ্যস্ত নন; expected FIELD, found WORD তাঁর কাছে অর্থহীন। পর্ব ৫০-এর ভালো diagnostic-এর গুণ (কোথায়, কী আশা ছিল, একটি মূল কথা)-এর সঙ্গে DSL-এ আরও দুটি লাগে: ব্যবহারকারীর নিজের শব্দ (“সংখ্যা”, “হ্যাঁ/না”), আর সমাধানের ইঙ্গিত। বাংলায় সবচেয়ে সাধারণ ভুল বানান: ী বনাম ি, ন বনাম ণ. তাই অচেনা শব্দ পেলে hint() প্রতিটি চেনা শব্দের সঙ্গে Levenshtein distance মাপে (কয়টি অক্ষর বদলালে, ঢোকালে বা মুছলে এক শব্দ অন্যটি হয়), আর দূরত্ব ছোট হলে প্রস্তাব দেয়। Parse-এর পরে checker দেখে শর্তের ধরন, দাম-এর ভুল ব্যবহার আর কখনো-না-খাটা নিয়ম।
# ছাড়লিপির checker: type আর নিয়মের যুক্তি, দোকানের ম্যানেজারের ভাষায় বার্তা
from chhar_front import *
KIND = {"Int": "সংখ্যা", "Bool": "হ্যাঁ/না"}
def start(e): return start(e.left) if isinstance(e, Binary) else (e.line, e.col)
def typ(e, kind, errs): # শর্তের ধরন; ভুল পেলে errs-এ (জায়গা, বার্তা)
if isinstance(e, Num): return "Int"
if isinstance(e, Var):
if e.name == "দাম" and kind == "ছাড়": errs.append((start(e), "'দাম' জানা যায় ছাড়ের পরে, তাই ছাড়ের নিয়মে এটি চলে না"))
return FIELDS[e.name]
parts = [e.operand] if isinstance(e, Unary) else [e.left, e.right]
got = [typ(p, kind, errs) for p in parts]
if e.op in ("==", "!="):
if got[0] != got[1]: errs.append((start(e), f"'{e.op}'-এর দুই পাশে একই ধরন লাগে, এখানে {KIND[got[0]]} আর {KIND[got[1]]}"))
else:
want = "Int" if e.op in ("<", "<=", ">", ">=") else "Bool"
for p, g in zip(parts, got):
if g != want: errs.append((start(p), f"'{e.op}'-এর পাশে {KIND[want]} লাগে, কিন্তু এটি {KIND[g]}"))
return "Bool"
def check(rules): # পুরো ফাইল: শর্তের ধরন আর নিয়মের ক্রম
errs, catch_all = [], {}
for r in rules:
if r.kind in catch_all:
errs.append(((r.line, r.col), f"এই নিয়ম কখনো খাটবে না: লাইন {catch_all[r.kind]}-এর শর্তহীন নিয়ম আগেই সব অর্ডার ধরে ফেলে"))
if r.cond is None: catch_all.setdefault(r.kind, r.line)
elif typ(r.cond, r.kind, errs) != "Bool": errs.append((start(r.cond), "শর্তের ফল হ্যাঁ/না হতে হবে, কিন্তু এটি একটি সংখ্যা"))
return sorted(errs)
def report(name, src): # error-এর সঙ্গে লাইনটি হুবহু; caret নয় (কারণ লেখায় দেখুন)
try: errs = check(parse(src)) or [((0, 0), "ঠিক আছে")]
except DslError as e: errs = [(e.at, str(e).split(": ভুল: ")[1])]
for (l, c), msg in errs:
print(f"{name}:{l}:{c}: ভুল: {msg}" if l else f"{name}: {msg}")
if l: print(f" {l} │ {NFC(src).splitlines()[l - 1]}")
for part in open("mistakes.chhar", encoding="utf-8").read().split("### ")[1:]: report(*part.split("\n", 1))আসল আউটপুট (ব্রাউজারের Python; mistakes.chhar-এ সাতটি ছোট ভুল ফাইল):
বানান-১:1:1: ভুল: অচেনা শব্দ 'যদী'; আপনি কি 'যদি' লিখতে চেয়েছিলেন?
1 │ যদী মোট >= 1000 তাহলে ছাড় 10%
বানান-২:2:5: ভুল: অচেনা শব্দ 'পরিমান'; আপনি কি 'পরিমাণ' লিখতে চেয়েছিলেন?
2 │ যদি পরিমান >= ১০ তাহলে ছাড় ৫%
ধরন:1:5: ভুল: '>='-এর পাশে সংখ্যা লাগে, কিন্তু এটি হ্যাঁ/না
1 │ যদি সদস্য >= 10 তাহলে ছাড় 5%
দাম:1:5: ভুল: 'দাম' জানা যায় ছাড়ের পরে, তাই ছাড়ের নিয়মে এটি চলে না
1 │ যদি দাম >= 500 তাহলে ছাড় 20 টাকা
তাহলে:1:17: ভুল: শর্তের পরে 'তাহলে' আশা ছিল, পাওয়া গেল 'ছাড়'
1 │ যদি মোট >= 1000 ছাড় 10%
দুই-তুলনা:1:16: ভুল: দুটি তুলনা পরপর লেখা যায় না; 'এবং' দিয়ে আলাদা করুন
1 │ যদি 500 <= মোট < 1000 তাহলে ছাড় 5%
ক্রম:2:1: ভুল: এই নিয়ম কখনো খাটবে না: লাইন 1-এর শর্তহীন নিয়ম আগেই সব অর্ডার ধরে ফেলে
2 │ যদি দাম >= 1000 তাহলে ডেলিভারি 0 টাকা
সাতটি বার্তা, সাত রকম ভুল। প্রথম দুটি বানান: “যদী” আর “পরিমান” দুটিরই চেনা শব্দ থেকে দূরত্ব ১, তাই প্রস্তাব এসেছে। তৃতীয়টির ভাষা ম্যানেজারের (“সংখ্যা”, “হ্যাঁ/না”), চতুর্থটি নকশা-সিদ্ধান্ত (গ) থেকে, পঞ্চম আর ষষ্ঠ বলে কী আশা ছিল বা কী করতে হবে। সপ্তমটি সবচেয়ে মূল্যবান: grammar-এ ভুল নেই, ধরনেও নেই, তবু নিয়মটি অর্থহীন, কারণ ওপরের শর্তহীন নিয়ম আগেই সব অর্ডার ধরে ফেলে। এটি পর্ব ৫৪-এর unreachable code-এর DSL-রূপ, আর “প্রথম মিল জেতে” নিয়মে এই ক্রমের ভুলটিই বাস্তবে সবচেয়ে বেশি হয়।
লক্ষ করুন, বার্তার নিচে লাইনটি হুবহু থাকে, কিন্তু rustc-এর মতো ^ চিহ্ন নেই। বাংলায় column আর চোখের অবস্থান এক নয়: ি, া, ্ আলাদা code point হলেও পাশের অক্ষরের সঙ্গে জুড়ে বসে; “পরিমাণ” ছয়টি code point, চোখে চারটি অক্ষর, তাই caret ভুল জায়গায় পড়ত। Font জানা একটি editor (পর্ব ৮০) ঠিক অক্ষরের নিচে দাগ টানতে পারে।
1ডেলিভারি 60 টাকা2যদি পরিমান >= ১০ তাহলে ছাড় ৫%
| ধাপ | |
| দেখা জিনিস | |
| সিদ্ধান্ত |
- শব্দ চেনা। লেখা NFC-তে আসে। “পরিমান” keyword বা FIELD-এর টেবিলে নেই, তবু lexer থামে না: একটি
WORDtoken বানায়, 2:5-এ। বাংলা “১০” পড়ার সময়েই 10 হয়ে যায়। - নিয়মের শুরু। প্রথম token
যদি, তাই parser জানে একটি শর্ত আসছে, আর Pratt-এরcond()ডাকে। - শর্তের শুরুতে অচেনা শব্দ। Prefix অংশে সংখ্যা, FIELD,
নাবা(চলত; WORD চলে না।fail()দেখে token-টি WORD, তাই সাধারণ “আশা ছিল …” না বলে “অচেনা শব্দ” বলে আরhint()ডাকে। - দূরত্ব মাপা। তেরোটি চেনা শব্দের প্রতিটির সঙ্গে Levenshtein distance. “পরিমাণ”-এর সঙ্গে ১ (শুধু ন → ণ), বাকি সবার সঙ্গে ৫ বা বেশি। সীমা হলো শব্দের দৈর্ঘ্যের এক-তৃতীয়াংশ, কমপক্ষে ১: ছয় code point-এর শব্দে ২। ১ সীমার ভেতরে, তাই প্রস্তাব।
- বার্তা। ফাইলের নাম, লাইন আর column, ম্যানেজারের ভাষায় কারণ আর প্রস্তাব, তারপর লাইনটি হুবহু। Parser প্রথম ভুলেই থামে; ছোট নিয়ম-ফাইলে পর্ব ৫০-এর panic-mode recovery-র দরকার কম।
- যেখানে কৌশলটি হারে। “ছাড়”-কে কেউ লিখলেন “ছার”। ড় দুটি code point (ড আর নুক্তা), তাই দূরত্ব ২, আর “দর”, “দাম”, “না”-র সঙ্গেও ২। তিন code point-এর শব্দে সীমা ১, তাই কোনো প্রস্তাব নেই: সত্যিকারের run-এ শুধু
1:23: ভুল: অচেনা শব্দ 'ছার'. Code point গুনে দূরত্ব মাপা মানুষের চোখের দূরত্ব নয় (ভাবনার প্রশ্ন ০৪)।
৭ · অনুবাদ কি ঠিক? — ২০০টি উৎপন্ন নিয়ম-ফাইলে differential test
চারটি অর্ডারে মিল ভালো লক্ষণ, প্রমাণ নয়। Differential testing-এ (পর্ব ৪৬, ৪৭) এবার দুই পক্ষ সরাসরি interpreter আর Haat-অনুবাদ। পরীক্ষার ফাইল আসে grammar থেকেই, grammar-based fuzzing-এর ধাঁচে: cond() এলোমেলো শর্ত লেখে (বন্ধনী, না, বাংলা অঙ্কসহ), gen() নিয়ম আর পাঁচটি অর্ডার; লেখা হিসেবে তৈরি বলে lexer আর parser-ও পরীক্ষিত হয়। বাস্তব tool Software Testing কোর্সের পর্ব ৫৮-এ।
উৎপন্ন Haat ব্রাউজারে চালায় সহায়ক haat_mini.py: Haat-এর শুধু অনুবাদকের লেখা অংশ, reference-এর নিয়মে (C-ধাঁচের /, 64-bit wrap) মেনে। নিজের interpreter-কেও অন্ধ বিশ্বাস নয়: লেখকের lab-এ একই ২০০টি program সত্যিকারের reference-এ (python -B haat.py run) চালিয়ে প্রতিটির SHA-1 hash-এর প্রথম দশ অক্ষর আর আউটপুট রাখা আছে ref_runs.txt-এ; hash মিললে নিশ্চিত, ব্রাউজারে ঠিক সেই program-ই তৈরি হয়েছে।
সহায়ক module haat_mini.py দেখুন (Haat-এর ছোট উপসেটের interpreter)
# haat_mini.py — সহায়ক অংশ: অনুবাদকের লেখা ধরনের Haat (top-level fn, let, if/else, return, print, call,
# Int/Bool) চালানোর ছোট tree-walking interpreter, reference-এর নিয়মে। Type checker নেই; lab-এ reference-এর সঙ্গে মেলানো।
import re
TOK = re.compile(r"\s+|//[^\n]*|(\d+|[A-Za-z_]\w*|==|!=|<=|>=|&&|\|\||->|[-+*/%<>!=(){},;:])")
BP = {"||": 10, "&&": 20, "==": 30, "!=": 30, "<": 40, "<=": 40, ">": 40, ">=": 40, "+": 50, "-": 50, "*": 60, "/": 60, "%": 60}
def wrap(n): return (n + 2**63) % 2**64 - 2**63
def c_div(a, b): q = abs(a) // abs(b); return wrap(q if (a < 0) == (b < 0) else -q)
class Return(Exception): pass
class Mini:
def __init__(self, src):
self.t = [m.group(1) for m in TOK.finditer(src) if m.group(1)] + ["<eof>"]; self.i = 0
self.fns, self.out = {}, []
def eat(self, want=None):
tok = self.t[self.i]; self.i += 1
assert want is None or tok == want, f"expected {want}, found {tok}"
return tok
def block(self): # { … } → statement-এর তালিকা
self.eat("{"); body = []
while self.t[self.i] != "}": body.append(self.stmt())
self.eat("}"); return body
def stmt(self):
t = self.t[self.i]
if t == "fn":
self.eat(); name = self.eat(); self.eat("("); ps = []
while self.t[self.i] != ")":
ps.append(self.eat()); self.eat(":"); self.eat()
if self.t[self.i] == ",": self.eat()
self.eat(")"); self.eat("->"); self.eat(); return ("fn", name, ps, self.block())
if t == "let": self.eat(); n = self.eat(); self.eat("="); e = self.expr(); self.eat(";"); return ("let", n, e)
if t == "if":
self.eat(); c = self.expr(); th = self.block(); el = []
if self.t[self.i] == "else": self.eat(); el = [self.stmt()] if self.t[self.i] == "if" else self.block()
return ("if", c, th, el)
if t in ("return", "print"): self.eat(); e = self.expr(); self.eat(";"); return (t, e)
e = self.expr(); self.eat(";"); return ("expr", e)
def expr(self, min_bp=0): # Pratt (পর্ব ৪৮)
t = self.eat()
if t == "(": left = self.expr(); self.eat(")")
elif t in ("-", "!"): left = (t, self.expr(70))
elif t.isdigit(): left = ("num", int(t))
elif t in ("true", "false"): left = ("num", t == "true")
else: left = ("var", t)
while True:
op = self.t[self.i]
if op == "(":
self.eat(); args = []
while self.t[self.i] != ")":
args.append(self.expr())
if self.t[self.i] == ",": self.eat()
self.eat(")"); left = ("call", left, args); continue
if op not in BP or BP[op] < min_bp: return left
self.eat(); left = (op, left, self.expr(BP[op] + 1))
def ev(self, e, env):
k = e[0]
if k == "num": return e[1]
if k == "var": return env[e[1]] if e[1] in env else self.fns[e[1]]
if k == "call":
ps, body = self.ev(e[1], env); args = [self.ev(a, env) for a in e[2]]
try: self.run(body, dict(zip(ps, args)))
except Return as r: return r.args[0]
if k == "!": return not self.ev(e[1], env)
if len(e) == 2: return wrap(-self.ev(e[1], env))
if k == "&&": return self.ev(e[1], env) and self.ev(e[2], env)
if k == "||": return self.ev(e[1], env) or self.ev(e[2], env)
a, b = self.ev(e[1], env), self.ev(e[2], env)
if k in ("/", "%") and b == 0: raise ZeroDivisionError("division by zero")
return {"+": lambda: wrap(a + b), "-": lambda: wrap(a - b), "*": lambda: wrap(a * b), "/": lambda: c_div(a, b),
"%": lambda: wrap(a - b * c_div(a, b)), "==": lambda: a == b, "!=": lambda: a != b, "<": lambda: a < b,
"<=": lambda: a <= b, ">": lambda: a > b, ">=": lambda: a >= b}[k]()
def run(self, stmts, env):
for s in stmts:
if s[0] == "let": env[s[1]] = self.ev(s[2], env)
elif s[0] == "if": self.run(s[2] if self.ev(s[1], env) else s[3], env)
elif s[0] == "return": raise Return(self.ev(s[1], env))
elif s[0] == "print": v = self.ev(s[1], env); self.out.append(("true" if v else "false") if isinstance(v, bool) else str(v))
elif s[0] == "expr": self.ev(s[1], env)
def run_haat(src): # program-এর print-গুলোর লেখা, তালিকা হিসেবে
m = Mini(src); prog = []
while m.t[m.i] != "<eof>": prog.append(m.stmt())
m.fns = {s[1]: (s[2], s[3]) for s in prog if s[0] == "fn"} # top-level fn আগেই দৃশ্যমান
m.run([s for s in prog if s[0] != "fn"], {})
return m.out# Differential test: সরাসরি interpreter বনাম Haat-এ অনুবাদ, এলোমেলো কিন্তু বৈধ ২০০টি নিয়ম-ফাইলে
import random, hashlib
from haat_mini import run_haat
BN = str.maketrans("0123456789", "০১২৩৪৫৬৭৮৯")
def num(rng, n): return str(n).translate(BN) if rng.random() < 0.3 else str(n) # বাংলা অঙ্কও চলে
def cond(rng, depth, kind): # এলোমেলো শর্ত, লেখা হিসেবে (grammar থেকে)
if depth == 0 or rng.random() < 0.4:
if rng.random() < 0.2: return rng.choice(["সদস্য", "না সদস্য"])
f, top = rng.choice([("পরিমাণ", 30), ("দর", 900), ("মোট", 6000)] + [("দাম", 6000)] * (kind == "ডেলিভারি"))
return f"{f} {rng.choice(['<', '<=', '>', '>=', '==', '!='])} {num(rng, rng.randint(1, top))}"
op = rng.choice(["এবং", "অথবা", "না"])
if op == "না": return f"না ({cond(rng, depth - 1, kind)})"
return f"({cond(rng, depth - 1, kind)}) {op} ({cond(rng, depth - 1, kind)})"
def gen(seed): # একটি নিয়ম-ফাইল আর পাঁচটি অর্ডার
rng, lines = random.Random(seed), []
for kind in ("ছাড়", "ডেলিভারি"):
for k in range(rng.randint(0, 3)):
act = (f"ছাড় {num(rng, rng.randint(1, 50))}%" if rng.random() < 0.5 else f"ছাড় {num(rng, rng.randint(10, 300))} টাকা") if kind == "ছাড়" else f"ডেলিভারি {num(rng, rng.randint(0, 120))} টাকা"
lines.append(act if rng.random() < 0.2 else f"যদি {cond(rng, 2, kind)} তাহলে {act}")
if not lines[-1].startswith("যদি"): break # শর্তহীন নিয়মের পরে আর নয়
orders = [(rng.randint(1, 30), rng.randint(10, 900), rng.random() < 0.5) for _ in range(5)]
return "\n".join(lines) + "\n", orders
ref = {int(i): (h, out.split(",")) for i, h, out in (l.split() for l in open("ref_runs.txt", encoding="utf-8"))}
same_mini = same_ref = rules_total = 0
for seed in range(200):
src, orders = gen(seed)
rules = parse(src); assert not check(rules), src; rules_total += len(rules)
want = [str(evaluate(rules, *o)) for o in orders]
haat = to_haat(rules, orders, f"r{seed}.chhar")
same_mini += run_haat(haat) == want
h, out = ref[seed]
same_ref += h == hashlib.sha1(haat.encode()).hexdigest()[:10] and out == want
print(f"নিয়ম-ফাইল 200টি, মোট নিয়ম {rules_total}টি, অর্ডার {200 * 5}টি")
print(f"haat_mini-র সঙ্গে মিল: {same_mini}/200 ফাইল")
print(f"সত্যিকারের reference-এর (lab-এ চালানো) সঙ্গে মিল: {same_ref}/200 ফাইল\n\nউদাহরণ, seed 15:\n" + gen(15)[0])আসল আউটপুট (ব্রাউজারের Python; আগের দুটি ব্লক নিজে থেকে আগে চলে, কারণ to_haat আর check সেখানে):
নিয়ম-ফাইল 200টি, মোট নিয়ম 508টি, অর্ডার 1000টি
haat_mini-র সঙ্গে মিল: 200/200 ফাইল
সত্যিকারের reference-এর (lab-এ চালানো) সঙ্গে মিল: 200/200 ফাইল
উদাহরণ, seed 15:
যদি সদস্য তাহলে ছাড় ৪৮%
যদি মোট <= 1691 তাহলে ডেলিভারি ৩০ টাকা
যদি (দাম >= 647) অথবা ((দাম >= 540) অথবা (পরিমাণ <= 5)) তাহলে ডেলিভারি 102 টাকা
২০০টি ফাইল, ৫০৮টি নিয়ম, ১০০০টি অর্ডার: সরাসরি interpreter, ব্রাউজারের haat_mini আর সত্যিকারের reference তিনজনই প্রতিটি ফাইলে একমত, আর lab-এ reference একটিতেও error দেয়নি। Seed 15-এর ফাইলে দেখুন grammar থেকে কী আসে: মেশানো অঙ্ক, বন্ধনীর ভেতরে বন্ধনী, যা কেউ হাতে লিখতেন না।
এই পরীক্ষা কতটা ধারালো? লেখকের lab-এ paren()-কে বন্ধনী ছাড়া রূপে বদলে একই ২০০টি ফাইল চালানো হয়েছে। ১৩৩টি ফাইলে অনুবাদের লেখা বদলেছে; সত্যিকারের reference তাদের ৯৬টিতে type error দিয়েছে (অংশ ৫-এর মতো), ১৩টিতে কোনো error ছাড়াই ভুল সংখ্যা দিয়েছে, আর ২৪টিতে কাকতালীয়ভাবে ঠিক। চুপচাপ ভুলের ধাঁচটি এরকম: ছাড়লিপির (ক অথবা খ) এবং গ বন্ধনী হারিয়ে Haat-এ হয় ক || খ && গ, যার অর্থ ক || (খ && গ); দুই দিকের ধরনই Bool, তাই type checker কিছু বলে না। সেই ১৩টি ফাইল ধরতে পারে শুধু differential test.
যা differential test ধরে না। দুই বাস্তবায়ন একই ভুল নকশা মানলে মিলবেই। ১০০০টি অর্ডারের ঠিক একটিতে (seed 5) টাকায়-ছাড় মোটের চেয়ে বড়, দাম ঋণাত্মক, আর তিন পক্ষই তাতে একমত: এটি ভাষার অর্থের ফাঁক (অনুশীলন ১)।
৮ · Internal DSL — একই নিয়ম host ভাষার ভেতরে
নিয়ম যদি প্রোগ্রামাররাই লেখেন, JavaScript-এর ভেতরেই সেগুলো প্রায় বাক্যের মতো লেখা যায়: প্রতিটি method একই object ফেরত দেয়, তাই শিকল চলে। নিয়ম বদলে আবার চালিয়ে দেখুন।
// Internal DSL: একই নিয়ম, JavaScript-এর ভেতরে (fluent interface). নিয়ম বদলে আবার চালিয়ে দেখুন।
const cond = test => ({ test, and: c => cond(o => test(o) && c.test(o)),
or: c => cond(o => test(o) || c.test(o)) });
const field = name => ({ name, test: o => o[name], // Bool field সরাসরি শর্ত
atLeast: n => cond(o => o[name] >= n), below: n => cond(o => o[name] < n) });
const not = c => cond(o => !c.test(o));
const [qty, unit, subtotal, member, price] = ["qty", "unit", "subtotal", "member", "price"].map(field);
const percent = n => o => Math.trunc(o.subtotal * n / 100), taka = n => () => n;
function shop() {
const rules = [], api = {
discount: amount => add("discount", amount), delivery: amount => add("delivery", amount),
when: c => { rules[rules.length - 1].c = c; return api; }, rules };
const add = (kind, amount) => { rules.push({ kind, amount, c: null }); return api; };
return api;
}
function total(shop, o) { // প্রতিটি ধরনের প্রথম মিল জেতে
const first = kind => { const r = shop.rules.find(r => r.kind === kind && (!r.c || r.c.test(o)));
return r ? r.amount(o) : 0; };
o = { ...o, subtotal: o.qty * o.unit };
o.price = o.subtotal - first("discount");
return o.price + first("delivery");
}
const bazar = shop()
.discount(percent(10)).when(subtotal.atLeast(1000))
.discount(taka(50)).when(qty.atLeast(10).and(member))
.delivery(taka(0)).when(price.atLeast(1000))
.delivery(taka(60));
const orders = [[2, 520, false], [12, 40, true], [12, 40, false], [3, 400, true]];
const run = s => orders.map(([q, u, m]) => total(s, { qty: q, unit: u, member: m })).join(", ");
console.log("internal DSL: ", run(bazar));
const oops = shop().discount(taka(50)).when(qty >= 10).delivery(taka(60)); // ভুল: >= লেখা হয়েছে
console.log("qty >= 10 =", qty >= 10, "→", run(oops));আসল আউটপুট (ব্রাউজারের JavaScript):
internal DSL: 996, 490, 540, 1080
qty >= 10 = false → 1050, 490, 490, 1210
প্রথম লাইনে একই চারটি সংখ্যা: ৯৯৬, ৪৯০, ৫৪০, ১০৮০. কোনো parser লিখতে হয়নি। দ্বিতীয় লাইন internal DSL-এর দামটি দেখায়। কেউ সহজ মনে করে .when(qty >= 10) লিখেছেন। JavaScript-এ operator overloading নেই, তাই qty >= 10 একটি object আর সংখ্যার তুলনা: চুপচাপ false. shop false-কে “শর্ত নেই” ধরে পঞ্চাশ টাকা ছাড় সবাইকে দিল: প্রথম অর্ডার ১১০০-এর জায়গায় ১০৫০.
Python-এ operator overloading আছে, তাই __ge__ দিয়ে qty >= 10 একটি শর্ত-object বানাতে পারে (SQLAlchemy-র মতো open-source library এভাবে চলে); কিন্তু host-এর নিয়মও সঙ্গে আসে। লেখকের lab-এ CPython 3.14.4, সত্যিকারের run (Field আর Cond দুটি ছোট class, & দিয়ে “এবং”):
rule = (qty >= 10) & member
print(rule, rule.test({"qty": 12, "member": True}))
print(0 < qty < 10) # Python: (0 < qty) and (qty < 10)
print(qty >= 10 & member) # & বাঁধে >=-এর আগে
(qty >= 10) & (member) True
qty < 10
TypeError: unsupported operand type(s) for &: 'int' and 'Field'
প্রথম লাইন কাজ করে। দ্বিতীয়টিতে Python-এর chained comparison মানে (0 < qty) and (qty < 10), আর and overload করা যায় না: প্রথম শর্ত-object “সত্য” গণ্য, তাই শুধু দ্বিতীয়টি ফেরে, 0 < qty নিঃশব্দে হারায়। তৃতীয়টিতে & বাঁধে >=-এর আগে: আসলে লেখা হয়েছে qty >= (10 & member). Internal DSL host-এর operator precedence বদলাতে পারে না। কৌশলগুলোর বিস্তারিত Python কোর্সের পর্ব ৩৮ আর JavaScript কোর্সের পর্ব ২৮-এ; macro দিয়ে host-এর syntax-এর বাইরে যাওয়া পর্ব ৭৮-এর (Metaprogramming — macro, template আর reflection) বিষয়।
Eযদি পরিমাণ >= 10 এবং সদস্য তাহলে ছাড় 50 টাকাI.discount(taka(50)).when(qty.atLeast(10).and(member))
| প্রশ্ন | |
| External (ছাড়লিপি) | |
| Internal (JS) |
- কে পড়ে। E লাইন পড়ে আমাদের lexer আর parser; I লাইন সাধারণ JavaScript, কয়েকটি function call, তাই পড়ে JavaScript engine. Internal DSL-এর বড় লাভ এখানেই।
- বানান ভুল। “পরিমান”-এ ছাড়লিপি বাংলায় প্রস্তাব দেয়;
qtyy-তে JavaScript বলেReferenceError: qtyy is not defined, প্রোগ্রামারের কাছে স্পষ্ট, ম্যানেজারের কাছে নয়। - ভুল চিহ্ন।
পরিমাণ => 10-এ আমাদের lexer সত্যিকারের run-এ বলে1:12: ভুল: অচেনা চিহ্ন '='. JavaScript-এqty >= 10বৈধ, তাই কেউ কিছু বলে না, আর নিয়ম সবার ওপর খাটে। - অর্থ। দুটিই নকশা-সিদ্ধান্ত (গ) হুবহু মানে; অর্থ একটি, লেখার রূপ দুটি।
- ফল। একই চার অর্ডারে একই চার সংখ্যা। কোনটি বাছবেন, ঠিক করে কে লিখবেন আর কে ভুল সামলাবেন।
৯ · কখন DSL বানাবেন না
ভাষা বানানোর খরচ parser-এ শেষ হয় না: লাগবে editor-এর সহায়তা (পর্ব ৮০), দলিল, পুরোনো নিয়ম-ফাইলের version, debugging (“কোন নিয়ম কেন খাটল?”), test আর বহু বছরের রক্ষণাবেক্ষণ। নিচের কোনোটি সত্য হলে আগে বিকল্প ভাবুন:
| পরিস্থিতি | সম্ভবত ভালো বিকল্প |
|---|---|
| নিয়ম শুধু কয়েকটি সংখ্যা বদলায় (ছাড় ১০% থেকে ১২%) | একটি config ফাইল বা settings পাতা |
| নিয়ম আসলে শর্তের সব মিশ্রণের একটি তালিকা | একটি টেবিল: decision table বা spreadsheet (Software Testing কোর্সের পর্ব ০৯) |
| লেখকেরা সবাই প্রোগ্রামার | সাধারণ library বা internal DSL |
| ব্যবহারকারী মাত্র দু-একজন, নিয়ম বছরে দুবার বদলায় | প্রোগ্রামার সরাসরি কোড বদলান |
| দরকার loop, variable, function, সব কিছু | একটি general-purpose ভাষা; DSL ধীরে ধীরে ভালো general-purpose ভাষা হতে পারে না |
আরেকটি প্রলোভন বিপজ্জনক: “নিয়ম সরাসরি eval করে দিই”। পর্ব ১২-এ দেখেছেন eval ভাষার পুরো ক্ষমতা খুলে দেয়, তাই বাইরের লেখা eval মানে code injection-এর দরজা। ছাড়লিপির parser শুধু তেরোটি শব্দ চেনে; ফাইল মোছা বা network ডাকার শব্দই নেই। নকশা-সিদ্ধান্ত (ঘ)-ও তাই: ভাষাটি Turing-complete নয়, প্রতিটি হিসাব থামে। উল্টো ঘটনাও সাধারণ: config ফাইল (YAML, JSON) ধীরে ধীরে শর্ত আর variable পায়, আর grammar বা error message ছাড়াই একটি দুর্বল ভাষা জন্মায়; তখন ছোট, পরিষ্কার একটি DSL ভালো।
আরও গভীরে। কিছু ভাষা DSL বানানোকে মূল কাজ ধরে। Racket-এ ফাইলের প্রথম লাইনে #lang লিখে পুরো নতুন ভাষা বেছে নেওয়া যায়, যাকে Racket সম্প্রদায় “language-oriented programming” বলে; parser, macro আর editor-সহায়তা একসঙ্গে আসে। গবেষণায় আরেকটি ধারা হলো DSL-এর অর্থ দিয়ে অনুবাদকের সঠিকতা প্রমাণ: পর্ব ৪৪-এর verified compiler-এর মতো, অনুবাদ যদি অর্থ রক্ষা করে (semantic preservation), তাহলে প্রতিটি নিয়ম-ফাইলের জন্য আর আলাদা test লাগে না। আর (পরিমাণ > 24) এবং (পরিমাণ == 14)-এর মতো কখনো-সত্য-না-হওয়া শর্ত খুঁজতে পূর্ণসংখ্যার সরল শর্তে SMT solver ব্যবহার করা যায়; ছাড়লিপির মতো ছোট ভাষায় প্রশ্নটি decidable, পূর্ণ ভাষায় Rice-এর theorem (ToC কোর্সের পর্ব ৫৩) পথ আটকায়।
পরীক্ষা ও ইন্টারভিউতে। বিশ্ববিদ্যালয়, চাকরি বা ইন্টারভিউর পরীক্ষায় এই ধরনের প্রশ্ন আসে:
- “DSL আর general-purpose ভাষার পার্থক্য কী? তিনটি উদাহরণ দিন।” DSL একটি জগতের ধারণা সরাসরি ভাষায় আনে আর বাকি সব বাদ দেয়; SQL, regex, CSS.
- “Internal আর external DSL-এর একটি করে সুবিধা আর অসুবিধা?” Internal: host-এর parser আর tool বিনামূল্যে, কিন্তু host-এর syntax আর error; external: নিজের syntax আর বার্তা, কিন্তু পুরো front end নিজে লিখতে হয়।
- “একটি নিয়ম-ভাষার grammar EBNF-এ লিখুন, যেখানে ‘এবং’ ‘অথবা’-র চেয়ে শক্ত।”
or = and { "অথবা" and },and = atom { "এবং" atom }: নিচের স্তর বেশি শক্ত। - “DSL-কে অন্য ভাষায় অনুবাদ করার সময় precedence-এর সমস্যা কীভাবে এড়াবেন?” গাছ থেকে লেখার সময় প্রতিটি যৌগিক সন্তানকে বন্ধনীতে মোড়ানো।
- “ব্যবহারকারীর লেখা নিয়ম eval করা কেন খারাপ?” Code injection: eval host ভাষার পুরো ক্ষমতা দেয়; নিজের parser শুধু অনুমোদিত শব্দ চেনে।
১০ · AI-এর যুগে DSL নকশা
AI-কে “একটি নিয়ম-ভাষা বানিয়ে দাও” বললে grammar, parser আর উদাহরণ মুহূর্তে আসে, দেখতেও নিখুঁত; কিন্তু ভুল লুকায় সেখানে, যেখানে কেউ খোঁজে না:
| AI-এর সাধারণ ভুল | কীভাবে ধরবেন |
|---|---|
Parser-এ precedence বা associativity ভুল (না কতটা বাঁধে, a < b < c চলে কি না) | EBNF-এর প্রতিটি স্তরের জন্য একটি করে ছোট উদাহরণ, তার AST ছাপিয়ে দেখা |
নিয়ম চালাতে eval বা exec বসানো | Code-এ eval, exec, new Function খোঁজা; নিজের parser দাবি করা |
| অনুবাদে অর্থ বদলানো: বন্ধনী হারানো, ভাগের ভগ্নাংশ ভিন্নভাবে কাটা, short-circuit ভুলে যাওয়া | উৎপন্ন কোড আসল target-এ (এখানে haat.py run) চালানো, আর এলোমেলো ফাইলে differential test |
একটি ভাষার নিয়ম সব ভাষায় চালিয়ে দেওয়া (“JavaScript-এ qty >= 10 দিয়ে শর্ত বানানো যায়”) | Host ভাষায় সত্যিকারের run; operator overloading আছে কি না দেখা |
| বানানো library বা বানানো option (অস্তিত্বহীন parser generator flag) | দলিল খুলে মেলানো, আর একবার নিজে চালিয়ে দেখা |
| Unicode উপেক্ষা: বাংলা keyword দুই রূপে টাইপ হলে মেলে না | একক আর ভাঙা রূপের ড়, য় দিয়ে test; NFC আছে কি না দেখা |
AI-কে নকশার সহকারী বানান, নকশাকার নয়। আগে নিজের সিদ্ধান্ত লিখে দিন, তারপর যাচাইযোগ্য অংশ চান:
AI-এর উত্তর হাতে পেলে — যাচাইয়ের চেকলিস্ট
ভাবনার প্রশ্ন
প্রতিটি প্রশ্ন নিয়ে নিজে কিছুক্ষণ ভাবুন, তারপর “→ উত্তর” চাপুন।
প্র ০১Spreadsheet-এর formula-কে অনেকে পৃথিবীর সবচেয়ে বেশি ব্যবহৃত প্রোগ্রামিং ভাষা বলেন। প্রোগ্রামার নন এমন কোটি মানুষ সেখানে সফল হন কেন, আর একটি DSL-এর নকশাকার সেখান থেকে কী শিখতে পারেন?
Spreadsheet-এর formula একটি DSL-এর প্রায় আদর্শ রূপ। এর জগৎ একটি ঘরের টেবিল, আর প্রতিটি formula একটি ঘরের মান অন্য ঘরগুলো থেকে বলে দেয়। এখানে কোনো loop নেই, assignment নেই, “আগে এটা, পরে ওটা” নেই: formula declarative, আর কোন ঘর আগে হিসাব হবে, spreadsheet নিজেই নির্ভরতার graph দেখে ঠিক করে, অনেকটা Make-এর মতো।
সাফল্যের দ্বিতীয় কারণ তাৎক্ষণিক ফল। একটি সংখ্যা বদলালে সঙ্গে সঙ্গে পুরো টেবিল বদলায়; লেখা, compile আর চালানোর আলাদা ধাপ নেই। তৃতীয়ত, প্রতিটি মধ্যবর্তী মান একটি ঘরে চোখের সামনে। এই ধারা শুরু হয় VisiCalc দিয়ে (১৯৭৯, Dan Bricklin আর Bob Frankston), যাকে প্রথম জনপ্রিয় ব্যক্তিগত-কম্পিউটারের spreadsheet বলে ধরা হয়; এর মূল ধারণা আজও প্রায় একই।
ছাড়লিপির নকশাকারের জন্য তিনটি শিক্ষা। এক, ধারণা ব্যবহারকারীর জগৎ থেকে নিন (মোট, দাম, সদস্য), প্রোগ্রামিং-এর জগৎ (variable, type) থেকে নয়। দুই, প্রতিক্রিয়া দ্রুত দিন: একটি ভালো ছাড়লিপি editor প্রতিটি নিয়মের পাশে কয়েকটি নমুনা অর্ডারের ফল সঙ্গে সঙ্গে দেখাতে পারে, যা অংশ ৭-এর মতো হিসাবকেই সামনে আনে। তিন, ক্ষমতা সীমিত রাখুন।
তবে উল্টো শিক্ষাও আছে। বড় spreadsheet-এ ভুল খুব সাধারণ, কারণ formula ঘরে ঘরে লুকানো, test নেই, আর একটি ভুল টেনে কপি করা formula শত ঘরে ছড়ায়। অর্থাৎ সহজ ভাষা ভুল কমায় না, ভুলের ধরন বদলায়; তাই DSL-এর সঙ্গে ভুল ধরার উপায়ও (অংশ ৬-এর checker, অংশ ৭-এর differential test) নকশার অংশ।
মূল উপলব্ধি: সফল DSL ব্যবহারকারীর জগতের শব্দে কথা বলে, দ্রুত ফল দেখায় আর ক্ষমতা সীমিত রাখে; কিন্তু সহজ ভাষাতেও ভুল হয়, তাই যাচাইয়ের ব্যবস্থা ভাষার সঙ্গে একসঙ্গে নকশা করতে হয়।
প্র ০২বাজারঘর প্রথমে internal DSL দিয়ে শুরু করল, পরে ম্যানেজারদের হাতে নিয়ম দিতে external DSL বানাল। দুটি একসঙ্গে রাখা যায় কি? রাখলে অর্থ এক থাকবে কীভাবে?
বাস্তবে এই বিবর্তন খুবই সাধারণ। শুরুতে নিয়ম লেখেন প্রোগ্রামাররাই, তাই internal DSL সস্তা আর দ্রুত: কোনো parser নেই, host-এর editor আর test সব কাজ করে। পরে নিয়ম বদলাতে চান প্রোগ্রামার নন এমন মানুষ, তখন external DSL.
দুটি একসঙ্গে রাখার সবচেয়ে পরিষ্কার উপায় হলো একটি সাধারণ মধ্যবর্তী রূপ। এই পর্বে সেটি প্রায় তৈরি: ছাড়লিপির parser একটি Rule-এর তালিকা দেয়, আর JavaScript-এর shop()-ও একটি নিয়মের তালিকা বানায়। যদি দুটি সামনের দিক একই data structure বানায়, আর তার অর্থ একটি জায়গায় (একটি evaluate(), বা একটি অনুবাদক) লেখা থাকে, তাহলে অর্থ আলাদা হওয়ার উপায় নেই। এটি পর্ব ০৫-এর compiler-এর front end আর back end-এর ভাগের ছোট রূপ: অনেক উৎস-ভাষা, এক মধ্যবর্তী রূপ।
সমস্যা শুরু হয় যখন দুটি পথ নিজের নিজের অর্থ লেখে। এই পর্বে ঠিক তা-ই হয়েছে: Python-এর evaluate() আর JavaScript-এর total() আলাদা কোড। এখন মিলছে, কারণ দুটিই নকশা-সিদ্ধান্ত (গ) মেনে লেখা, কিন্তু কেউ একটিতে “সর্বোচ্চ ছাড়” নিয়ম যোগ করে অন্যটিতে ভুলে গেলে চুপচাপ আলাদা হবে। প্রতিকার দুটি: অর্থ এক জায়গায় রাখা, অথবা দুই পথের মধ্যে নিয়মিত differential test, অংশ ৭-এর মতো।
পুরোনো নিয়ম নতুন ভাষায় আনতে একটি pretty-printer (পর্ব ৪৯-এর fmt-এর মতো) মধ্যবর্তী রূপ থেকে ছাড়লিপির লেখা বানাতে পারে। Martin Fowler-এর “Domain-Specific Languages” বইয়েও (২০১০ সালের দিকে প্রকাশিত) একই পরামর্শ: internal আর external, দুই রূপই একটি সাধারণ “semantic model” তৈরি করবে, আর অর্থ থাকবে সেই model-এ।
মূল উপলব্ধি: একাধিক লেখার রূপ সমস্যা নয়, একাধিক অর্থ সমস্যা; সব রূপকে একটি মধ্যবর্তী data structure-এ নামিয়ে অর্থ এক জায়গায় রাখুন, আর না পারলে differential test দিয়ে পাহারা দিন।
প্র ০৩ছাড়লিপি “প্রথম মিল জেতে” নিয়ম নিয়েছে। SQL-এর CASE, firewall-এর নিয়ম আর CSS-এর cascade কোন নিয়ম মানে? বিকল্প নিয়মগুলো কী, আর বাছাইয়ের মাপকাঠি কী হওয়া উচিত?
একাধিক নিয়ম একই অর্ডারে খাটলে কী হবে, প্রতিটি নিয়ম-ভাষাকে এই প্রশ্নের উত্তর দিতে হয়, আর উত্তরটিই তার অর্থের কেন্দ্র। অন্তত চারটি পথ চালু আছে। প্রথম মিল: SQL-এর CASE WHEN ওপর থেকে প্রথম সত্য শর্তের মান নেয় (অংশ ১-এর run), আর অনেক firewall-এর নিয়ম-তালিকাও প্রথম মেলা নিয়মের সিদ্ধান্ত মানে। শেষ মিল বা অগ্রাধিকার: CSS-এ একই element-এ একাধিক নিয়ম খাটলে আগে selector-এর specificity দেখা হয়, আর সমান হলে পরে লেখা নিয়ম জেতে। সব মিল যোগ: প্রতিটি মেলা নিয়মের ছাড় একসঙ্গে। সবচেয়ে ভালো মিল: গ্রাহকের জন্য সবচেয়ে বড় ছাড়টি।
প্রতিটির দাম আলাদা। প্রথম মিলে ক্রম গুরুত্বপূর্ণ, তাই অংশ ৬-এর সপ্তম ভুলটি (শর্তহীন নিয়ম আগে) সম্ভব, আর তা ধরতে checker লাগে। কিন্তু অর্থ সহজে ব্যাখ্যা করা যায়: “ওপর থেকে পড়ুন, প্রথম যেটি মেলে”। সব যোগ করলে ক্রম গুরুত্বহীন, কিন্তু দুটি অফার একসঙ্গে খেটে অপ্রত্যাশিত বড় ছাড় দিতে পারে, আর অনুশীলন ১-এর ঋণাত্মক দামের ঝুঁকি বাড়ে।
মাপকাঠি হওয়া উচিত ব্যবহারকারীর মনের ছবি। বাজারঘরের ম্যানেজার অফারকে একটি তালিকা হিসেবে ভাবেন, আর দোকানে সাধারণত “একটি অফার একবারে” নিয়ম চলে; তাই প্রথম মিল তাঁর অভিজ্ঞতার সঙ্গে মেলে। অন্য দোকানে অফার জমানো স্বাভাবিক হলে সব-যোগ ভালো, সঙ্গে একটি সর্বোচ্চ সীমা।
যা-ই বাছুন, একটি জিনিস বাধ্যতামূলক: নিয়মটি লিখিত থাকবে, interpreter আর অনুবাদ দুটিতেই হুবহু এক, আর checker সেই নিয়মের সাধারণ ফাঁদগুলো (অপ্রাপ্য নিয়ম, পরস্পরবিরোধী নিয়ম) ধরবে।
মূল উপলব্ধি: নিয়মের সংঘাত মেটানোর নিয়মই একটি নিয়ম-ভাষার আসল semantics; ব্যবহারকারীর মনের ছবির সঙ্গে মেলে এমনটি বাছুন, লিখে রাখুন, আর তার ফাঁদ ধরার checker দিন।
প্র ০৪“ছার” লিখলে ছাড়লিপি কোনো প্রস্তাব দেয় না, অথচ মানুষের চোখে এটি “ছাড়”-এর সবচেয়ে কাছের ভুল। বাংলা লেখায় “কাছের শব্দ” মাপার আরও ভালো উপায় কী, আর বাংলা DSL-এর অন্য Unicode-ঝুঁকিগুলো কী?
আমাদের distance() code point গোনে। “ছাড়” চারটি code point (ছ, া, ড, নুক্তা), “ছার” তিনটি, তাই দূরত্ব ২: র → ড একটি বদল, নুক্তা একটি সংযোজন। মানুষের চোখে ড় একটি অক্ষর, আর র ও ড়-এর উচ্চারণ এত কাছাকাছি যে বাংলায় এদের গুলিয়ে ফেলা খুব সাধারণ। প্রথম উন্নতি: code point নয়, grapheme cluster (চোখে দেখা একটি অক্ষর) ধরে দূরত্ব মাপা; তখন “ছার” আর “ছাড়”-এর দূরত্ব ১, আর প্রস্তাব আসত।
দ্বিতীয় উন্নতি: সব বদলকে সমান খরচ না ধরা। Levenshtein-এর প্রতিটি কাজের খরচ ১, কিন্তু ি আর ী, ন আর ণ, র আর ড়, শ, ষ আর স-এর মতো জোড়ার বদলকে আধা খরচ ধরা যায়, কারণ এগুলো বানানের ভুল, অর্থের নয়। এটি একটি weighted edit distance, আর ওজনের টেবিলটি আসলে বাংলা বানানের ভুলের জ্ঞান।
তৃতীয়ত, প্রসঙ্গ দেখা। তাহলে-এর পরে কেবল ছাড় বা ডেলিভারি আসতে পারে; তাই সেখানে প্রস্তাব খোঁজা উচিত শুধু এই দুটির মধ্যে, তেরোটির মধ্যে নয়। তখন “ছার”-এর বিরুদ্ধে “দর” বা “না” প্রতিদ্বন্দ্বী থাকে না। Parser জানে কোন জায়গায় কী বৈধ (পর্ব ৫০-এর expected-token set), আর সেই তথ্য প্রস্তাবে লাগানো ভালো diagnostic-এর লক্ষণ।
অন্য ঝুঁকিগুলোও বাস্তব। অংশ ৩-এর মতো একই অক্ষরের দুই Unicode রূপ (NFC দিয়ে সমাধান)। চোখে অদৃশ্য অক্ষর: zero-width joiner বা non-joiner (U+200D, U+200C), যা কিছু যুক্তাক্ষরের চেহারা বদলায়; আমাদের lexer এগুলোকে শব্দের অংশ ধরে, তাই একটি অদৃশ্য অক্ষর থাকলে “চেনা” শব্দও অচেনা হতে পারে, আর বার্তায় দুটি শব্দ একই দেখাবে। প্রতিটির জন্য দরকার একটি নিয়ম (normalize, বাদ দেওয়া, বা স্পষ্ট বার্তা) আর একটি test.
মূল উপলব্ধি: বাংলা DSL-এ “অক্ষর” মানে code point নয়; ভালো বার্তার জন্য grapheme, বানান-ভুলের ওজন আর parser-এর প্রসঙ্গ একসঙ্গে লাগে, আর Unicode-এর অদৃশ্য ফাঁদগুলোর প্রতিটির জন্য আলাদা নিয়ম আর test.
প্র ০৫ছাড়লিপিতে loop নেই, তাই প্রতিটি হিসাব থামে। একটি DSL-কে ইচ্ছা করে দুর্বল রাখার লাভ কী? ব্যবহারকারীরা “আরও একটু” ক্ষমতা চাইলে কী করবেন?
ক্ষমতা কম মানে নিশ্চয়তা বেশি। ছাড়লিপির প্রতিটি নিয়ম-ফাইলের হিসাব সীমিত সময়ে থামে: প্রতিটি অর্ডারে প্রতিটি নিয়মের শর্ত বড়জোর একবার হিসাব হয়, আর শর্তের আকার লেখার আকারের সমান। তাই দোকানের server-এ কোনো ম্যানেজারের নিয়ম চিরকাল ঘুরবে না। আরও গভীর লাভ: ভাষা ছোট বলে তার সম্পর্কে প্রশ্নের উত্তর দেওয়া যায়। “এই নিয়ম কি কখনো খাটে?” প্রশ্নটি একটি general-purpose ভাষায় Rice-এর theorem অনুযায়ী সাধারণভাবে অমীমাংসেয়; ছাড়লিপিতে শর্তগুলো শুধু পূর্ণসংখ্যার তুলনা আর এবং/অথবা/না, তাই প্রশ্নটি decidable, আর একটি SMT solver বা সরল ব্যবধানের (interval) হিসাব দিয়েই উত্তর মেলে।
ব্যবহারকারীরা ক্ষমতা চাইবেনই: “পরপর তিন মাস কিনলে ছাড়”, “প্রতি পাঁচটির জন্য একটি ফ্রি”। প্রতিটি অনুরোধে প্রথম প্রশ্ন: এটি কি নতুন ধারণা (নতুন তথ্য, যেমন মাসিক_ক্রয়), নাকি নতুন গণনার ক্ষমতা (loop, variable)? নতুন তথ্য যোগ করা নিরাপদ: host system হিসাবটি করে একটি নতুন FIELD হিসেবে দেয়, আর ভাষা তুলনা করেই খুশি থাকে। গণনার ক্ষমতা যোগ করা বিপজ্জনক, কারণ ধাপে ধাপে ভাষা Turing-complete হয়ে যায় আর সব নিশ্চয়তা হারায়; বহু config ভাষার গল্প এরকমই।
মাঝামাঝি পথও আছে: সীমিত loop, যেমন শুধু অর্ডারের পণ্যগুলোর ওপর একবার যাওয়া (“প্রতিটি পণ্যের জন্য”), যা সবসময় থামে কারণ তালিকা সসীম।
শেষ বিকল্প সৎ উত্তর: “এই নিয়মটি ছাড়লিপিতে নয়, প্রোগ্রামাররা Haat বা Python-এ লিখবেন”, আর DSL থেকে সেই function-এর ফল একটি নাম হিসেবে ব্যবহার করা যাবে। একটি DSL যত ছোট থাকে, তত বেশি মানুষ তাকে বোঝেন।
মূল উপলব্ধি: DSL-এর দুর্বলতা একটি বৈশিষ্ট্য: থামার নিশ্চয়তা, নিরাপত্তা আর বিশ্লেষণের সুযোগ আসে সীমা থেকেই; নতুন ক্ষমতার বদলে নতুন তথ্য দিন, আর সত্যিকারের গণনা host ভাষায় রাখুন।
অনুশীলন
প্রথমে নিজে লিখুন বা হিসাব করুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর লেখকের lab-এ চালিয়ে আর দরকারে সত্যিকারের reference-এ যাচাই করা।
-
নকশা ও বাস্তবায়ন — ঋণাত্মক দাম: নিচের নিয়ম-ফাইলে ১টি পণ্য, দর ২০০, সদস্য নন: সরাসরি interpreter আর Haat-অনুবাদ কী দেবে? এটি কি অনুবাদের ভুল? ভাষার অর্থে একটি পরিবর্তন প্রস্তাব করুন আর অনুবাদক (
to_haat) বদলান, যাতে reference-এ ঠিক ফল আসে।ছাড় 300 টাকা ডেলিভারি 60 টাকালেখকের lab-এ: সরাসরি interpreter দেয়
-40(মোট ২০০, ছাড় ৩০০, দাম −১০০, ডেলিভারি ৬০), আর অনুবাদ reference-এ সত্যিকারের run-এ ছাপে-40; দ্বিতীয় নমুনা অর্ডার (২×৫২০) দেয়800. অনুবাদ নির্ভুলভাবে ভুল নকশাটি বহন করছে; ভুলটি ভাষার অর্থে। প্রস্তাব: “দাম কখনো ০-এর নিচে নামে না”। দুই জায়গায় একই বদল:evaluate()-এenv["দাম"] = max(0, …), আর অনুবাদে Haat-এ একটি সাহায্যকারী function (Haat-এmaxনেই):fn floor0(n: Int) -> Int { if n < 0 { return 0; } return n; } fn total(qty: Int, unit: Int, member: Bool) -> Int { let price = floor0(qty * unit - discount(qty, unit, member)); return price + delivery(qty, unit, member, price); }to_haat()-এtotal-এর আগে এই চার লাইন যোগ করে আরlet price-এর লাইনটি বদলে reference-এ সত্যিকারের run:60আর800. লক্ষ করুন, অংশ ৭-এর ২০০টি ফাইলের ১০০০টি অর্ডারে এমন ঘটনা ছিল মাত্র একটি (seed 5), আর differential test তা ধরতে পারেনি, কারণ দুই পক্ষ একমত ছিল। -
ভুল খুঁজুন — বন্ধনী ছাড়া অনুবাদ: একজন সহকর্মী
to_haat.py-এরparen()সরিয়ে সব জায়গায়expr()বসালেন: “বন্ধনীগুলো কুৎসিত দেখায়, আর Haat-এর precedence তো এমনিতেই ঠিক।” নিচের নিয়মের অনুবাদ কী হবে, আর কেন সেটি ভুল? Type checker কি ধরবে?যদি (মোট >= 2000 অথবা সদস্য) এবং পরিমাণ >= 3 তাহলে ছাড় 10%ছাড়লিপির গাছ:
এবং-এর বাঁ দিকে(মোট >= 2000 অথবা সদস্য), ডানেপরিমাণ >= 3. বন্ধনী ছাড়া অনুবাদ হয়subtotal >= 2000 || member && qty >= 3, আর Haat-এ&&||-এর চেয়ে শক্ত, তাই অর্থ দাঁড়ায়subtotal >= 2000 || (member && qty >= 3). মোট ২৫০০ টাকার একটি পণ্য (পরিমাণ ১) কিনলে আসল নিয়মে ছাড় নেই (পরিমাণ ৩-এর কম), অনুবাদে ছাড় আছে। সব অংশ Bool, তাই type checker চুপ। এটি অংশ ৭-এর সেই ১৩টি “চুপচাপ ভুল” ফাইলের ধাঁচ। লেখকের lab-এparen()সরিয়ে ২০০টি ফাইল reference-এ চালানোর ফল: ১৩৩টিতে অনুবাদ বদলায়, ৯৬টিতে type error (প্রায়ইনা-এর কারণে, যেমন প্রথমটি12:9: error: type mismatch: expected Bool, found Int), ১৩টিতে ভুল সংখ্যা, ২৪টিতে কাকতালীয়ভাবে ঠিক। শিক্ষা: অনুবাদক গাছ থেকে লেখা বানালে precedence-এর ওপর ভরসা না করে গঠন বন্ধনীতে লিখুন; -
হিসাব — আউটপুট আগে বলুন: নিচের ফাইলে তিনটি অর্ডার: (ক) পরিমাণ ৫, দর ৫০০, সদস্য; (খ) একই, সদস্য নন; (গ) পরিমাণ ২, দর ২০০, সদস্য। প্রতিটির মোট দেয় টাকা কত? আর
discountfunction-এর Haat অনুবাদ লিখুন।যদি সদস্য তাহলে ছাড় 5% যদি মোট >= 2000 তাহলে ছাড় 15% যদি দাম < 500 তাহলে ডেলিভারি 60 টাকা ডেলিভারি 30 টাকা(ক) মোট ২৫০০. প্রথম মিল জেতে, আর প্রথম নিয়মই মেলে (সদস্য), তাই ছাড় ৫%, অর্থাৎ ১২৫, যদিও দ্বিতীয় নিয়মে ১৫% পাওয়া যেত। দাম ২৩৭৫, ৫০০-এর কম নয়, তাই ডেলিভারি ৩০: ২৪০৫. (খ) সদস্য নন, দ্বিতীয় নিয়ম: ৩৭৫ ছাড়, দাম ২১২৫, ডেলিভারি ৩০: ২১৫৫. (গ) মোট ৪০০, সদস্য, ৫% = ২০, দাম ৩৮০ < ৫০০, ডেলিভারি ৬০: ৪৪০. লেখকের lab-এ
evaluate()আর reference-এ অনুবাদের সত্যিকারের run দুটিই দেয়2405,2155,440. অনুবাদ:fn discount(qty: Int, unit: Int, member: Bool) -> Int { let subtotal = qty * unit; if member { return subtotal * 5 / 100; } // e3.chhar:1 if subtotal >= 2000 { return subtotal * 15 / 100; } // e3.chhar:2 return 0; }(ক) আর (খ): সদস্য হয়ে কম ছাড়! ভাষা ঠিক, নিয়মের ক্রম ম্যানেজারের উদ্দেশ্য নয়।
-
প্রমাণ — অনুবাদ অর্থ রক্ষা করে: প্রমাণ করুন (রূপরেখা যথেষ্ট): checker পাস করা যেকোনো নিয়ম-ফাইল R আর যেকোনো অর্ডার (q, u, m)-এর জন্য, যেখানে 0 ≤ q, u আর q · u · 100 < 263,
to_haat-এর Haat program reference-এ যা ছাপে, তাevaluate(R, q, u, m)-এর সমান। প্রমাণের কোথায় শর্ত দুটি লাগে?প্রমাণের রূপরেখা। নামের মানচিত্র σ: পরিমাণ ↦ qty, দর ↦ unit, মোট ↦ subtotal, সদস্য ↦ member, দাম ↦ price. Haat-এর environment ρ আর ছাড়লিপির env মিলে যদি প্রতিটি নাম x-এর জন্য ρ(σ(x)) = env(x) হয়।
- গঠন-রক্ষা (lemma ১). প্রতিটি শর্ত e-র জন্য, Haat-এর parser
expr(e)পড়ে e-র সমান আকারের গাছ বানায়। শর্তের গঠনের ওপর induction: পাতা (সংখ্যা, নাম) এক token;Binary-এর প্রতিটি যৌগিক সন্তান বন্ধনীতে, তাই Haat-এর precedence যা-ই হোক, বন্ধনীর ভেতরটি একটি পূর্ণ সন্তান;!Haat-এ সবচেয়ে শক্ত, আর তার operand যৌগিক হলে বন্ধনীতে। - মান-রক্ষা (lemma ২). মিলে যাওয়া ρ আর env-এ, Haat-এ
expr(e)-এর মান =value(e, env). আবার গঠনের ওপর induction; তুলনা দুই ভাষায় একই,&&/||/!আর এবং/অথবা/না-র সত্য-সারণি এক। Checker-এর কারণে Haat-এর type checker-ও গ্রহণ করে। - প্রথম মিল (lemma ৩). একটি ধরনের নিয়মের তালিকা r1 … rk-এর ওপর induction: Haat function-এর
if ci { return ai; }-এর সারি প্রথম সত্য ci-তে ai ফেরত দেয়, কেউ না মিললেreturn 0; শর্তহীন নিয়ম সরাসরিreturn, আর checker নিশ্চিত করেছে তার পরে একই ধরনের নিয়ম নেই। এটিইfirst(). - পরিমাণ। শতাংশে Haat হিসাব করে
subtotal * N / 100: Haat-এর/শূন্যের দিকে কাটে, Python-এর//নিচের দিকে। দুটি সমান যখন ভাজ্য ঋণাত্মক নয়: এখানে লাগে 0 ≤ q, u. আর q · u · N ≤ q · u · 100 < 263 হলে Haat-এর 64-bit wrap (spec decision 13) কখনো ঘটে না; এখানে লাগে দ্বিতীয় শর্ত, N ≤ 100 ধরে নিয়ে। - সব মিলিয়ে।
total-এ price = মোট − ছাড় (lemma ৩ আর ৪), তারপর ডেলিভারির function-এ ρ(price) = env(দাম), তাই lemma ২-৩ আবার খাটে; যোগফল দুই দিকে এক, আরprintএকই দশমিক লেখা ছাপে। ∎
Lemma ১ ছাড়া প্রমাণ ভাঙত (অনুশীলন ২); আর প্রমাণটি “অনুবাদ ঠিক” বলে, “নকশা ঠিক” নয় (অনুশীলন ১)।
- গঠন-রক্ষা (lemma ১). প্রতিটি শর্ত e-র জন্য, Haat-এর parser
নিজেকে যাচাই করুন
ভুল হলে কারণসহ ব্যাখ্যা পাবেন, আবার চেষ্টাও করতে পারবেন।
ক্রমএকটি external DSL-এর নিয়ম-ফাইল (যেমন যদি মোট >= 1000 তাহলে ছাড় 10%) অনুবাদের মাধ্যমে চালানো হচ্ছে। ধাপগুলো ক্রমে সাজান (▲▼ চেপে সরান)
- লেখাটিকে Unicode NFC রূপে আনা
- Lexer শব্দ আর চিহ্ন থেকে token বানায়
- Parser শর্তকে Pratt পদ্ধতিতে গাছে সাজায়
- Checker শর্তের ধরন আর নিয়মের ক্রম যাচাই করে
- অনুবাদক গাছ থেকে বন্ধনীসহ target-ভাষার কোড লেখে
- Target-ভাষার আসল interpreter কোডটি চালায়
Internal DSL আর external DSL-এর মূল পার্থক্য কোনটি?
- Internal DSL compile হয়, external DSL interpret হয়
- Internal DSL অন্য ভাষার ভেতরে library হিসেবে থাকে; external DSL-এর নিজের grammar আর parser থাকে
- Internal DSL শুধু প্রোগ্রামারের জন্য, external শুধু প্রোগ্রামার নন এমন মানুষের জন্য
- External DSL শুধু গবেষণায় ব্যবহৃত হয়
একটি নিয়ম-ভাষায় না-এর ডান দিকের binding power ৩০, এবং-এর ২০, তুলনার ৪০। না পরিমাণ >= 10 এবং সদস্য কীভাবে parse হবে?
- (না পরিমাণ) >= 10, তারপর এবং সদস্য
- না ((পরিমাণ >= 10) এবং সদস্য)
- (না (পরিমাণ >= 10)) এবং সদস্য
- Syntax error, কারণ না-এর পরে তুলনা চলে না
একটি DSL-এর গাছ থেকে Haat কোড লেখার সময় অনুবাদক প্রতিটি যৌগিক সন্তানকে বন্ধনীতে মোড়ায়। এর প্রধান কারণ কী?
- দুই ভাষার precedence আলাদা হলেও গাছের আকার, তাই অর্থ, একই রাখতে
- Haat-এ বন্ধনী থাকলে program দ্রুত চলে
- Haat বন্ধনী ছাড়া কোনো expression গ্রহণ করে না
- বন্ধনী দিলে Bool মান Int-এ বদলে যায়
JavaScript-এ একটি fluent internal DSL-এ কেউ লিখলেন .when(qty >= 10), যেখানে qty একটি object. কী ঘটার সম্ভাবনা সবচেয়ে বেশি?
- JavaScript engine syntax error দেবে
- >= overload হয়ে একটি শর্ত-object তৈরি হবে
- TypeError ছোড়া হবে
- কোনো error ছাড়াই
falseপাস হবে, আর নিয়ম ভুলভাবে খাটতে পারে
একটি নিয়ম-ভাষার সরাসরি interpreter আর তার Haat-অনুবাদ ২০০টি এলোমেলো ফাইলে একই ফল দিল। এ থেকে কোনটি বলা যায়?
- ভাষার নকশায় কোনো ভুল নেই
- পরীক্ষিত ফাইলগুলোতে দুই বাস্তবায়ন একমত; তবু সব ফাইলের জন্য প্রমাণ নয়, আর একই নকশা-ভুল ধরা পড়ে না
- সব সম্ভাব্য ফাইলে অনুবাদ নির্ভুল, এটি প্রমাণিত
- Interpreter অনুবাদের চেয়ে দ্রুত
ব্যবহারকারীর লেখা নিয়ম চালাতে Python-এর eval ব্যবহার না করে নিজের parser লেখার সবচেয়ে বড় কারণ কোনটি?
- নিজের parser সবসময় eval-এর চেয়ে দ্রুত
- Python 3.14-এ eval সরিয়ে দেওয়া হয়েছে
- eval পুরো ভাষার ক্ষমতা দেয়, ফলে code injection সম্ভব; নিজের parser শুধু অনুমোদিত শব্দ চেনে
- eval বাংলা লেখা পড়তে পারে না
শব্দকোষ
লেখার মধ্যে ডটেড দাগ দেওয়া শব্দে মাউস রাখুন বা চাপুন — অর্থ দেখাবে। এই পর্বের সব নতুন শব্দ এখানে একসাথে:
মনে রাখুন
- DSL: একটি জগতের ধারণা সরাসরি ভাষার শব্দ, বাকি সব বাদ; SQL, regex, Make, CSS, template আর build ফাইল সবাই DSL, বেশিরভাগই declarative.
- Internal বনাম external: internal host-এর parser আর tool পায়, সঙ্গে host-এর syntax, precedence আর নীরব ভুল; external নিজের grammar আর ব্যবহারকারীর ভাষায় বার্তা দেয়, কিন্তু পুরো front end নিজেকে বানাতে হয়।
- নকশা মানুষ থেকে শুরু: ব্যবহারকারীর শব্দ, এক লাইনে এক নিয়ম, স্পষ্ট সংঘাত-নিয়ম (প্রথম মিল), সীমিত ক্ষমতা; বাংলা শব্দে NFC আর অদৃশ্য অক্ষরের ফাঁদ।
- অনুবাদে অর্থ: DSL → Haat, আর Haat-এর আসল reference চালায়; precedence আলাদা হলে বন্ধনী দিয়ে গাছের আকার রক্ষা; উৎসের ঠিকানা মন্তব্যে।
- যাচাই আর সংযম: grammar থেকে বানানো এলোমেলো ফাইলে differential test অনুবাদের ভুল ধরে, নকশার ভুল নয়; আর config, টেবিল বা library-তে কাজ হলে নতুন ভাষা নয়।
আরও পড়ুন · ABCL TECH-এ আপনার পরবর্তী পদক্ষেপ
- পর্ব ৮০ · Language tooling — LSP, formatter, linter আর incremental compilationপরবর্তী পর্বএকটি ভাষার চারপাশের tool: editor-এর diagnostic, formatter আর linter.
- প্রোগ্রামিং ভাষা ও কম্পাইলার · কোর্স হোম৮৬টি পর্বপুরো কোর্সের মানচিত্র আর Haat প্রজেক্টের পথ।
- পর্ব ৪৮ · Pratt parsing — expression-এর precedence আর associativityএই কোর্সেছাড়লিপির শর্ত-parser-এর পুরো কৌশল।
- পর্ব ৫০ · Parser-এর error recovery আর ভালো diagnostic messageএই কোর্সেভালো বার্তার নীতি, যা DSL-এ আরও জরুরি।
- Grammar নকশা — ToC কোর্সের পর্ব ৪২পাশের ট্র্যাকAmbiguity এড়িয়ে precedence-এর স্তরে grammar লেখার তত্ত্ব।
- BDD আর Gherkin — Software Testing কোর্সের পর্ব ৪৩পাশের ট্র্যাকপরীক্ষা লেখার জন্য একটি বাস্তব external DSL.