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

Syntax, semantics আর pragmatics — একটি ভাষার তিন স্তর

Syntax, Semantics and Pragmatics — The Three Layers of a Programming Language

Taught in Bangla, this lesson separates the three layers of a language: syntax (lexical, context-free and context-sensitive rules), semantics (static and dynamic) and pragmatics. It reads an EBNF fragment of Haat's expressions and runs a recognizer for it, contrasts the 18-node parse tree of (2 + 3) * 4 with its 5-node AST, and shows Python's own ast module. Real runs in C, Python and JavaScript show the same text meaning different things, for -7 / 2 and -7 % 2, and it previews three styles of formal semantics.

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

  • যেকোনো ভুল বা প্রশ্ন দেখে বলতে পারা, সেটি syntax, static semantics, dynamic semantics না pragmatics-এর বিষয়
  • Concrete syntax, abstract syntax, parse tree আর AST-এর পার্থক্য, আর Python-এর নিজের AST চোখে দেখা
  • Haat-এর expression অংশের EBNF grammar পড়া, আর তা থেকে একটি ছোট recognizer চালানো
  • Typing rule আর evaluation rule কীভাবে লেখা হয় (M7-এর প্রস্তুতি)
  • C, Python, JavaScript আর Haat-এ একই লেখার ভিন্ন অর্থ সত্যিকারের run দিয়ে যাচাই করা, আর AI-এর এ বিষয়ের ভুল ধরা

১ · একটি ভাষার তিনটি প্রশ্ন: রূপ, অর্থ আর ব্যবহার

বাজারঘরের ডেলিভারি কর্মী রাকিবকে তিনটি চিরকুট দেওয়া হলো। প্রথমটিতে লেখা: “মিরপুর ১০ বাসা ২৩ রোড”। শব্দগুলো চেনা, কিন্তু ক্রম এলোমেলো; ঠিকানা লেখার নিয়ম মানেনি। দ্বিতীয়টিতে লেখা: “বাসা ২৩, রোড ৪, মিরপুর ১০, ঢাকা ১২১৬”। নিয়ম মেনে লেখা, কিন্তু রাকিব গিয়ে দেখলেন রোড ৪-এ ২৩ নম্বর বাসাই নেই। লেখার রূপ ঠিক, অর্থ ভুল। তৃতীয়টিতে লেখা: “বাসা ২৩, রোড ৪, মিরপুর ১০; মসজিদের পাশের গলি, সন্ধ্যার পর ফোন দেবেন”। শেষ অংশটি কোনো নিয়মের বই চায়নি, কিন্তু বাস্তবে এটিই কাজটি সহজ করল।

প্রোগ্রামিং ভাষারও ঠিক এই তিনটি স্তর আছে।

  • Syntax (রূপ): কোন অক্ষর আর token কোন ক্রমে বসলে লেখাটি ভাষার একটি বৈধ program. যেমন Haat-এ প্রতিটি statement শেষ হয় ; দিয়ে, আর if-এর শর্তের পরে { আসে।
  • Semantics (অর্থ): একটি বৈধ program-এর মানে কী, চালালে কী ঘটে, আর কোন program চালানোর আগেই অর্থহীন বলে বাতিল হবে। যেমন Haat-এ -7 / 2-এর মান -3, আর শূন্য দিয়ে ভাগ করলে division by zero runtime error.
  • Pragmatics (ব্যবহার): মানুষ ভাষাটি বাস্তবে কীভাবে ব্যবহার করেন: প্রচলিত লেখার ভঙ্গি (idiom), নামকরণ, error message কতটা কাজের, কোন বৈশিষ্ট্য কখন বেছে নেওয়া উচিত, আর একটি নির্দিষ্ট compiler বা interpreter বাস্তবে কেমন আচরণ করে।

বাংলা ভাষাতেই ভাবুন। “ভাত আমি খেয়েছি” আর “আমি ভাত খেয়েছি” দুটিই বাংলা ব্যাকরণে চলে, অর্থও এক। “আমি খেয়েছি ভাত টেবিল নীল” ব্যাকরণ ভাঙে। আর চায়ের দোকানে কেউ যদি বলেন “চা হবে?”, এর আক্ষরিক অর্থ একটি প্রশ্ন, কিন্তু ব্যবহারে এটি একটি অর্ডার। প্রথমটি syntax, দ্বিতীয়টি semantics, তৃতীয়টি pragmatics.

এই তিন ভাগের নাম প্রোগ্রামিং থেকে আসেনি। মার্কিন দার্শনিক Charles W. Morris ১৯৩৮ সালে “Foundations of the Theory of Signs” বইয়ে চিহ্নবিদ্যাকে তিন ভাগে ভাগ করেন: চিহ্নের সঙ্গে চিহ্নের সম্পর্ক (syntactics), চিহ্নের সঙ্গে বস্তুর সম্পর্ক (semantics) আর চিহ্নের সঙ্গে ব্যবহারকারীর সম্পর্ক (pragmatics). আর ভাষাবিদ Noam Chomsky ১৯৫৭ সালের “Syntactic Structures” বইয়ে বাক্য দেন “Colorless green ideas sleep furiously”: ইংরেজি ব্যাকরণে নিখুঁত, কিন্তু অর্থহীন। Syntax আর semantics যে আলাদা জিনিস, তার সবচেয়ে বিখ্যাত উদাহরণ এটিই।

Haat ভাষায় (এই কোর্সের চলমান প্রজেক্ট; পূর্ণ বিবরণ পর্ব ০১ আর পর্ব ৪৫-এ) তিন স্তরের তিনটি ছোট উদাহরণ:

let p = qty * unit        // syntax ভুল: শেষে ';' নেই
let ok = 5 > 3;
print(ok + 1);            // syntax ঠিক, অর্থ ভুল: Bool + Int
var limit = 5000;         // syntax আর অর্থ ঠিক; কিন্তু limit কখনো
print(limit);             // বদলায় না, তাই 'let' বেশি পরিষ্কার (pragmatics)

প্রথম লাইন parser-ই আটকাবে। দ্বিতীয়-তৃতীয় লাইন parser পার হবে, কিন্তু Haat-এর type checker বাতিল করবে। শেষ দুই লাইন চলবে, ঠিক ফলও দেবে; কোনো compiler আপত্তি তুলবে না। তবু অভিজ্ঞ একজন reviewer বলবেন, যে মান বদলায় না সেটি let দিয়ে ঘোষণা করুন। এই পর্বের বাকিটা এই তিন স্তরকে ধাপে ধাপে খুলে দেখা।

মূল ধারণা

একটি ভাষার সংজ্ঞা মানে syntax আর semantics. Pragmatics ভাষার সংজ্ঞার অংশ নয়, কিন্তু একটি ভাষা সফল হবে কি না তা অনেকটাই এর ওপর নির্ভর করে। Compiler বা interpreter লিখতে গেলে প্রথম দুটি হুবহু মানতে হয়; ভালো program লিখতে গেলে তিনটিই জানতে হয়।

২ · Syntax-এর ভেতরের স্তর: lexical, context-free আর context-sensitive

“Syntax ঠিক আছে কি না” একটি প্রশ্ন মনে হলেও compiler একে তিনটি আলাদা স্তরে ভাগ করে দেখে, কারণ প্রতিটি স্তরের জন্য আলাদা গণিত আর আলাদা কৌশল লাগে।

  1. Lexical স্তর (শব্দ চেনা): অক্ষরের সারি থেকে token বের করা: let একটি keyword, qty একটি নাম, 520 একটি সংখ্যা, >= একটি operator. এখানকার নিয়ম regular expression দিয়ে লেখা যায়, আর যে অংশ কাজটি করে তার নাম lexer. Haat-এ @ কোনো token নয়, তাই let x = 5 @ 2; এই স্তরেই আটকায়। তত্ত্বটি আছে গণনার তত্ত্ব কোর্সের পর্ব ২২ “Lexical analysis”-এ; Haat-এর lexer আমরা হাতে লিখব পর্ব ৪৬-এ।
  2. Context-free স্তর (বাক্য গঠন): token-গুলো কীভাবে nested গঠন বানায়: বন্ধনীর জোড়া, operator-এর precedence, block-এর ভেতরে block. এর নিয়ম context-free grammar (CFG) দিয়ে লেখা হয়, আর যে অংশ যাচাই করে তার নাম parser. print((2 + 3) * 4;-এ একটি বন্ধনী খোলা থেকে গেছে: এই স্তরের ভুল।
  3. Context-sensitive দিক (প্রসঙ্গ-নির্ভর শর্ত): “প্রতিটি নাম ব্যবহারের আগে ঘোষিত”, “function call-এ argument-এর সংখ্যা definition-এর সমান”, “var ছাড়া অন্য নামে assignment নিষেধ”। এগুলোতে program-এর দুটি দূরের অংশ (ঘোষণা আর ব্যবহার) হুবহু মিলতে হয়।

তৃতীয় ধরনের শর্ত CFG দিয়ে লেখা যায় না, এটি একটি প্রমাণিত সত্য, শুধু অসুবিধার কথা নয়। “ঘোষণা করা নাম পরে হুবহু আবার আসবে” গঠনটি মোটামুটি { w c w } ধরনের “কপি” language, যা context-free নয়; প্রমাণ CFL-এর pumping lemma দিয়ে (গণনার তত্ত্ব, পর্ব ৩৬)। পুরো ছবিটি, অর্থাৎ regular ⊂ context-free ⊂ context-sensitive ধাপের Chomsky hierarchy, আছে সেই কোর্সের পর্ব ০৬-এ।

তাহলে compiler কি context-sensitive grammar ব্যবহার করে? প্রায় কখনো না। এমন grammar পড়া, লেখা আর তা থেকে দ্রুত parser বানানো খুব কঠিন। প্রচলিত সমাধান হলো কাজ ভাগ করা: grammar শুধু context-free অংশ ধরে, আর প্রসঙ্গ-নির্ভর শর্তগুলো parser-এর পরের ধাপ semantic analysis-এ সাধারণ কোড দিয়ে যাচাই হয়, একটি symbol table ব্যবহার করে। এজন্যই অনেক বই এই শর্তগুলোকে বলে static semantics: রূপের নিয়ম, কিন্তু CFG-এর বাইরে, আর চালানোর আগেই যাচাই হয়।

Haat-এর নিয়মস্তরকে যাচাই করে
নাম [A-Za-z_][A-Za-z0-9_]*, সংখ্যা [0-9]+Lexical (regular)Lexer
// থেকে লাইনের শেষ পর্যন্ত commentLexicalLexer (বাদ দেয়)
* আগে, + পরে; বন্ধনীর জোড়াContext-freeParser
a < b < c নিষেধ (comparison non-associative)Context-freeParser
নাম ঘোষণার আগে ব্যবহার নিষেধ (top-level function বাদে)Context-sensitiveName resolution
শুধু var-এ assignment; Int + Bool নিষেধStatic semanticsType checker
/ শূন্যের দিকে কাটে; শূন্য দিয়ে ভাগ runtime errorDynamic semanticsচলার সময় interpreter/VM

কিছু ভাষায় এই ভাগাভাগি পরিষ্কার নয়। C-তে T * x; একটি গুণ, নাকি pointer ঘোষণা, তা নির্ভর করে T আগে typedef করা হয়েছে কি না তার ওপর। তাই বাস্তব C compiler-এ parser symbol table দেখে lexer-কে জানায় কোন নাম type; একে প্রায়ই “lexer hack” বলা হয়। Haat-এর নকশা ইচ্ছা করেই এমন অস্পষ্টতা এড়ায়।

৩ · Grammar হলো চুক্তিপত্র: Haat-এর একটি EBNF অংশ

ভাষার syntax লেখার প্রচলিত রীতি BNF (Backus–Naur Form): John Backus ১৯৫৯ সালে ALGOL 58-এর syntax বর্ণনায় একটি রীতি প্রস্তাব করেন, আর Peter Naur ALGOL 60-এর রিপোর্টে (১৯৬০) সেটিকে সামান্য বদলে ব্যবহার করেন। পরে Niklaus Wirth ১৯৭৭ সালে একটি ছোট প্রস্তাবে { … } (শূন্য বা বেশিবার) আর [ … ] (থাকতেও পারে) যোগ করা একটি সরল রূপ প্রচার করেন; এই ধরনের রূপকে বলে EBNF. ১৯৯৬ সালে ISO/IEC 14977 নামে EBNF-এর একটি মানও প্রকাশিত হয়, যদিও বাস্তবে প্রায় প্রতিটি ভাষার নথি নিজের মতো সামান্য আলাদা রীতি ব্যবহার করে।

Grammar-কে একটি চুক্তিপত্র ভাবুন। ভাষার ব্যবহারকারী জানেন কী লিখলে তা বৈধ; compiler লেখক জানেন কী মানতে হবে; আর দুটি আলাদা compiler একই grammar মানলে একই লেখা দুটিতেই বৈধ বা দুটিতেই অবৈধ। নিচে Haat-এর একটি অংশ: তিন রকম statement আর পুরো expression ভাষা। Precedence-এর প্রতিটি স্তরের জন্য একটি করে নিয়ম, নিচু থেকে উঁচু:

stmt       = "let" NAME "=" expr ";"
           | "print" "(" expr ")" ";"
           | expr ";" ;
expr       = or ;
or         = and { "||" and } ;
and        = equality { "&&" equality } ;
equality   = comparison [ ( "==" | "!=" ) comparison ] ;
comparison = additive [ ( "<" | "<=" | ">" | ">=" ) additive ] ;
additive   = term { ( "+" | "-" ) term } ;
term       = unary { ( "*" | "/" | "%" ) unary } ;
unary      = ( "-" | "!" ) unary | call ;
call       = primary { "(" [ expr { "," expr } ] ")" } ;
primary    = INT | STRING | "true" | "false" | NAME | "(" expr ")" ;

তিনটি জিনিস খেয়াল করুন। (১) { … } লুপ মানে বাঁ দিকে জোড়া বাঁধা: 10 - 3 - 2 পড়া হয় (10 - 3) - 2, অর্থাৎ left-associative. (২) equality আর comparison-এ { }-এর বদলে [ ]: প্রতি স্তরে সর্বোচ্চ একটি তুলনা, তাই 1 < 2 < 3 আর a == b == c grammar-এই অবৈধ (Haat রেফারেন্স implementation-এর সিদ্ধান্ত ১০), কিন্তু a < b == c < d বৈধ, কারণ সেখানে দুটি আলাদা স্তর। (৩) NAME হলো keyword নয় এমন যেকোনো নাম; let, print বা true নাম হতে পারে না। if, while, fn, var আর assignment এই অংশে নেই; পূর্ণ grammar আসবে পর্ব ৪৫ আর ৪৭-এ।

নিচের Python কোড এই grammar-এর একটি recognizer: এটি শুধু হ্যাঁ বা না বলে (সঙ্গে প্রথম ভুলের অবস্থান), কোনো গাছ বানায় না। প্রতিটি precedence স্তরের জন্য expr(lv)-এর একটি করে ডাক; একে বলে recursive descent. Error message Haat-এর নিয়মে line:col: error: … রূপে (একটি লাইনের input, তাই line সবসময় 1).

import re   # recognizer for a Haat fragment:  let NAME = expr ;  print(expr) ;  expr ;
TOK = re.compile(r'(\d+|"(?:[^"\\]|\\.)*"|\w+|<=|>=|==|!=|&&|\|\||[-+*/%<>!=(),;])|(\S)')
NAME = re.compile(r"(?!(let|var|fn|if|else|while|return|print|true|false)\b)[A-Za-z_]\w*")
LEVELS = [["||"], ["&&"], ["==", "!="], ["<", "<=", ">", ">="], ["+", "-"], ["*", "/", "%"]]
def recognize(src):
    toks = [(m[0], m.start() + 1, m.end() + 1, m[2]) for m in TOK.finditer(src)] + [("$", len(src) + 1, 0, None)]; k = 0
    def eat(t, msg):                       # t=None: always an error; a missing ';' is reported
        nonlocal k                         # just after the previous token, like Haat and gcc
        if toks[k][0] == t or t == "NAME" and NAME.fullmatch(toks[k][0]): k += 1; return
        raise SyntaxError(f"1:{toks[k - 1][2] if t == ';' else toks[k][1]}: error: {msg}")
    def expr(lv=0):                        # one loop per precedence level, low to high
        nonlocal k
        if lv < len(LEVELS):
            expr(lv + 1)
            while toks[k][0] in LEVELS[lv]:
                k += 1; expr(lv + 1)
                if lv in (2, 3) and toks[k][0] in LEVELS[lv]: eat(None, "comparison operators cannot be chained")
            return
        if toks[k][0] in ("-", "!"): k += 1; return expr(lv)                     # unary
        if toks[k][0] == "(": k += 1; expr(); eat(")", "expected ')' after expression")
        else: eat(toks[k][0] if re.fullmatch(r'\d+|".*"|true|false', toks[k][0]) else "NAME", "expected expression")
        while toks[k][0] == "(":                                                  # call f(a, b)
            k += 1; more = toks[k][0] != ")"
            while more: expr(); more = toks[k][0] == "," and not eat(",", "")
            eat(")", "expected ')' after arguments")
    try:
        for k in [i for i, t in enumerate(toks) if t[3]][:1]: eat(None, f"unexpected character '{toks[k][3]}'")
        kind = {"let": "variable declaration", "print": "print statement"}.get(toks[0][0], "expression")
        if kind[0] == "v": k = 1; eat("NAME", "expected variable name after 'let'"); eat("=", "expected '=' after variable name in 'let'")
        if kind[0] == "p": k = 1; eat("(", "expected '(' after 'print'"); expr(); eat(")", "expected ')' after print argument")
        else: expr()
        eat(";", f"expected ';' after {kind}"); eat("$", "expected end of input"); return "ok"
    except SyntaxError as e: return str(e)
for line in ["print(2 + 3 * 4);", "let first = price(2, 520) + 60;", "let ok = 1 < 2 < 3;", "print((2 + 3) * 4;",
             "let p = qty * unit", "let x = 5 @ 2;", "let flag = 5 > 3;", "print(flag + 1);"]: print(f"{line:33} {recognize(line)}")

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

print(2 + 3 * 4);                 ok
let first = price(2, 520) + 60;   ok
let ok = 1 < 2 < 3;               1:16: error: comparison operators cannot be chained
print((2 + 3) * 4;                1:18: error: expected ')' after print argument
let p = qty * unit                1:19: error: expected ';' after variable declaration
let x = 5 @ 2;                    1:11: error: unexpected character '@'
let flag = 5 > 3;                 ok
print(flag + 1);                  ok

প্রথম দুটি লাইন grammar-এর চোখে বৈধ। (দ্বিতীয়টি পুরো Haat-এ অবশ্য পরের ধাপে আটকাবে: price নামে কিছু ঘোষিত নেই, তাই undefined variable 'price'; সেটি name resolution-এর কাজ।) তৃতীয়টি দ্বিতীয় <-এ (কলাম ১৬) আটকেছে: grammar-এর [ ] একটির বেশি তুলনা দেয় না। চতুর্থটিতে কলাম ১৮-তে ; এসেছে যেখানে ) দরকার ছিল। পঞ্চমটিতে ; নেই, আর বার্তাটি দেওয়া হয়েছে আগের token-এর ঠিক পরে (কলাম ১৯), gcc আর Haat যেমন করে। এই recognizer-এর প্রতিটি বার্তা আর কলাম ২৪টি input-এ Haat রেফারেন্স implementation-এর python haat.py check-এর সঙ্গে মিলিয়ে দেখা হয়েছে; অমিল শুধু assignment-এ, যা এই অংশে নেই। ষষ্ঠটি lexical ভুল: @ কোনো token-ই নয়, তাই parser পর্যন্ত যাওয়াই হয়নি। সবচেয়ে গুরুত্বপূর্ণ শেষ দুটি লাইন: let flag = 5 > 3; আর print(flag + 1); দুটিই “ok”. Grammar-এর চোখে এরা নিখুঁত, যদিও দ্বিতীয়টি Haat-এ অর্থহীন (Bool-এর সঙ্গে Int যোগ)। এই ভুল ধরা grammar-এর কাজ নয়; অংশ ৫-এ দেখবেন কে ধরে। পূর্ণ Haat parser-এর কোড রেফারেন্স implementation-এর parser.py ফাইলে, আর ধাপে ধাপে লেখা হবে পর্ব ৪৭ ও ৪৮-এ।

Grammar-এর তত্ত্ব, যেমন derivation, parse tree, ambiguous grammar আর কীভাবে precedence-স্তর দিয়ে ambiguity দূর করা হয়, গণনার তত্ত্ব কোর্সে পূর্ণভাবে আছে: পর্ব ২৫ (CFG), পর্ব ২৭ (ambiguity) আর পর্ব ৪২ (grammar নকশা). এখানে আমরা সেটি আবার প্রমাণ করব না, শুধু ব্যবহার করব।

৪ · Concrete syntax বনাম abstract syntax

আপনি যা টাইপ করেন, প্রতিটি বন্ধনী, ফাঁকা জায়গা, ; আর comment-সহ, সেটি concrete syntax. Compiler-এর কাছে এর অনেকটাই শুধু পড়ার সুবিধার জন্য। (2 + 3) * 4-এ বন্ধনী বলে দেয় যোগ আগে; একবার সেটা জানা হয়ে গেলে বন্ধনীর আর কোনো কাজ নেই। Program-এর যে অংশ সত্যিই অর্থ বহন করে, অর্থাৎ কোন operation কোন operand-এর ওপর, সেটি abstract syntax.

দুই রকম syntax-এর জন্য দুই রকম গাছ। Grammar-এর প্রতিটি নিয়ম-প্রয়োগ একটি node হলে পাওয়া যায় parse tree (concrete syntax tree). শুধু অর্থবহ operation রাখলে পাওয়া যায় abstract syntax tree (AST). নিচের ছবিতে পরিচিত তিন-স্তরের grammar E → E + T ∣ T, T → T ∗ F ∣ F, F → ( E ) ∣ num দিয়ে (2 + 3) * 4-এর দুটি গাছ:

একই expression, দুটি গাছ

নীল: grammar-এর variable (E, T, F); হলুদ: token; সবুজ: AST-এর operation

Parse tree (18 nodes) versus AST (5 nodes) for (2 + 3) * 4 Parse tree (concrete syntax): ১৮টি node AST (abstract syntax): ৫টি node E T T * F F 4 ( E ) E + T T F F 3 2 * + 4 2 3 বন্ধনী নেই, শিকল নেই
ছবি ৩.১ — Parse tree-র ১৮টি node-এর পাতাগুলো বাঁ থেকে ডানে পড়লে হুবহু input: ( 2 + 3 ) * 4. AST-এ বন্ধনী নেই, কারণ গাছের আকারই বলে দেয় যোগ আগে।

নিচের stepper-এ parse tree থেকে AST কীভাবে পাওয়া যায়, ধাপে ধাপে দেখুন।

Token৭টি token
(   2   +   3   )   *   4
LP NUM PLUS NUM RP STAR NUM
Parse tree১৮টি node
E
└ T
  ├ T
  │ └ F
  │   ├ (
  │   ├ E
  │   │ ├ E─T─F─2
  │   │ ├ +
  │   │ └ T─F─3
  │   └ )
  ├ *
  └ F─4
শিকল ভাঙাএক-সন্তানের node বাদ
*
├ ( … )
│ └ +
│   ├ 2
│   └ 3
└ 4
AST৫টি node
*
├ +
│ ├ 2
│ └ 3
└ 4

Binary(*,
  Binary(+, Num 2, Num 3),
  Num 4)
একই ASTভিন্ন লেখা
(2 + 3) * 4
((2 + 3)) * (4)
(2+3)*4   // যোগফল
→ তিনটিরই AST হুবহু এক

2 + 3 * 4
→ ভিন্ন AST: + root-এ
  1. Token. Lexer ১১টি অক্ষর (ফাঁকা জায়গা বাদে ৭টি) থেকে ৭টি token দিল। এখানে এখনো কোনো গঠন নেই, শুধু একটি সারি।
  2. Parse tree. Parser grammar-এর নিয়ম খাটিয়ে ১৮টি node-এর গাছ বানাল: ১১টি variable আর ৭টি পাতা। যোগ ভেতরের E-তে, গুণ বাইরের T-তে: তাই যোগ আগে। লক্ষ করুন E─T─F─2-এর মতো লম্বা শিকল, যেগুলো শুধু grammar-এর স্তর পার হওয়ার চিহ্ন।
  3. শিকল ভাঙা। যে node-এর একটিমাত্র সন্তান, যেমন T → F বা E → T, সেটি নতুন কোনো তথ্য দেয় না; বাদ দিলে operator-গুলো সরাসরি তাদের operand-এর ওপরে বসে। বন্ধনী এখনো আছে, কিন্তু এর কাজ ইতিমধ্যে গাছের আকারে ধরা পড়েছে।
  4. AST. বন্ধনী বাদ দিলে থাকে ৫টি node: * root-এ, বাঁয়ে + (2 আর 3), ডানে 4. Haat-এর রেফারেন্স implementation একে Binary আর Num node দিয়ে রাখে। Type checker, interpreter আর compiler-এর বাকি সব ধাপ এই গাছটিই হাঁটে।
  5. অনেক লেখা, এক AST. বাড়তি বন্ধনী, ফাঁকা জায়গা বা comment বদলালে concrete syntax বদলায়, AST নয়। কিন্তু 2 + 3 * 4 আলাদা AST, কারণ সেখানে + root-এ, আর মানও আলাদা (14, যেখানে (2 + 3) * 4-এর মান 20).

Python নিজেও ঠিক এভাবে কাজ করে। CPython আপনার কোড পড়ে প্রথমে token, তারপর AST বানায়, আর standard library-র ast module দিয়ে সেই গাছ সরাসরি দেখা যায়। নিচের কোড একই expression-এর token-সারি আর AST দুটিই ছাপে, তারপর দেখায় AST থেকে আবার লেখা বানালে (ast.unparse) বাড়তি বন্ধনী হারিয়ে যায়।

import ast, io, sys, tokenize

src = "x = (2 + 3) * 4"
print("Python", sys.version.split()[0])

# 1. concrete syntax: every character group the reader typed
toks = tokenize.generate_tokens(io.StringIO(src).readline)
print([t.string for t in toks if t.string.strip()])

# 2. abstract syntax: the tree the compiler keeps
tree = ast.parse(src)
print(ast.dump(tree.body[0], indent=1))

# 3. the AST forgets the parentheses: unparse rebuilds minimal text
print(ast.unparse(ast.parse("x = ((2 + 3)) * (4)")))
print(ast.unparse(ast.parse("x = 2 + (3 * 4)")))

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

Python 3.14.2
['x', '=', '(', '2', '+', '3', ')', '*', '4']
Assign(
 targets=[
  Name(id='x', ctx=Store())],
 value=BinOp(
  left=BinOp(
   left=Constant(value=2),
   op=Add(),
   right=Constant(value=3)),
  op=Mult(),
  right=Constant(value=4)))
x = (2 + 3) * 4
x = 2 + 3 * 4

Token-সারিতে ৯টি টুকরো, বন্ধনীসহ। AST-এ বন্ধনীর চিহ্নমাত্র নেই: BinOp(Mult)-এর বাঁ সন্তান আরেকটি BinOp(Add), যা ছবি ৩.১-এর নিচের গাছের সঙ্গে হুবহু মেলে (Python-এর নামগুলো শুধু আলাদা: Constant, BinOp, Assign). ast.unparse AST থেকে লেখা বানায়, আর যেখানে বন্ধনী লাগবেই শুধু সেখানে বসায়: ((2 + 3)) * (4) হয়ে গেল (2 + 3) * 4, আর 2 + (3 * 4)-এর বন্ধনী বাদ পড়ল কারণ precedence নিজেই সেটি বোঝায়। Code formatter (যেমন Python-এর Black) মূলত এই কাজটিই করে: AST রেখে concrete syntax নতুন করে লেখে। CPython কীভাবে AST থেকে bytecode-এ যায়, তা আছে Python কোর্সের পর্ব ০৫-এ, আর এই কোর্সে পর্ব ০৪-এ।

সংজ্ঞা ৪.১ (Abstract syntax)

একটি ভাষার abstract syntax হলো program-এর এমন বর্ণনা, যেখানে প্রতিটি গঠনকে তার ধরন (যোগ, গুণ, let, print…) আর অংশগুলো দিয়ে চেনা হয়, কিন্তু সেটি কোন অক্ষরে লেখা হয়েছিল তা বাদ পড়ে। Haat-এর expression-এর abstract syntax গাণিতিকভাবে লেখা যায় এভাবে:
e ::= n ∣ s ∣ b ∣ x ∣ −e ∣ !e ∣ e ⊕ e ∣ e(e, …, e) ∣ fn(x : τ, …) → τ { … }
যেখানে n একটি পূর্ণসংখ্যা, s একটি string, b হলো true বা false, x একটি নাম, ⊕ যেকোনো binary operator, আর τ একটি type. খেয়াল করুন, এখানে বন্ধনী বা precedence-এর কোনো কথা নেই। এই grammar ambiguous, কিন্তু তাতে সমস্যা নেই, কারণ এটি লেখা পড়ার জন্য নয়, গাছের আকার বর্ণনার জন্য।

৫ · Static semantics আর dynamic semantics

Semantics-কেও দুই ভাগে দেখা হয়। Static মানে program চালানোর আগে (compile time), আর dynamic মানে চলার সময় (run time).

  • Static semantics: কোন বৈধ-রূপের program অর্থপূর্ণ, তা চালানোর আগেই ঠিক করার নিয়ম। Haat-এ: প্রতিটি নাম ব্যবহারের আগে ঘোষিত, assignment শুধু var-এ, +-এর দুই পাশে দুটিই Int বা দুটিই Str, if-এর শর্ত Bool. এগুলো যাচাই করে type checker আর name resolution.
  • Dynamic semantics: program চালালে কী ঘটে। Haat-এ: / শূন্যের দিকে কাটে, %-এর চিহ্ন ভাজ্যের মতো, && আর || short-circuit করে, Int overflow হলে wrap করে, শূন্য দিয়ে ভাগে runtime error: division by zero.

নিয়মগুলো সাধারণ বাংলায় লেখা যায়, কিন্তু ভাষা-গবেষকেরা এগুলো লেখেন inference rule হিসেবে: দাগের ওপরে শর্ত (premise), নিচে সিদ্ধান্ত (conclusion), ডানে নিয়মের নাম। প্রথমে Haat-এর +-এর দুটি typing rule. এখানে Γ (গামা) হলো type environment, অর্থাৎ কোন নামের কী type তার তালিকা (যেমন qty : Int, ok : Bool); Γ ⊢ e : τ পড়ুন “Γ-এর তথ্য দিয়ে e-এর type τ প্রমাণ করা যায়”:

Γ ⊢ e1 : Int    Γ ⊢ e2 : Int
Γ ⊢ e1 + e2 : Int
(T-Add)
Γ ⊢ e1 : Str    Γ ⊢ e2 : Str
Γ ⊢ e1 + e2 : Str
(T-Concat)
Γ ⊢ e1 : Int    Γ ⊢ e2 : Int
Γ ⊢ e1 > e2 : Bool
(T-Gt)

কোনো নিয়মের নিচের সারিতে Bool + Int মেলে না, তাই ok + 1-এর জন্য কোনো type প্রমাণ করা যায় না; checker তখন error দেয়। এবার dynamic দিক। e ⇓ v পড়ুন “e-এর মান হিসাব করলে v পাওয়া যায়” (এটি big-step রীতি, পর্ব ৪০-এ বিস্তারিত)। ভাগের দুটি নিয়ম, যেখানে trunc মানে শূন্যের দিকে কাটা:

e1 ⇓ n1    e2 ⇓ n2    n2 ≠ 0
e1 / e2 ⇓ trunc(n1 ÷ n2)
(E-Div)
e1 ⇓ n1    e2 ⇓ 0
e1 / e2 ⇓ error “division by zero”
(E-DivZero)

তাই Haat-এ -7 / 2 ⇓ trunc(−3.5) = −3. লক্ষ করুন, E-Div অনুযায়ী আগে e1, তারপর e2 হিসাব হয়; পূর্ণ নিয়মে এই ক্রমও বলে দেওয়া থাকে, যা পর্ব ২৬-এ evaluation order নিয়ে আলোচনায় গুরুত্বপূর্ণ হবে।

এখন সবচেয়ে শিক্ষণীয় ধরনের program: রূপে নিখুঁত, অর্থে ভুল। নিচের stepper-এ এর যাত্রা দেখুন।

1let qty = 3;2let ok = qty > 2;3print(ok + 1);
এই ধাপের অবস্থা
ধাপ
ফল
Γ
  1. Lexer. তিন লাইনে ১৯টি token: let qty = 3 ; (৫টি), let ok = qty > 2 ; (৭টি), print ( ok + 1 ) ; (৭টি)। প্রতিটি অক্ষরগুচ্ছ বৈধ token, তাই lexical স্তর পার।
  2. Parser. তিনটি statement-ই grammar মানে: দুটি Let আর একটি Print, যার ভেতরে Binary(+, Var ok, Num 1). Syntax-এর দিক থেকে program নিখুঁত; অংশ ৩-এর recognizer-ও একই গঠনের print(flag + 1);-কে “ok” বলেছিল।
  3. Name resolution. লাইন ২-এ qty ব্যবহারের আগে লাইন ১-এ ঘোষিত; লাইন ৩-এ ok লাইন ২-এ ঘোষিত। প্রসঙ্গ-নির্ভর শর্তও পার।
  4. Type checker. 3 থেকে qty : Int; T-Gt থেকে qty > 2 : Bool, তাই ok : Bool. লাইন ৩-এ ok + 1-এ বাঁয়ে Bool, ডানে Int: T-Add চায় দুটিই Int, T-Concat চায় দুটিই Str. কোনো নিয়ম খাটে না, তাই বার্তা আসে লাইন ৩, কলাম ৭-এ, যেখানে ok শুরু। Program একবারও চলেনি।
  5. অন্য ভাষায়। একই গঠনের program C17, Python 3.14 আর JavaScript-এ চালিয়ে দেখা হয়েছে (সত্যিকারের run): তিনটিই 2 ছাপে। C-তে তুলনার ফল int 1; Python-এ True আসলে int-এর subclass; JavaScript true-কে সংখ্যা 1-এ বদলায়। Haat-এ implicit conversion নেই, তাই একই syntax-এর অর্থ এখানে “অবৈধ”।

“Python-এ type error চলার সময় ধরা পড়ে” কথাটি সাধারণভাবে সত্য, কিন্তু উপরের উদাহরণে Python কোনো error-ই দেয় না, কারণ Python-এর semantics-এ True + 1 বৈধ। কোন জিনিস ভুল, তা নির্ভর করে ভাষার semantics-এর ওপর; এক ভাষার নিয়ম অন্য ভাষায় চাপিয়ে দেবেন না।

৬ · একই লেখা, ভিন্ন অর্থ: চারটি ভাষায় সত্যিকারের run

অনেক ভাষার syntax এত কাছাকাছি যে মনে হয় অর্থও এক। -7 / 2 লেখাটি C, Python, JavaScript আর Haat চারটিতেই বৈধ। কিন্তু মান? প্রথমে C. নিচের program GCC দিয়ে চালান (warning চালু); তিনটি জিনিস একসঙ্গে দেখায়: ঋণাত্মক সংখ্যার ভাগ আর ভাগশেষ, string literal-এ +, আর শর্তের ভেতরে =.

#include <stdio.h>

int main(void) {
    /* integer division and remainder with a negative operand */
    printf("-7 / 2 = %d\n", -7 / 2);
    printf("-7 %% 2 = %d\n", -7 % 2);
    printf("7 / -2 = %d\n", 7 / -2);
    printf("7 %% -2 = %d\n", 7 % -2);

    /* "+" on a string literal: pointer arithmetic, not joining */
    printf("\"bazar\" + 2 -> %s\n", "bazar" + 2);

    /* "=" inside a condition is an assignment expression */
    int stock = 5;
    if (stock = 0) {
        printf("never printed\n");
    }
    printf("stock is now %d\n", stock);
    return 0;
}

আসল আউটপুট (সত্যিকারের run: Zig 0.17.1-এর সঙ্গে আসা Clang 22.1.8, -std=c17 -Wall -Wextra; “চালান” বোতাম একই কোড Wandbox-এর GCC-তে চালায়, আর এখানে প্রতিটি লাইনের ফল C standard-এ নির্দিষ্ট, তাই যেকোনো C99-মানা compiler একই লেখা দেবে):

-7 / 2 = -3
-7 % 2 = -1
7 / -2 = -3
7 % -2 = 1
"bazar" + 2 -> zar
stock is now 0

C99 থেকে C-র নিয়ম: ভাগফল শূন্যের দিকে কাটা হয় (−3.5 → −3), আর ভাগশেষের চিহ্ন হয় ভাজ্যের মতো, যাতে সবসময় (a/b)*b + a%b == a থাকে। (C89-এ ঋণাত্মক operand-এ দিকটি implementation-এর ওপর ছাড়া ছিল।) "bazar" + 2 কোনো জোড়া লাগানো নয়: string literal একটি char-এর array, + 2 pointer-কে দুই ঘর সরায়, তাই zar. শর্তের stock = 0 তুলনা নয়, assignment: stock-এ 0 বসে, শর্তের মান 0, ভেতরের লাইন চলে না। Clang-এর সত্যিকারের দুটি warning ঠিক এই দুই জায়গায়: adding 'int' to a string does not append to the string [-Wstring-plus-int] আর using the result of an assignment as a condition without parentheses [-Wparentheses]. Syntax বৈধ, semantics আপনার আশামতো নয়, আর শুধু warning আপনাকে সাবধান করে। C-র operator-গুলোর বিস্তারিত আছে C কোর্সের পর্ব ০৭-এ।

এবার একই লেখাগুলো Python 3-এ। Python-এ / সবসময় দশমিক (float) ভাগ, আর পূর্ণসংখ্যার ভাগের জন্য আলাদা operator //, যা নিচের দিকে (−∞-এর দিকে) গোল করে।

import math, sys
print("Python", sys.version.split()[0])
print("-7 // 2 =", -7 // 2)            # floor division
print("-7 % 2 =", -7 % 2)              # remainder takes the divisor's sign
print("7 // -2 =", 7 // -2, "  7 % -2 =", 7 % -2)
print("-7 / 2 =", -7 / 2)              # true division gives a float
print("int(-7 / 2) =", int(-7 / 2))    # C-style: truncate toward zero
print("math.fmod(-7, 2) =", math.fmod(-7, 2))
print('"bazar" + "ghor" =', "bazar" + "ghor")
for text in ('"bazar" + 2', '[10, 20][5]', 'compile("if stock = 0: pass", "<s>", "exec")'):
    try:
        print(text, "=", eval(text))
    except Exception as e:
        print(text, "->", type(e).__name__ + ":", e)

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

Python 3.14.2
-7 // 2 = -4
-7 % 2 = 1
7 // -2 = -4   7 % -2 = -1
-7 / 2 = -3.5
int(-7 / 2) = -3
math.fmod(-7, 2) = -1.0
"bazar" + "ghor" = bazarghor
"bazar" + 2 -> TypeError: can only concatenate str (not "int") to str
[10, 20][5] -> IndexError: list index out of range
compile("if stock = 0: pass", "<s>", "exec") -> SyntaxError: invalid syntax. Maybe you meant '==' or ':=' instead of '='? (<s>, line 1)

-7 // 2 হলো −4, C-র −3 নয়, কারণ Python নিচের দিকে গোল করে; আর তার সঙ্গে মিল রাখতে -7 % 2 হলো 1 (ভাজকের চিহ্ন)। Python-এও (a//b)*b + a%b == a সত্য, শুধু জোড়াটি আলাদা। C-র মতো ফল চাইলে int(-7 / 2) আর math.fmod. + দুটি str-এ জোড়া লাগায়, কিন্তু str আর int মেশালে TypeError: Python নিজে থেকে type বদলায় না। Array-র সীমার বাইরে গেলে IndexError (C-তে একই কাজ undefined behavior, তাই সেটি চালানো হয়নি)। আর শর্তে = লিখলে Python লেখাটিকে syntax-এর স্তরেই বাতিল করে, এমনকি পরামর্শও দেয়: == নাকি :=?

JavaScript-এর জন্য একই লেখাগুলো Node.js v24.15.0-এ চালানো হয়েছে (সত্যিকারের run, নিজের কম্পিউটারে):

console.log("-7 / 2 =", -7 / 2);
console.log("-7 % 2 =", -7 % 2);
console.log('"bazar" + 2 =', "bazar" + 2);
console.log('"5" - 3 =', "5" - 3);
const a = [10, 20];
console.log("a[5] =", a[5]);
let stock = 5;
if (stock = 0) { console.log("never printed"); }
console.log("stock is now", stock);
$ node same_text.js
-7 / 2 = -3.5
-7 % 2 = -1
"bazar" + 2 = bazar2
"5" - 3 = 2
a[5] = undefined
stock is now 0

JavaScript-এ সংখ্যা মানেই দশমিক সংখ্যা (IEEE 754 double), তাই -7 / 2 হলো −3.5; কিন্তু % C-র মতো ভাজ্যের চিহ্ন নেয় (−1). +-এর একপাশে string থাকলে অন্যপাশ string-এ বদলে জোড়া লাগে (bazar2), অথচ - string-কে সংখ্যায় বদলায় ("5" - 3 = 2). সীমার বাইরে পড়লে error নয়, undefined. এই নিয়মগুলোর বিস্তারিত JavaScript কোর্সের পর্ব ০৬-এ।

চারটি ভাষা পাশাপাশি দেখুন। প্রতিটি ধাপে একটি লেখা, আর প্রতিটি ভাষায় তার অর্থ (C, Python আর JavaScript-এর মান উপরের সত্যিকারের run থেকে; Haat-এর মান তার নির্দিষ্ট নিয়ম থেকে):

1-7 / 22-7 % 23"bazar" + 24if (stock = 0) …5a[5]  (a-তে ২টি মান)
অর্থ
C17
Python 3.14
JavaScript
Haat
  1. -7 / 2. C আর Haat-এ পূর্ণসংখ্যার ভাগ, শূন্যের দিকে কাটা: −3. Python 3 আর JavaScript-এ / দশমিক ভাগ: −3.5. Python-এ পূর্ণসংখ্যার ভাগ চাইলে //, যা −4 দেয়। একই চিহ্ন, তিনটি ভিন্ন মান।
  2. -7 % 2. C, JavaScript আর Haat-এ ভাগশেষ ভাজ্যের চিহ্ন নেয়: −1. Python-এ ভাজকের চিহ্ন: 1. সংখ্যাটি জোড় না বিজোড় দেখতে কেউ n % 2 == 1 লিখলে C-তে ঋণাত্মক বিজোড় সংখ্যায় ভুল উত্তর পাবেন, Python-এ পাবেন না।
  3. "bazar" + 2. C-তে pointer দুই ঘর সরে: zar. Python-এ চলার সময় TypeError. JavaScript 2-কে string বানিয়ে জোড়ে: bazar2. Haat-এ Str + Int কোনো typing rule মানে না, তাই চালানোর আগেই type error.
  4. শর্তে =. C আর JavaScript-এ assignment একটি expression, তাই বৈধ: stock-এ 0 বসে, শর্ত মিথ্যা। Python-এ শর্তে = syntax-এই নিষেধ। Haat-এ assignment শুধু statement, আর if-এর শর্তের পরে { আসার কথা, তাই if stock = 0 { একটি syntax error; রেফারেন্স implementation বলে expected '{' after if condition, ঠিক =-এর অবস্থানে।
  5. a[5], দুই মানের array-তে। C-তে undefined behavior: যা খুশি ঘটতে পারে, তাই চালিয়ে “ফল” দেখানো অর্থহীন। Python-এ IndexError, JavaScript-এ undefined. Haat v1-এ array-ই নেই; এটি আসবে পরে “Haat-এর বর্ধিত রূপ” হিসেবে, আর তখন আমরা সীমা-যাচাই বেছে নেব।
উপপাদ্য ৬.১ (দুই রকম ভাগ, একই অভেদ)

b ≠ 0 হলে truncating ভাগ (qt = trunc(a/b), rt = a − b·qt) আর flooring ভাগ (qf = ⌊a/b⌋, rf = a − b·qf) দুটিই a = b·q + r মানে, আর দুটিতেই |r| < |b|. পার্থক্য শুধু r-এর চিহ্নে: rt-এর চিহ্ন a-এর মতো, rf-এর চিহ্ন b-এর মতো (r = 0 হলে দুটিই সমান)।

প্রমাণের রূপরেখা: (১) a = b·q + r দুটিতেই সংজ্ঞা থেকে সরাসরি আসে। (২) Flooring-এ qf ≤ a/b < qf + 1. b > 0 হলে b দিয়ে গুণ করে 0 ≤ a − b·qf < b, অর্থাৎ 0 ≤ rf < b: চিহ্ন b-এর মতো। b < 0 হলে অসমতা উল্টে যায়: b < rf ≤ 0. (৩) Truncating-এ a/b ≥ 0 হলে trunc = floor, তাই rt = rf; আর a, b একই চিহ্নের হলে r-এর চিহ্ন দুটিরই সঙ্গে মেলে। a/b < 0 হলে trunc(a/b) = ⌈a/b⌉, আর একই যুক্তিতে rt হয় 0 অথবা a-এর চিহ্নের। ∎ উদাহরণ: a = −7, b = 2: truncating দেয় q = −3, r = −1; flooring দেয় q = −4, r = 1. দুটিতেই 2·q + r = −7.

৭ · Pragmatics: ভাষা বাস্তবে কীভাবে ব্যবহার হয়

দুটি program-এর semantics হুবহু এক হতে পারে, তবু একটি অন্যটির চেয়ে অনেক ভালো। বাজারঘরের দুই প্রোগ্রামার একই হিসাব দুইভাবে লিখলেন:

var a = 2;
var b = 520;
var c = a * b;
var d = c;
if c >= 1000 { d = c - c / 10; }
print(d);
// ১০০০ টাকা বা বেশি হলে ১০% ছাড়
fn price(qty: Int, unit: Int) -> Int {
    let p = qty * unit;
    if p >= 1000 { return p - p / 10; }
    return p;
}
print(price(2, 520));

দুটিই 936 ছাপে (2 × 520 = 1040, ১০% ছাড় 104, বাকি 936), আর পর্ব ০১-এর bazar.haat-এর প্রথম আউটপুট 996 হলো এই 936-এর সঙ্গে ৬০ টাকা ডেলিভারি চার্জ। কিন্তু সংস্করণ খ পড়তে, পরীক্ষা করতে আর আবার ব্যবহার করতে অনেক সহজ: নামগুলো অর্থ বলে, যা বদলায় না সেটি let, আর নিয়মটি একটি function-এ বন্দি। এই পার্থক্য syntax বা semantics-এর নয়, pragmatics-এর।

প্রোগ্রামিং ভাষার pragmatics-এ সাধারণত যা পড়ে:

  • Idiom: একটি কাজের প্রচলিত লেখার ভঙ্গি। Python-এ for x in items: idiomatic, for i in range(len(items)): দিয়ে সূচক ধরে হাঁটা চলে কিন্তু অভিজ্ঞ পাঠকের চোখে লাগে। C-তে if (0 == x) (“Yoda condition”) একসময় =-ভুল ঠেকানোর idiom ছিল; আধুনিক compiler-এর warning আসার পর এর দরকার অনেক কমেছে।
  • Style guide আর convention: Python-এর PEP 8 (২০০১), Go-র gofmt: নাম, ফাঁকা জায়গা, লাইনের দৈর্ঘ্য। কোনো compiler এগুলো জোর করে না (Go-তে tool-টি নিজেই format করে দেয়), কিন্তু দলের সবাই একই রীতি মানলে কোড পড়া সহজ হয়।
  • Implementation-এর আচরণ: ভাষার সংজ্ঞা যা খোলা রেখেছে, একটি নির্দিষ্ট compiler সেখানে কী করে। C-তে int-এর আকার implementation-defined; CPython-এ recursion-এর ডিফল্ট সীমা 1000 (sys.getrecursionlimit()), যা Python ভাষার নিয়ম নয়, CPython-এর পছন্দ। কিছু লেখক (যেমন Michael L. Scott-এর বই “Programming Language Pragmatics”) pragmatics বলতে মূলত এই implementation-এর দিকটিই বোঝান।
  • Diagnostic-এর মান: error message কতটা কাজের, তা ভাষার সংজ্ঞায় নেই, কিন্তু ব্যবহারে বিশাল প্রভাব ফেলে। Python-এর “Maybe you meant '==' or ':='?” ধরনের পরামর্শ, Clang-এর -Wparentheses নোট: সবই pragmatics-এর বিনিয়োগ। Haat-এর বার্তার নির্দিষ্ট রূপ (line:col: error: …) এই কারণেই নকশার অংশ; পর্ব ৫০-এ ভালো diagnostic লেখা শিখব।

Pragmatics ভাষার নকশাকেও বদলায়। শর্তে = আর == গুলিয়ে ফেলা C-র এত পুরোনো ও পরিচিত ভুল যে Python ইচ্ছা করেই শর্তে = নিষেধ রাখে; আর ২০১৮ সালে PEP 572 যখন expression-এর ভেতরে assignment আনল (Python 3.8-এ), তখন আলাদা চিহ্ন := বেছে নেওয়া হলো, যাতে দুটি কখনো গুলিয়ে না যায়। Haat-ও একই কারণে assignment-কে শুধু statement রেখেছে। পর্ব ০৬-এ এমন নকশা-সিদ্ধান্ত বিস্তারিত।

৮ · Semantics লেখার তিন রীতি: একটি পূর্বাভাস

ALGOL 60-এর রিপোর্ট syntax লিখেছিল BNF-এ, নিখুঁতভাবে; কিন্তু semantics লিখেছিল ইংরেজি গদ্যে। ফলাফল: কয়েক বছর পর Donald Knuth ১৯৬৭ সালে “The Remaining Trouble Spots in ALGOL 60” প্রবন্ধে ভাষাটির বেশ কিছু অস্পষ্ট জায়গার তালিকা দেন, যেখানে দুটি সৎ compiler আলাদা অর্থ করতে পারত। এ থেকেই semantics-কে গাণিতিকভাবে লেখার চেষ্টা জোর পায়। প্রধান তিনটি রীতি, Haat-এর একটি statement x = x + 1; দিয়ে (σ হলো memory-র অবস্থা, প্রতিটি নামের বর্তমান মান):

রীতিx = x + 1; সম্পর্কে যা বলেএই কোর্সে
Operational⟨x = x + 1;, σ⟩ ⟶ σ[x ↦ σ(x) + 1]: যন্ত্র কীভাবে এক ধাপ এগোয়পর্ব ৪০; interpreter (পর্ব ৫৬) এরই কোড-রূপ
Denotational⟦x = x + 1;⟧ = λσ. σ[x ↦ σ(x) + 1]: statement-টি অবস্থা থেকে অবস্থায় একটি গাণিতিক functionপর্ব ৪১
Axiomatic{x = n} x = x + 1; {x = n + 1}: আগের শর্ত সত্য হলে পরের শর্ত সত্যপর্ব ৪২ (Hoare logic)

তিনটি রীতি একই ভাষাকে তিন দিক থেকে দেখে: interpreter লেখকের চোখে (কীভাবে চলে), গণিতবিদের চোখে (কী মান বোঝায়), আর যাচাইকারীর চোখে (কী প্রমাণ করা যায়)। Hoare triple আর loop invariant-এর গাণিতিক ভিত্তি আগে দেখতে চাইলে Discrete Mathematics কোর্সের পর্ব ১৩ দেখুন। বাস্তবেও এর প্রয়োগ আছে: Standard ML-এর সংজ্ঞা (Milner, Tofte ও Harper, ১৯৯০) পুরো ভাষার formal semantics দেয়, আর WebAssembly-র আনুষ্ঠানিক specification-এ (২০১৭ থেকে) প্রতিটি instruction-এর typing আর execution নিয়ম ঠিক এই ধরনের inference rule-এ লেখা।

প্রসঙ্গ-নির্ভর নিয়মও grammar-এ ধরার চেষ্টা হয়েছিল। ALGOL 68-এর রিপোর্ট (১৯৬৮) Adriaan van Wijngaarden-এর two-level grammar ব্যবহার করে “ঘোষণার আগে ব্যবহার নয়”-এর মতো শর্তও grammar-এ লিখেছিল; ক্ষমতা ছিল বিশাল (এ ধরনের grammar Turing-সম্পূর্ণ বলে পরিচিত), কিন্তু পড়া এত কঠিন ছিল যে ধারাটি মূলধারায় টেকেনি। একই বছর Donald Knuth “Semantics of Context-Free Languages” প্রবন্ধে attribute grammar প্রস্তাব করেন: CFG-এর প্রতিটি node-এ মান (attribute) জুড়ে তা দিয়ে type বা অর্থ হিসাব করা। এই ধারণাটি আজও compiler-এ বেঁচে আছে; পর্ব ৫৩-এ দেখবেন।

আরও গভীরে: Formal semantics শুধু তত্ত্ব নয়। CompCert নামের C compiler-এর (Xavier Leroy আর সহকর্মীরা, ২০০৫-এর দিক থেকে) বড় অংশের জন্য Coq proof assistant-এ যন্ত্র-যাচাইকৃত প্রমাণ আছে যে compile করা code source-এর semantics রক্ষা করে; এর ভিত্তি C-র একটি বড় অংশের সম্পূর্ণ operational semantics. গবেষকেরা C-র “undefined behavior”-এর নিয়মও formal রূপে লিখেছেন, যেমন K framework-এ লেখা C semantics, যা দিয়ে কোনো program UB ঘটায় কি না পরীক্ষা করা যায়। আর Rice-এর উপপাদ্য (গণনার তত্ত্ব, পর্ব ৫৩) মনে করিয়ে দেয়: dynamic semantics-এর যেকোনো অ-তুচ্ছ ধর্ম সাধারণভাবে যন্ত্রে নিশ্চিতভাবে নির্ণয় করা যায় না, তাই static semantics সবসময় সাবধানী একটি আসন্নমান।

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

  • Syntax আর semantics-এর পার্থক্য উদাহরণসহ বলুন। Syntax লেখার বৈধ রূপ (; বাদ পড়া syntax error); semantics অর্থ ("5" + 3 Python-এ TypeError, JavaScript-এ "53").
  • Static আর dynamic semantics কী? Static: চালানোর আগে যাচাইযোগ্য নিয়ম (ঘোষণা, type); dynamic: চলার সময়ের আচরণ (মান, runtime error).
  • Parse tree আর AST-এর পার্থক্য? Parse tree-তে প্রতিটি grammar নিয়ম আর প্রতিটি token; AST-এ শুধু operation আর operand, বন্ধনী ও এক-সন্তানের শিকল বাদ।
  • “ব্যবহারের আগে ঘোষণা” কেন grammar-এ লেখা হয় না? এটি context-free নয় ({wcw}-ধরনের কপি); compiler একে symbol table দিয়ে semantic analysis-এ যাচাই করে।
  • C-তে -7 / 2 আর -7 % 2? C99 থেকে −3 আর −1 (শূন্যের দিকে কাটা); Python-এ -7 // 2 = −4, -7 % 2 = 1.

৯ · AI-এর যুগে syntax আর semantics

AI assistant syntax-এ সাধারণত দারুণ: তার লেখা কোড প্রায় সবসময় parse হয়। ভুলগুলো লুকিয়ে থাকে semantics-এ, আর সেখানে AI প্রায়ই এক ভাষার নিয়ম আরেক ভাষায় চাপায়। এই পর্বের বিষয়ে যে ভুলগুলো বারবার দেখা যায়:

AI-এর দাবিবাস্তবতাকীভাবে ধরবেন
“-7 % 2 সব ভাষায় 1”C, Java, JavaScript-এ −1; Python-এ 1প্রতিটি ভাষায় চালান
“Python-এ bool আর int মেশালে TypeError”True + 1 হলো 2Pyodide-এ এক লাইন চালান
“C-তে array-র বাইরে পড়লে 0 আসে”Undefined behavior: কোনো নির্দিষ্ট ফল নেইC standard পড়ুন; sanitizer চালান
Parser-এ a - b - c-কে a - (b - c) বানায়Left-associative হওয়ার কথা10 - 3 - 2 = 5 পরীক্ষা লিখুন
“Compiler আপনার =-ভুল error দেবে”C-তে বৈধ; শুধু warning, তাও -Wall দিলেWarning চালু রেখে compile করুন

AI-কে semantics-এর প্রশ্ন করলে ভাষা আর version নির্দিষ্ট করুন, আর উত্তর যাচাইযোগ্য রূপে চান:

নিচের expression-গুলোর মান C17 (GCC), Python 3.14 আর JavaScript (Node 20)-এ আলাদা আলাদা বলো: -7 / 2, -7 % 2, "5" + 3, true + 1. প্রতিটি উত্তরের সঙ্গে ভাষার specification-এর কোন নিয়ম এটি ঠিক করে, তা উল্লেখ করো। কোথাও undefined বা implementation-defined behavior থাকলে স্পষ্ট বলো, অনুমান করে মান দিও না। শেষে প্রতিটি ভাষায় চালিয়ে যাচাই করার মতো একটি ছোট test program দাও।

AI-এর উত্তর হাতে পেলে: যাচাইয়ের চেকলিস্ট

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

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

প্র ০১ALGOL 60 syntax লিখেছিল BNF-এ, কিন্তু semantics ইংরেজিতে। এতে কী সমস্যা হয়েছিল, আর আধুনিক ভাষাগুলো কী শিখেছে?

ALGOL 60-এর রিপোর্ট (সম্পাদক Peter Naur, ১৯৬০; সংশোধিত রূপ ১৯৬৩) ভাষা-নকশার ইতিহাসে একটি মাইলফলক, কারণ প্রথমবারের মতো একটি বড় ভাষার syntax পুরোপুরি একটি formal notation-এ লেখা হয়। এর সুফল সঙ্গে সঙ্গে দেখা যায়: কোন লেখা বৈধ, তা নিয়ে তর্কের অবকাশ প্রায় থাকল না, আর grammar থেকে যান্ত্রিকভাবে parser বানানোর গবেষণার দরজা খুলে গেল, যা পরে LL আর LR parsing-এর তত্ত্বে পৌঁছায়।

কিন্তু semantics ছিল সতর্ক ইংরেজি গদ্যে, আর গদ্য যত সতর্কই হোক, অস্পষ্টতা থাকে। Donald Knuth ১৯৬৭ সালে “The Remaining Trouble Spots in ALGOL 60” প্রবন্ধে এমন বহু জায়গা তালিকাভুক্ত করেন: যেমন for loop-এর নিয়ন্ত্রক variable-এর মান loop শেষে কী থাকবে, side effect-ওয়ালা expression কোন ক্রমে হিসাব হবে, call-by-name parameter-এর সঙ্গে এগুলোর মিশ্রণে কী ঘটবে। এসব প্রশ্নে দুটি compiler দুটি “সঠিক” কিন্তু ভিন্ন উত্তর দিতে পারত, আর একই program দুই যন্ত্রে দুই ফল দিত।

এর পরের দশকগুলোতে তিনটি ধারা আসে। একটি হলো semantics-কে গণিতে লেখা: Standard ML-এর সংজ্ঞা (১৯৯০) পুরো ভাষার typing আর evaluation নিয়ম inference rule-এ দেয়, আর WebAssembly-র specification-এও প্রতিটি instruction-এর নিয়ম formal রূপে। দ্বিতীয়টি হলো খুব বিস্তারিত গদ্য-মান, যেমন C আর C++-এর ISO standard, যেখানে অস্পষ্টতা এড়াতে “undefined”, “unspecified” আর “implementation-defined” শব্দগুলোর সুনির্দিষ্ট অর্থ দেওয়া হয়েছে। তৃতীয়টি হলো একটি reference implementation-কেই কার্যত সংজ্ঞা ধরা, যেমন বহুদিন CPython-এর ক্ষেত্রে হয়েছে; এর সঙ্গে বিশাল test suite, যা অন্য implementation-কে মেলাতে হয়।

Haat এই কোর্সে তিনটিরই একটু নেয়: একটি লিখিত নির্দিষ্ট spec, পর্ব ৩৪ আর ৪০-এ formal নিয়ম, আর একটি reference implementation যার আউটপুটের সঙ্গে প্রতিটি পর্বের কোড মেলানো হয়।

মূল উপলব্ধি: Syntax formal করা তুলনামূলক সহজ, আর লাভ দ্রুত চোখে পড়ে; semantics formal করা কঠিন, কিন্তু না করলে অস্পষ্টতার দাম দেন ব্যবহারকারীরা, বছরের পর বছর।

প্র ০২FORTRAN-এ ফাঁকা জায়গার কোনো মূল্য ছিল না। DO 10 I = 1.10-এর গল্পটি lexical নকশা সম্পর্কে কী শেখায়?

শুরুর দিকের FORTRAN-এ (১৯৫৭ সালে প্রকাশিত, John Backus-এর দলের তৈরি) statement-এর ভেতরের ফাঁকা জায়গা compiler সম্পূর্ণ উপেক্ষা করত। Punch card-এর যুগে এটি সুবিধাজনক মনে হয়েছিল: যে যেভাবে খুশি ফাঁক দিয়ে লিখুক। কিন্তু এর একটি অদ্ভুত পরিণতি আছে। DO 10 I = 1,10 একটি loop: লেবেল 10 পর্যন্ত, I-কে 1 থেকে 10. কমার জায়গায় ভুলে বিন্দু দিলে DO 10 I = 1.10 হয়ে যায়, আর ফাঁকা জায়গা বাদ দিলে এটি DO10I = 1.10: DO10I নামের একটি নতুন variable-এ 1.1 বসানো। FORTRAN-এ variable ঘোষণা না করেও ব্যবহার করা যেত, তাই কোনো error আসত না; loop-টি নিঃশব্দে একটি assignment হয়ে যেত।

এই ভুলটি নিয়ে একটি বিখ্যাত গল্প প্রচলিত আছে যে এর কারণে একটি মহাকাশযান হারিয়ে যায়। ইতিহাসবিদদের মতে গল্পটি অন্তত আংশিক ভুল-আরোপ: এমন একটি ভুল NASA-র একটি প্রকল্পের কোডে ধরা পড়েছিল বলে বর্ণনা আছে, কিন্তু যে মহাকাশযানের নাম সাধারণত বলা হয়, তার ব্যর্থতার কারণ ছিল ভিন্ন। তাই গল্পটি সতর্কভাবে বলা উচিত; তবে ভাষাগত শিক্ষাটি পুরোপুরি সত্য।

শিক্ষাটি হলো: lexical স্তরের নকশা অর্থের নিরাপত্তায় প্রভাব ফেলে। FORTRAN-এর lexer-কে কোন অক্ষরগুচ্ছ একটি token, তা ঠিক করতে কখনো কখনো অনেক দূর পর্যন্ত সামনে দেখতে হতো (কমা আছে কি না দেখার পরেই বোঝা যেত এটি DO statement নাকি assignment). আধুনিক প্রায় সব ভাষা ফাঁকা জায়গাকে token-এর সীমানা হিসেবে ব্যবহার করে, keyword-কে সংরক্ষিত রাখে, আর variable ব্যবহারের আগে ঘোষণা চায়। Haat-এও তাই: let ছাড়া নতুন নাম আসে না, আর অপরিচিত নাম undefined variable error দেয়। Python আরও এক ধাপ এগিয়ে indentation-কেই syntax-এর অংশ করেছে; tokenizer লাইনের শুরুর ফাঁক মেপে INDENT আর DEDENT token বানায়।

মূল উপলব্ধি: “ছোট” lexical সিদ্ধান্তও semantics-এ বড় ঝুঁকি তৈরি করতে পারে। ভালো ভাষা এমনভাবে নকশা করা হয় যাতে একটি টাইপো সাধারণত একটি error দেয়, নিঃশব্দে অন্য বৈধ program নয়।

প্র ০৩C শূন্যের দিকে কাটে, Python নিচের দিকে গোল করে। কোনটি “সঠিক”, আর Haat C-র পথ বেছে নিল কেন?

গাণিতিকভাবে দুটিই বৈধ: উপপাদ্য ৬.১ দেখায়, দুটিই a = b·q + r আর |r| < |b| মানে; পার্থক্য শুধু r-এর চিহ্নে। তাই প্রশ্নটি “কোনটি সত্য” নয়, “কোনটি কাজে বেশি সুবিধা দেয়”।

Python-এর পক্ষে যুক্তি: Python-এর স্রষ্টা Guido van Rossum তাঁর “The History of Python” ব্লগে (২০১০ সালের একটি লেখায়) ব্যাখ্যা করেন, ভাজক ধনাত্মক হলে flooring-এ ভাগশেষ সবসময় 0 থেকে b − 1-এর মধ্যে থাকে, যা বাস্তবে প্রায়ই দরকার। যেমন একটি timestamp থেকে দিনের ঘণ্টা বের করতে t % 24; t ঋণাত্মক হলেও (১৯৭০-এর আগের সময়) ফল 0–23-এর মধ্যে। বাজারঘরের উদাহরণে, সপ্তাহের দিন (day - 3) % 7 হিসাব করলে Python-এ কখনো ঋণাত্মক দিন আসে না, C-তে আসতে পারে।

C-র পক্ষে যুক্তি ঐতিহাসিক আর হার্ডওয়্যার-সংক্রান্ত। বেশিরভাগ CPU-র signed division instruction শূন্যের দিকে কাটে। C89 ঋণাত্মক operand-এ দিকটি implementation-এর ওপর ছেড়ে দিয়েছিল, যাতে প্রতিটি যন্ত্রে native instruction সরাসরি ব্যবহার করা যায়। কিন্তু এতে portable কোড লেখা কঠিন হয়, তাই C99 শূন্যের দিকে কাটা বাধ্যতামূলক করে; FORTRAN আগে থেকেই এভাবে করত বলে কোড স্থানান্তরও সহজ হয়। Java, C#, JavaScript-এর %, Rust আর Go-ও একই পথে।

Haat একটি compiler শেখানোর ভাষা, যা শেষে RISC-V আর WebAssembly-তে নামবে। RISC-V-র div/rem আর WebAssembly-র i64.div_s/i64.rem_s দুটিই শূন্যের দিকে কাটে। C-র নিয়ম নিলে Haat-এর / একটি instruction-এ নামে; Python-এর নিয়ম নিলে প্রতিটি ভাগের পরে চিহ্ন যাচাই করে সংশোধনের বাড়তি কোড লাগত। পর্ব ৭২ আর ৭৩-এ এটি সরাসরি দেখবেন।

মূল উপলব্ধি: Semantics-এর সিদ্ধান্ত প্রায়ই গাণিতিক সৌন্দর্য, ব্যবহারকারীর সুবিধা আর যন্ত্রে কতটা সস্তায় করা যায়, এই তিনের আপস। কোনো ভাষার নিয়ম মুখস্থ না করে কারণটি বুঝলে নতুন ভাষায় ভুল কম হয়।

প্র ০৪“ব্যবহারের আগে ঘোষণা” কি syntax না semantics? উত্তর কেন বই অনুযায়ী বদলায়?

প্রশ্নটি শুনতে সংজ্ঞার খুঁটিনাটি মনে হলেও এর পেছনে একটি গভীর সত্য আছে। নিয়মটি নিঃসন্দেহে program-এর রূপ সম্পর্কে: program না চালিয়ে শুধু লেখা দেখেই যাচাই করা যায়। সেই অর্থে এটি syntax. কিন্তু নিয়মটি context-free নয়, কারণ ঘোষণা আর ব্যবহার দুটি দূরের অংশ, আর তাদের নাম হুবহু মিলতে হয়; এটি {w c w} ধরনের কপি-গঠন, যা pumping lemma দিয়ে CFG-এর বাইরে প্রমাণ করা যায়।

যেহেতু প্রায় সব বাস্তব compiler syntax বলতে বোঝে “যা CFG দিয়ে parser যাচাই করে”, তাই CFG-এর বাইরের রূপ-নিয়মগুলো চলে যায় পরের ধাপে, semantic analysis-এ। অনেক পাঠ্যবই এগুলোকে তাই static semantics বলে। আবার কিছু বই এগুলোকে বলে “context-sensitive syntax”. দুটি নামই একই জিনিস বোঝায়; পার্থক্যটা শুধু সীমারেখা কোথায় টানা হলো।

ইতিহাসে দুই দিকেই চেষ্টা হয়েছে। ALGOL 68 van Wijngaarden-এর two-level grammar দিয়ে এসব শর্তও grammar-এ লিখেছিল। ক্ষমতা ছিল প্রচুর, কিন্তু grammar পড়ে বোঝা আর তা থেকে দক্ষ parser বানানো দুটিই কঠিন হয়ে গেল। Knuth-এর attribute grammar (১৯৬৮) মাঝামাঝি পথ নেয়: CFG থাকে, আর node-এ attribute হিসেবে symbol table-এর মতো তথ্য বয়ে নিয়ে শর্ত যাচাই হয়। আজকের compiler-গুলো মূলত এই চিন্তার একটি অনানুষ্ঠানিক রূপ ব্যবহার করে: parser AST বানায়, তারপর আলাদা একটি pass scope ধরে নাম খোঁজে।

Haat-এ নিয়মটির একটি ব্যতিক্রমও আছে: top-level function program-এর শুরু থেকেই দৃশ্যমান, যাতে দুটি function একে অপরকে ডাকতে পারে (mutual recursion). এ ধরনের ব্যতিক্রম grammar-এ লেখা আরও কঠিন, কিন্তু name resolution-এ দুই ধাপে (আগে সব top-level নাম সংগ্রহ, তারপর যাচাই) খুব সহজ। পর্ব ৫১-এ এটি বানাবেন।

মূল উপলব্ধি: Syntax আর semantics-এর সীমারেখা প্রকৃতির নিয়ম নয়, প্রকৌশলের সিদ্ধান্ত: যে নিয়ম সস্তায় parser-এ ধরা যায় সেটি grammar-এ, বাকিটা পরের pass-এ।

প্র ০৫Semantics এক হলে style আর idiom নিয়ে এত কথা কেন? Pragmatics কি শুধু রুচির প্রশ্ন?

Program একবার লেখা হয়, কিন্তু বহুবার পড়া হয়: বাগ খুঁজতে, নতুন বৈশিষ্ট্য যোগ করতে, অন্য কেউ দায়িত্ব নিলে। তাই কোড মানুষের কাছে কতটা স্পষ্ট, সেটি তার দীর্ঘমেয়াদি খরচ ঠিক করে। Python-এর “Zen of Python” (PEP 20, Tim Peters) বলে “There should be one-- and preferably only one --obvious way to do it”; উদ্দেশ্য হলো একই কাজ সবাই একইভাবে লিখলে পাঠককে প্রতিবার নতুন ভঙ্গি বুঝতে হয় না। Perl ভাষার বিখ্যাত নীতি ঠিক উল্টো: “There's more than one way to do it”. দুটিই সচেতন pragmatic সিদ্ধান্ত, আর দুটিরই নিজস্ব সমর্থক আছে।

Pragmatics শুধু রুচি নয়, কারণ এর অনেকটা বাগের সঙ্গে সরাসরি যুক্ত। C-তে if (x = 0) বৈধ, কিন্তু এর প্রায় প্রতিটি ব্যবহার আসলে ভুল; তাই compiler warning দেয় আর style guide নিষেধ করে। Go ভাষা অব্যবহৃত import আর অব্যবহৃত local variable-কে সরাসরি compile error বানিয়েছে: এটি ঐতিহ্যগতভাবে pragmatics-এর বিষয় (“পরিষ্কার কোড”), যা নকশাকারীরা semantics-এ তুলে এনেছেন। Go-র gofmt format নিয়ে তর্কই বন্ধ করে দিয়েছে। Rust আর Elm-এর মতো ভাষা error message-এর মানকে নকশার অগ্রাধিকার বলে প্রকাশ্যে ঘোষণা করেছে।

আরেকটি দিক হলো implementation-এর বাস্তবতা। CPython-এর recursion সীমা (ডিফল্ট 1000), JavaScript engine-এর আলাদা optimization, C compiler-এর UB-নির্ভর optimization: কোনোটি ভাষার মূল নিয়ম নয়, কিন্তু program কেমন চলবে তা ঠিক করে। ভালো প্রোগ্রামার তাই জানেন ভাষা কী বলে আর তাঁর ব্যবহৃত tool আসলে কী করে, দুটিই।

এই কোর্সে Haat-এর কয়েকটি নিয়ম সরাসরি pragmatics থেকে এসেছে: let আর var আলাদা, যাতে কোনটি বদলায় তা লেখাতেই বোঝা যায়; function-এর parameter type লেখা বাধ্যতামূলক, যাতে function-এর চুক্তি পড়েই বোঝা যায়; error message-এ সবসময় লাইন আর কলাম।

মূল উপলব্ধি: Pragmatics হলো ভাষার সেই অংশ যা মানুষকে কেন্দ্র করে। প্রায়ই আজকের pragmatics (ভালো অভ্যাস) আগামী দিনের ভাষায় semantics (নিয়ম) হয়ে যায়।

অনুশীলন

প্রথমে নিজে করুন, তারপর উত্তর মিলিয়ে নিন।

  1. Recognizer বাড়ান (implementation): অংশ ৩-এর haat_recognizer.py-তে আরও দুটি Haat statement যোগ করুন: var NAME = expr ; আর assignment NAME = expr ;. EBNF-এ নিয়ম দুটি লিখুন, তারপর কোডে কোন লাইন বদলাবেন বলুন। x = 3; আর x == 3; দুটিই যেন সঠিকভাবে চেনা হয়।

    EBNF: stmt = ( "let" | "var" ) NAME "=" expr ";" | NAME "=" expr ";" | "print" "(" expr ")" ";" | expr ";" ;

    কোডে try-এর ভেতরের kind লাইন আর let-এর লাইনটি বদলে এই চারটি লাইন বসান:

    kind = {"let": "variable declaration", "var": "variable declaration",
            "print": "print statement"}.get(toks[0][0], "expression")
    if kind == "expression" and NAME.fullmatch(toks[0][0]) and toks[1][0] == "=":
        kind = "assignment"
    if kind[0] == "v": k = 1; eat("NAME", f"expected variable name after '{toks[0][0]}'"); eat("=", f"expected '=' after variable name in '{toks[0][0]}'")
    if kind[0] == "a": k = 2

    পরের print/expr() লাইন আর ;-এর যাচাই আগের মতোই থাকে; বার্তা আপনাআপনি হবে expected ';' after assignment. এভাবে বদলানো কোড চালিয়ে দেখা হয়েছে: var = 3; দেয় 1:5: error: expected variable name after 'var', x = 3 দেয় 1:6: error: expected ';' after assignment, হুবহু রেফারেন্সের মতো। var যেহেতু NAME regex-এর keyword-তালিকায় আছে, var নিজে নাম হিসেবে গৃহীত হবে না, যা ঠিক। x = 3;-এ দ্বিতীয় token =, তাই assignment শাখা; x == 3;-এ দ্বিতীয় token == (lexer ==-কে একটি token হিসেবে আগে চেনে, কারণ regex-এ == একক =-এর আগে আছে), তাই এটি expression statement. খেয়াল করুন, assignment শুধু var-এ বৈধ, এই শর্ত recognizer যাচাই করবে না: সেটি static semantics, name resolution-এর কাজ।

  2. ভুল derivation খুঁজুন: Γ = qty : Int ধরে একজন লিখলেন: (১) Γ ⊢ qty : Int, (২) Γ ⊢ 2 : Int, (৩) T-Gt দিয়ে Γ ⊢ qty > 2 : Int, (৪) Γ ⊢ 1 : Int, (৫) T-Add দিয়ে Γ ⊢ (qty > 2) + 1 : Int. কোন ধাপ ভুল, আর সঠিক সিদ্ধান্ত কী?

    ধাপ (৩) ভুল। T-Gt-এর নিচের সারি বলে Γ ⊢ e1 > e2 : Bool, Int নয়। সঠিক ধাপ: Γ ⊢ qty > 2 : Bool. তখন ধাপ (৫)-এ T-Add-এর premise Γ ⊢ e1 : Int খাটে না (e1-এর type Bool), আর T-Concat-ও খাটে না (চায় দুটিই Str). +-এর অন্য কোনো নিয়ম নেই, তাই (qty > 2) + 1-এর কোনো type derive করা যায় না: Haat-এ এটি type error. ভুল derivation-টি আসলে C-র semantics লিখে ফেলেছে, যেখানে তুলনার ফল int.

  3. আউটপুট অনুমান করুন: Haat program print(-7 / 2); print(-7 % 2); print(7 % -2); print(-7 / -2); কী ছাপবে? আর Python 3-এ print(-7 // 2, -7 % 2, 7 % -2, -7 // -2)?

    Haat (C-র নিয়ম: শূন্যের দিকে কাটা, ভাগশেষ ভাজ্যের চিহ্ন): -3, -1, 1, 3, প্রতিটি আলাদা লাইনে। Python 3: -4 1 -1 3. শেষেরটি দুটিতেই 3, কারণ −7/−2 = 3.5 ধনাত্মক, আর ধনাত্মক সংখ্যায় কাটা আর নিচের দিকে গোল করা একই। C-র সত্যিকারের run (অংশ ৬) দেখিয়েছে 7 % -2 = 1, আর ব্রাউজারের Python দেখিয়েছে 7 % -2 = -1. যাচাই: Haat-এ 7 = (−2)(−3) + 1, Python-এ 7 = (−2)(−4) + (−1).

  4. স্তর চিনুন: নিচের প্রতিটি Haat সমস্যা কোন স্তরের (lexical, context-free syntax, static semantics, dynamic semantics, pragmatics)? (ক) let x = 5 # 2; (খ) print(1 < 2 < 3); (গ) print(totl); যেখানে নাম total (ঘ) let r = 10 / (5 - 5); (ঙ) let s = "Dhaka" + 1; (চ) একটি var যা কখনো বদলায় না।

    (ক) Lexical: # Haat-এর কোনো token নয় (comment //)। (খ) Context-free syntax: comparison non-associative, grammar-ই একাধিক তুলনা দেয় না। (গ) Static semantics (name resolution): বার্তা হবে undefined variable 'totl'. (ঘ) Dynamic semantics: syntax আর type ঠিক, কিন্তু চলার সময় runtime error: division by zero. (একটি চালাক optimizer চালানোর আগেই এটি ধরতে পারে, কিন্তু ভাষার নিয়মে এটি runtime error.) (ঙ) Static semantics (type): Str + Int-এর কোনো typing rule নেই; রেফারেন্স implementation বলে 1:19: error: type mismatch: expected Str, found Int (বাঁয়ের Str ঠিক করে দেয় ডানে কী চাই)। (চ) Pragmatics: program বৈধ ও সঠিক, কিন্তু let উদ্দেশ্য বেশি পরিষ্কার বলে।

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

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

ক্রমএকটি Haat program-এর যাত্রার ধাপগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. অক্ষর থেকে token (lexical)
  2. Token থেকে parse করে AST (context-free syntax)
  3. নাম ঘোষিত কি না যাচাই (name resolution)
  4. Type যাচাই (static semantics)
  5. চালানো আর আউটপুট (dynamic semantics)

C99 বা তার পরের C standard মেনে চলা compiler-এ -7 / 2 আর -7 % 2-এর মান কী?

  • -4 আর 1
  • -3 আর -1
  • -3.5 আর -1
  • -3 আর 1

“Colorless green ideas sleep furiously” বাক্যটি প্রোগ্রামিং ভাষার কোন ধরনের program-এর সঙ্গে সবচেয়ে বেশি মেলে?

  • যে program-এ syntax error আছে
  • যে program সঠিক, কিন্তু style খারাপ
  • যে program syntax-এ বৈধ, কিন্তু semantics-এ অর্থহীন
  • যে program-এ lexical error আছে

নিচের কোন নিয়মটি একটি context-free grammar দিয়ে প্রকাশ করা যায় না, তাই compiler সাধারণত parser-এর পরের ধাপে যাচাই করে?

  • প্রতিটি খোলা বন্ধনীর একটি বন্ধ বন্ধনী থাকবে
  • * আর / আগে, + আর - পরে হিসাব হবে
  • প্রতিটি statement শেষ হবে ; দিয়ে
  • প্রতিটি variable ব্যবহারের আগে ঘোষিত হবে

E → E + T ∣ T, T → T ∗ F ∣ F, F → ( E ) ∣ num grammar-এ (2 + 3) * 4-এর parse tree আর AST-এর তুলনায় কোনটি সত্য?

  • Parse tree-তে ১৮টি node, AST-এ ৫টি; AST-এ বন্ধনী নেই
  • দুটিতেই বন্ধনী থাকে, শুধু AST-এ variable নেই
  • AST-এ গুণ আগে হিসাব হয়, তাই মান 14
  • AST-এ বেশি node থাকে, কারণ এতে type-এর তথ্যও থাকে

Haat-এ let ok = 5 > 3; print(ok + 1); program-টির কী হবে? (Haat-এ Int, Bool আলাদা type, implicit conversion নেই।)

  • Parser syntax error দেবে
  • চালানোর আগেই type checker error দেবে
  • 2 ছাপবে
  • চলার সময় runtime error দেবে

C-তে int stock = 5; if (stock = 0) { … } লিখলে compile (warning চালু রেখে) আর চালানোর পরে কী হয়?

  • Compile error: শর্তে = নিষেধ
  • শর্ত সত্য হয় কারণ stock আগে 5 ছিল
  • একটি warning আসে; stock 0 হয়ে যায় আর শর্ত মিথ্যা হয়
  • Undefined behavior, ফল অনিশ্চিত

শব্দকোষ

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

মনে রাখুন

  1. Syntax রূপ, semantics অর্থ, pragmatics ব্যবহার; ভাষার সংজ্ঞা প্রথম দুটি।
  2. Syntax-এর তিন স্তর: lexical (regular), context-free (grammar, parser), আর context-sensitive শর্ত, যা compiler semantic analysis-এ যাচাই করে।
  3. Parse tree সব নিয়ম আর token রাখে; AST শুধু অর্থ: (2 + 3) * 4-এ ১৮ বনাম ৫টি node.
  4. Static semantics চালানোর আগে (type, ঘোষণা), dynamic semantics চলার সময় (মান, runtime error); নিয়মগুলো inference rule-এ লেখা যায়।
  5. একই লেখা ভাষাভেদে ভিন্ন অর্থ বহন করে: -7 / 2, -7 % 2, +, =; সবসময় ভাষা আর version ধরে চালিয়ে যাচাই করুন।

পরের পর্বে: ভাষার অর্থ জানা হলো; এবার সেই অর্থ যন্ত্রে পৌঁছায় কীভাবে। পর্ব ০৪ “অনুবাদক — compiler, interpreter, transpiler আর JIT”-এ দেখবেন একই program কীভাবে অনুবাদ করে বা সরাসরি চালিয়ে ফল পাওয়া যায়, আর CPython, JVM ও JavaScript engine আসলে কোন পথে চলে।

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

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