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

Expression আর evaluation order — precedence, side effect আর short-circuit

Expressions and Evaluation Order — Precedence, Side Effects and Short-Circuit

Taught in Bangla, this lesson separates three questions about an expression: tree shape, evaluation order and side effects. It builds a Pratt parser in Python with Haat's binding powers and steps through 2 + 3 * 4 - 1. JavaScript and Python probes show operand order across languages, with C's unspecified order and the undefined i++ + i++ flagged by Clang's -Wunsequenced. It shows short-circuit as JUMP_IF_FALSE in Haat bytecode, desugars compound assignment and tests constant folding in Python.

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

  • Precedence, associativity আর non-associative operator দিয়ে একটি expression-এর গাছ নিজে আঁকা, আর C, Python, JavaScript ও Haat-এর পার্থক্য চেনা
  • Binding power দিয়ে একটি ছোট Pratt parser লেখা আর তার প্রতিটি সিদ্ধান্ত ধাপে ধাপে ব্যাখ্যা করা
  • Evaluation order-এর নিয়ম ভাষা আর version ধরে বলা, আর C-র unspecified, undefined ও sequenced-before-এর পার্থক্য বোঝা
  • Short-circuit আর conditional expression-এর formal নিয়ম লেখা, আর bytecode-এ তার jump চেনা
  • Assignment, compound assignment, operator overloading আর constant folding-এর পেছনের desugaring ও নিরাপত্তার শর্ত বোঝা

১ · একটি expression, তিনটি প্রশ্ন — গঠন, ক্রম আর প্রভাব

মডিউল ৫ শুরু হলো program-এর সবচেয়ে ছোট “কাজের একক” দিয়ে: expression. price(2, 520) + delivery(936) লিখলে একটি মান পাওয়া যায়; এই মান পাওয়ার পথটি সরল মনে হলেও ভেতরে তিনটি আলাদা সিদ্ধান্ত লুকিয়ে আছে। পর্ব ০১-এ (কোর্সের মানচিত্র) আর পর্ব ০৩-এ (Syntax, semantics আর pragmatics) precedence-এর একটি ঝলক দেখেছেন, আর পর্ব ১৯-এ (Evaluation strategy) দেখেছেন argument আদৌ কখন হিসাব হয়। এই পর্বে তিনটি সিদ্ধান্তকেই পুরো খুলে দেখব।

বাজারঘরের হিসাবরক্ষক একটি অর্ডার স্লিপ পেলেন: “২ কেজি চাল × ৫২০ + ডেলিভারি ৬০”। প্রথম প্রশ্ন, গঠন: গুণ আগে, না যোগ আগে? সবাই জানেন গুণ আগে; এটি precedence. দ্বিতীয় প্রশ্ন, ক্রম: তিনি কোন খাতা আগে খুলবেন, চালের দামের খাতা না ডেলিভারির খাতা? ফল একই আসে, তাই সাধারণত কেউ মাথা ঘামায় না। তৃতীয় প্রশ্ন, প্রভাব: কিন্তু ধরুন চালের খাতা খোলার সময় তিনি স্টক থেকে ২ কেজি কেটে দেন, আর ডেলিভারির খাতা স্টক দেখে চার্জ ঠিক করে। তখন কোন খাতা আগে খোলা হলো, তার ওপর বিলের অঙ্কই বদলে যায়। প্রোগ্রামিং ভাষাকে এই তিনটি প্রশ্নের উত্তর আলাদা আলাদা নিয়মে দিতে হয়।

প্রথমে কয়েকটি শব্দ। একটি operator যে মানগুলোর ওপর কাজ করে, তাদের বলে operand. Operand কয়টি, সেটি operator-এর arity: Haat-এর -x আর !b unary (একটি operand), a * b binary (দুটি), আর C-র c ? a : b ternary (তিনটি)। Operator কোথায় বসে, সেটি তার fixity: prefix (-x), infix (a + b), postfix (C-র i++, বা Haat-এর call f(a, b), যা callee-র পরে বসে)। আর expression-এর বিপরীতে statement কোনো মান দেয় না, শুধু কিছু করে: Haat-এ print(e);, x = e; আর while statement.

সংজ্ঞা ২৬.১ — একটি expression-এর তিন স্তর

(ক) গঠন: লেখা থেকে কোন abstract syntax tree (AST) হবে। এটি ঠিক করে precedence (কোন operator বেশি জোরে বাঁধে) আর associativity (একই স্তরের operator পাশাপাশি থাকলে বাঁ থেকে না ডান থেকে জোড়া)। এটি পুরোপুরি syntax-এর বিষয়, parser-এর সিদ্ধান্ত। (খ) ক্রম: গাছের যে node-গুলোর মধ্যে কোনো নির্ভরতা নেই, যেমন একটি যোগের দুই operand, তাদের কোনটি আগে হিসাব হবে। এটি dynamic semantics-এর বিষয়। (গ) প্রভাব: হিসাবের সময় মান ফেরত দেওয়ার বাইরে কী ঘটে: variable বদলানো, ছাপা, error. Side effect না থাকলে ক্রম বাইরে থেকে দেখাই যায় না; side effect থাকলেই ক্রম program-এর অর্থের অংশ হয়ে যায়।

Haat-এ তিনটি স্তরের উত্তরই নির্দিষ্ট। Reference বাস্তবায়নের নকশা-সিদ্ধান্ত ১২ বলে: বাঁ operand ডানের আগে, callee argument-এর আগে, argument বাঁ থেকে ডানে। পর্ব ১৯-এর tag program দেখিয়েছিল argument-এর ক্রম। এবার আরও দুটি জিনিস দেখি: একই function দুবার ডাকলে side effect-এর ক্রম, আর callee নিজেই যখন একটি call (পর্ব ১৭-এর closure দিয়ে বানানো counter):

// বাজারঘর: কোন অংশ আগে হিসাব হয়
fn counter() -> () -> Int {
    var n = 0;
    fn step() -> Int {
        n = n + 1;
        return n;
    }
    return step;
}
let next = counter();
print(next() * 10 + next());
fn tag(s: Str, v: Int) -> Int {
    print(s);
    return v;
}
fn pick() -> (Int, Int) -> Int {
    print("callee");
    return fn(a: Int, b: Int) -> Int { return a - b; };
}
print(pick()(tag("arg1", 9), tag("arg2", 4)));
~/haat $ python haat.py run order.haat
12
callee
arg1
arg2
5

সত্যিকারের run (Haat reference, CPython 3.14.4; vm-এও হুবহু এক)। next() * 10 + next()-এ দুই next() একই function, কিন্তু প্রতিটি ডাক counter বাড়ায়। বাঁ পাশ আগে চলে বলে বাঁয়ের ডাক পায় 1, ডানের ডাক 2: 1 × 10 + 2 = 12. ক্রম উল্টো হলে ফল হতো 2 × 10 + 1 = 21. একই লেখা, দুটি সম্ভাব্য অর্থ; ভাষার নিয়মই ঠিক করে কোনটি। দ্বিতীয় লাইনে callee নিজেই একটি call, pick(). ছাপার ক্রম callee, arg1, arg2: আগে callee হিসাব হয়ে একটি function-মান দেয়, তারপর argument দুটি বাঁ থেকে ডানে, তারপর আসল call, 9 − 4 = 5.

২ · Precedence আর associativity — গাছের আকার কে ঠিক করে

লেখা একটি সরলরেখা, কিন্তু অর্থ একটি গাছ। 2 + 3 * 4 - 1 লেখায় কোনো বন্ধনী নেই, তবু আমরা জানি এর অর্থ (2 + (3 * 4)) - 1. এই জ্ঞানের দুটি অংশ। Precedence: * +-এর চেয়ে বেশি জোরে বাঁধে, তাই 3 আর 4 আগে জোড়া লাগে। Associativity: + আর - একই স্তরের, পাশাপাশি থাকলে বাঁ দিক থেকে জোড়া লাগে, তাই 10 - 4 - 3 মানে (10 - 4) - 3 = 3, 10 - (4 - 3) = 9 নয়। Haat-এর পুরো নিয়ম reference-এর parser.py থেকে:

স্তর (নিচু → উঁচু)OperatorlbprbpAssociativity
১||1011বাঁ
২&&2021বাঁ
৩== !=3031non-associative
৪< <= > >=4041non-associative
৫+ -5051বাঁ
৬* / %6061বাঁ
৭prefix - !—70(prefix)
৮call f(a, b)80—বাঁ: f(1)(2)

“lbp” আর “rbp” মানে left আর right binding power; পরের অংশে এদের কাজ দেখবেন। এখানে একটি নতুন ধারণা আছে: non-associative. Haat-এ a < b < c বাঁ-থেকেও নয়, ডান-থেকেও নয়, সরাসরি syntax error (নকশা-সিদ্ধান্ত ১০)। কেন? গণিতে “a < b < c” মানে “a < b এবং b < c”, কিন্তু বাঁ-সংযোগে পড়লে অর্থ হতো (a < b) < c, অর্থাৎ একটি Bool-কে Int-এর সঙ্গে তুলনা। ভুল অর্থ দেওয়ার চেয়ে নিষেধ করা ভালো। ভিন্ন স্তর মেশানো যায়: a < b == c < d মানে (a < b) == (c < d). সত্যিকারের run:

var stock = 5;
print(1 < 2 < 3);
print(stock = 4);
let ok = stock == 5 != true;
~/haat $ python haat.py run bad.haat
2:13: error: comparison operators cannot be chained
3:13: error: expected ')' after print argument
4:21: error: comparison operators cannot be chained

তিনটি error একবারেই এসেছে, কারণ parser একটি ভুলের পরে নিজেকে সামলে নিয়ে বাকিটা পড়ে (নকশা-সিদ্ধান্ত ২৫; বিস্তারিত পর্ব ৫০-এ)। প্রথম আর শেষ error দেখায় দুই তুলনা-স্তরই non-associative, আর error-টি দ্বিতীয় operator-এর জায়গায় (কলাম ১৩ আর ২১)। মাঝেরটি অংশ ৭-এর বিষয়: Haat-এ assignment একটি statement, তাই print-এর ভেতরে stock = 4 বসে না।

অন্য ভাষার টেবিল: একই প্রশ্ন, ভিন্ন উত্তর

C-র standard আসলে কোনো precedence টেবিল দেয় না; precedence লুকিয়ে আছে grammar-এর স্তরে (multiplicative-expression, additive-expression, …)। টেবিলটি সেই grammar থেকে বানানো, আর তাতে প্রায় ১৫টি স্তর (গণনার ধরনভেদে ১৫ বা ১৬)। কয়েকটি স্তর বিখ্যাতভাবে অদ্ভুত: bitwise &, ^, | তুলনার ==-এর নিচে। ফলে qty & 1 == 0 মানে qty & (1 == 0). আর C-তে 3 > 2 > 1 বৈধ, অর্থ (3 > 2) > 1, অর্থাৎ 1 > 1, মানে 0. সত্যিকারের run, PyPI-র ziglang package-এর Zig 0.17.1-এর সঙ্গে আসা Clang 22.1.8 দিয়ে (এই পর্বে zig cc মানে python -m ziglang cc; zig-এর নিজের একটি অপ্রাসঙ্গিক লাইন আর Clang-এর “note” লাইন বাদ):

#include <stdio.h>
int main(void) {
    int qty = 4;
    int even = qty & 1 == 0;      /* means qty & (1 == 0) */
    int ok = 3 > 2 > 1;           /* means (3 > 2) > 1 */
    printf("%d %d\n", even, ok);
    return 0;
}
~/haat $ zig cc -std=c17 -Wall -O0 -fno-sanitize=undefined prec.c -o prec.exe
prec.c:4:20: warning: & has lower precedence than ==; == will be evaluated first [-Wparentheses]
prec.c:5:20: error: chained comparison 'X > Y > Z' does not behave the same as a mathematical expression [-Wparentheses]
1 warning and 1 error generated.
~/haat $ zig cc -std=c17 -O0 -fno-sanitize=undefined -Wno-parentheses prec.c -o prec.exe
~/haat $ ./prec.exe
0 0

দুটি শিক্ষা। প্রথমত, qty = 4 জোড় সংখ্যা, তবু even 0: প্রোগ্রামার যা ভেবেছিলেন, C তা পড়েনি। দ্বিতীয়ত, এই Clang version শৃঙ্খলিত তুলনাকে ডিফল্টে error বানিয়েছে, যদিও C17-এর চোখে program বৈধ; সতর্কবার্তা বন্ধ করলে program চলে আর 0 0 ছাপে। অর্থাৎ ভাষার নিয়ম আর compiler-এর ভদ্রতা আলাদা জিনিস: ভাষা যা অনুমতি দেয়, ভালো compiler তার বিপজ্জনক অংশে বাধা দিতে পারে। Haat এই পথটিই grammar-এ বেঁধে দিয়েছে। C-র পুরো operator টেবিল আর অভ্যাস দেখুন C কোর্সের পর্ব ০৭-এ।

আরও কয়েকটি ভাষার বৈশিষ্ট্য, প্রতিটি সত্যিকারের run-এ যাচাই করা (Python 3.14.4, Node 24):

  • Python: a < b < c বৈধ আর গাণিতিক অর্থেই: a < b and b < c, শুধু b একবার হিসাব হয় (অংশ ৪-এর run দেখুন)। আর -2 ** 2-এর মান −4, কারণ ** তার বাঁয়ের unary minus-এর চেয়ে বেশি জোরে বাঁধে; ** ডান-সংযোগী, তাই 2 ** 3 ** 2 = 29 = 512.
  • JavaScript: -2 ** 2 লেখাই SyntaxError (“Unary operator used immediately before exponentiation expression…”); ভাষাটি ES2016-এ ** আনার সময় অস্পষ্টতা থেকে বাঁচতে বন্ধনী বাধ্যতামূলক করেছে: (-2) ** 2 = 4, -(2 ** 2) = −4.
  • Java: C-র মতো টেবিল, কিন্তু 3 > 2 > 1 type error, কারণ boolean-কে int-এর সঙ্গে তুলনা করা যায় না। একই grammar, কঠোর type system ভুলটি ধরে। পুরো টেবিল Java কোর্সের পর্ব ০৭-এ, Python কোর্সের পর্ব ০৮-এ আর JavaScript কোর্সের পর্ব ০৮-এ।

Precedence দুইভাবে প্রকাশ করা যায়। একটি হলো grammar-কে স্তরে ভাগ করা: expr → expr + term | term, term → term * factor | factor. বাঁ-recursive নিয়ম বাঁ-সংযোগ দেয়, আর নিচের স্তর বেশি জোরে বাঁধে। এর তত্ত্ব, আর একটি অস্পষ্ট grammar কীভাবে একই লেখার দুটি গাছ দেয়, তা আছে গণনার তত্ত্বের পর্ব ২৭-এ আর পর্ব ৪২-এ। অন্যটি হলো একটি সংখ্যার টেবিল আর একটি ছোট loop: Pratt parsing. Haat দ্বিতীয় পথে চলে। পুরো গাছটি আর তার হিসাবের ক্রম এক ছবিতে:

ছবি ২৬.১ — 2 + 3 * 4 - 1: গাছের আকার আর হিসাবের ক্রম

গাছের আকার ঠিক করে precedence আর associativity; লাল বৃত্তের সংখ্যা দেখায় Haat-এর বাঁ-থেকে-ডান নিয়মে কোন node কখন হিসাব শেষ করে।

AST of 2 + 3 * 4 - 1 with binding powers and left-to-right evaluation order − + * 1 2 3 4 lbp 50 মান 13 lbp 50 মান 14 lbp 60 মান 12 1 2 3 4 5 6 7 আকার = precedence + associativity লাল সংখ্যা = হিসাবের ক্রম
ছবি ২৬.১ — একই গাছ, দুটি আলাদা নিয়ম। Parser গাছের আকার ঠিক করে দিয়ে সরে যায়; এরপর evaluator গাছটি post-order-এ হাঁটে: আগে বাঁ সন্তান, তারপর ডান, তারপর node নিজে। তাই 3 আর 4-এর গুণ (৪ নম্বর) 2-এর পরে হয়, যদিও গুণের precedence বেশি। Precedence বলে কে কার সঙ্গে জোড়া, কে আগে চলবে তা বলে না।

৩ · Pratt parser হাতে — binding power দিয়ে গাছ বানানো

Pratt parsing (Vaughan Pratt, ১৯৭৩, “Top Down Operator Precedence”) পুরো precedence টেবিলকে একটি ছোট loop-এ নামিয়ে আনে। প্রতিটি infix operator-এর একটি left binding power (lbp): সে তার বাঁয়ের operand-কে কত জোরে টানে। আর parser-এর প্রতিটি ডাকের একটি সীমা, min_bp: এই ডাক কেবল সেই operator-গুলো বাঁধবে, যাদের lbp এই সীমার সমান বা বেশি। একটি operator বাঁধার পরে তার ডান operand পড়া হয় নতুন সীমা rbp দিয়ে। Haat-এ rbp = lbp + 1. Reference-এর parser.py-র expression() এরই একটি পূর্ণ রূপ; নিচে তার সার:

1def expr(min_bp):2    left = atom()3    while lbp(peek()) >= min_bp:4        op = advance()5        right = expr(lbp(op) + 1)6        left = (op, left, right)7    return left
এই ধাপে
চলমান ডাক
পরের token
সিদ্ধান্ত
left
  1. শুরু, সীমা 0. expr(0) প্রথম atom পড়ে: left = 2. পরের token +, lbp 50 ≥ 0, তাই loop ঢোকে। সীমা 0 মানে “যেকোনো operator চলবে”।
  2. ডান পাশ, সীমা 51. + খাওয়া হলো, ডান operand-এর জন্য expr(51). এটি পড়ে 3; পরের *-এর lbp 60 ≥ 51, তাই * এই ভেতরের ডাকেই বাঁধা পড়ে। এটাই precedence: বেশি শক্তির operator ভেতরের ডাকে ধরা পড়ে, তাই গাছের নিচে বসে।
  3. আরও ভেতরে, সীমা 61. *-এর ডান পাশের জন্য expr(61) পড়ে 4. পরের --এর lbp 50, যা 61-এর কম, তাই এই ডাক কিছু না বেঁধে 4 ফেরত দেয়।
  4. এক ধাপ ফেরা। expr(51)-এ এখন left = (* 3 4). আবার - দেখে: 50 ≥ 51? না। এখানেই associativity: +-এর ডান পাশ পড়ার সীমা 51 ছিল বলে সমান-শক্তির - ভেতরে ঢুকতে পারল না।
  5. বাইরের loop. expr(0)-এ left = (+ 2 (* 3 4)). এবার 50 ≥ 0, তাই - এখানে বাঁধা হয়, বাইরের স্তরে; তার ডান পাশ expr(51) পড়ে 1, আর শেষ চিহ্ন $-এ থামে।
  6. শেষ। left = (- (+ 2 (* 3 4)) 1), আর $ কোনো operator নয়, loop শেষ। মোট তিনবার “বাঁধা”, ঠিক তিনটি binary operator-এর জন্য; মান 2 + 12 − 1 = 13.

এবার একই loop চালিয়ে দেখুন। নিচের কোড Haat-এর binding power নিয়ে একটি ছোট Pratt parser, যা প্রতিটি “বাঁধা”-র সিদ্ধান্ত ছাপে, গাছটি S-expression আকারে দেখায় আর মান হিসাব করে। Haat-এর মতোই একই তুলনা-স্তর পরপর দুবার এলে error দেয়।

import re
LBP = {"||": 10, "&&": 20, "==": 30, "!=": 30, "<": 40, "<=": 40,
       ">": 40, ">=": 40, "+": 50, "-": 50, "*": 60, "/": 60, "%": 60}
def parse(src):
    toks = re.findall(r"\d+|&&|\|\||[=!<>]=|[-+*/%<>()!]", src) + ["$"]
    pos = 0
    def expr(min_bp):                            # Pratt loop
        nonlocal pos
        t = toks[pos]; pos += 1
        if t == "(":    left = expr(0); pos += 1  # skip ")"
        elif t in "-!": left = (t, expr(70))      # prefix, rbp 70
        else:           left = int(t)
        last = None
        while toks[pos] in LBP and LBP[toks[pos]] >= min_bp:
            op = toks[pos]; lbp = LBP[op]; pos += 1
            if lbp in (30, 40) and lbp == last:
                raise SyntaxError("comparison operators cannot be chained")
            print(f"  bind {op:2} lbp={lbp}, right side min_bp={lbp + 1}")
            left = (op, left, expr(lbp + 1)); last = lbp
        return left
    return expr(0)
def show(t):
    return "(" + " ".join(map(show, t)) + ")" if type(t) is tuple else str(t)
def ev(t):                                # evaluate; / truncates as in C
    if type(t) is int: return t
    if len(t) == 2: return -ev(t[1]) if t[0] == "-" else not ev(t[1])
    a, b = ev(t[1]), ev(t[2])
    return {"+": a + b, "-": a - b, "*": a * b, "<": a < b, "==": a == b,
            "/": int(a / b) if b else "error"}.get(t[0], "?")
for src in ["2 + 3 * 4 - 1", "10 - 4 - 3", "-2 * 3 < 1 == 1 < 2", "1 < 2 < 3"]:
    try:
        print(src); tree = parse(src)
        print("  tree:", show(tree), " value:", str(ev(tree)).lower())
    except SyntaxError as e:
        print("  error:", e)

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

2 + 3 * 4 - 1
  bind +  lbp=50, right side min_bp=51
  bind *  lbp=60, right side min_bp=61
  bind -  lbp=50, right side min_bp=51
  tree: (- (+ 2 (* 3 4)) 1)  value: 13
10 - 4 - 3
  bind -  lbp=50, right side min_bp=51
  bind -  lbp=50, right side min_bp=51
  tree: (- (- 10 4) 3)  value: 3
-2 * 3 < 1 == 1 < 2
  bind *  lbp=60, right side min_bp=61
  bind <  lbp=40, right side min_bp=41
  bind == lbp=30, right side min_bp=31
  bind <  lbp=40, right side min_bp=41
  tree: (== (< (* (- 2) 3) 1) (< 1 2))  value: true
1 < 2 < 3
  bind <  lbp=40, right side min_bp=41
  error: comparison operators cannot be chained

প্রথম তিন “bind” লাইন stepper-এর ধাপগুলোর সঙ্গে হুবহু মেলে, আর গাছ (- (+ 2 (* 3 4)) 1) ঠিক Haat reference-এর python haat.py ast-এর গাছ। 10 - 4 - 3-এ দ্বিতীয় - বাইরের loop-এ বাঁধা পড়েছে, তাই (- (- 10 4) 3) = 3: বাঁ-সংযোগ। তৃতীয় উদাহরণে চার স্তর মিশেছে, আর prefix - rbp 70 নিয়ে পড়ে বলে -2 * 3 হয়েছে (* (- 2) 3). শেষ উদাহরণে দ্বিতীয় < দেখে parser থেমেছে। একটি জিনিস খেয়াল করুন: পুরো precedence টেবিলটি কোডে শুধু একটি dictionary, LBP. নতুন operator যোগ করতে grammar নতুন করে লিখতে হয় না, একটি লাইন যোগ করলেই হয়।

নিয়ম ২৬.২ — binding power থেকে associativity

Loop-এর শর্ত lbp(peek()) >= min_bp হলে: একটি operator op-এর ডান operand যদি rbp = lbp(op) + 1 সীমায় পড়া হয়, তাহলে সমান lbp-র পরের operator ডান পাশে ঢুকতে পারে না, তাই op বাঁ-সংযোগী। আর rbp = lbp(op) হলে পরের সমান operator ডান পাশে ঢুকে যায়, তাই op ডান-সংযোগী: Python-এর ** বা C-র =-এর জন্য এটিই দরকার। Non-associative স্তরের জন্য বাঁ-সংযোগের নিয়ম রেখে আলাদা একটি পরীক্ষা যোগ হয়: একই loop-এ সেই স্তরের দ্বিতীয় operator এলে error. Prefix operator-এর শুধু rbp থাকে (Haat-এ 70), আর call-এর মতো postfix operator-এর শুধু lbp, Haat-এ 80.

এই নিয়মের একটি ছোট প্রমাণ অনুশীলন ২-এ করবেন। পূর্ণ Haat parser, prefix অংশ, call আর error recovery-সহ, নিজের হাতে লিখবেন পর্ব ৪৮-এ (Pratt parsing). ঐতিহাসিকভাবে Pratt একা নন: Edsger Dijkstra-র shunting-yard algorithm (১৯৬১ সালের দিকে, ALGOL 60 compiler-এর কাজে) একটি stack দিয়ে একই কাজ করে, আর “precedence climbing” নামের পদ্ধতিটি Pratt loop-এরই একটি রূপ।

৪ · Operand-এর evaluation order — ভাষাভেদে আলাদা চুক্তি

ছবি ২৬.১-এর লাল সংখ্যাগুলো একটি সিদ্ধান্ত: যোগের দুই operand-এর মধ্যে বাঁটি আগে। গাছ নিজে এটি বলে না; গাছ শুধু বলে যোগের আগে দুই operand-এর মান লাগবে। এই ফাঁকা জায়গাটি প্রতিটি ভাষা নিজের মতো ভরেছে:

ভাষা (version)Binary operandFunction argumentAssignment a[i] = v
Haat (নকশা-সিদ্ধান্ত ১২)বাঁ থেকে ডানেcallee, তারপর বাঁ থেকে ডানে(Haat-এ শুধু x = e;)
Java 21 (JLS §15.7)বাঁ থেকে ডানেবাঁ থেকে ডানেবাঁ পাশ (array, index), তারপর v
JavaScript (ECMAScript)বাঁ থেকে ডানেবাঁ থেকে ডানেবাঁ পাশ, তারপর v
Python 3.14 (Reference §6.16)বাঁ থেকে ডানেবাঁ থেকে ডানেআগে v, তারপর a, তারপর i
C17unspecifiedunspecifiedunsequenced; একই object ছুঁলে UB
C++17 ও পরেসাধারণত unspecified (<<, >> বাঁ থেকে ডানে)যেকোনো ক্রমে, তবে একটির পর একটিআগে v, তারপর বাঁ পাশ

Formal semantics-এ বাঁ-থেকে-ডান নিয়মটি খুব পরিষ্কারভাবে লেখা যায়, যদি হিসাবের সঙ্গে memory-র অবস্থাও লিখি। ⟨e, σ⟩ ⇓ ⟨v, σ′⟩ মানে: memory-র অবস্থা σ থেকে e হিসাব করলে মান v আসে আর memory হয়ে যায় σ′ (big-step নিয়ম; পুরো পদ্ধতি পর্ব ৪০-এ)। দাগের ওপরের শর্ত সত্য হলে নিচের সিদ্ধান্ত সত্য:

⟨e1, σ⟩ ⇓ ⟨n1, σ1⟩    ⟨e2, σ1⟩ ⇓ ⟨n2, σ2⟩
⟨e1 + e2, σ⟩ ⇓ ⟨wrap(n1 + n2), σ2⟩
(Add)

ক্রমটি লুকিয়ে আছে σ-এর পথে: e1 শুরু হয় σ থেকে, আর e2 শুরু হয় σ1 থেকে, অর্থাৎ e1-এর সব side effect শেষ হওয়ার পরের memory থেকে। σ1 আর σ অদলবদল করলেই নিয়মটি ডান-থেকে-বাঁ হয়ে যেত। C-র মতো unspecified ক্রম লিখতে হলে দুটি নিয়ম লাগে, আর যেকোনোটি প্রয়োগের অনুমতি; ফলে একই program-এর একাধিক বৈধ ফল থাকে। wrap হলো ৬৪-বিটে মোড়ানো (নকশা-সিদ্ধান্ত ১৩; wrapping arithmetic নিয়ে পর্ব ২০-এ, Primitive type).

Haat-এর VM এই নিয়ম কীভাবে মানে? অংশ ১-এর print(next() * 10 + next());-এর সত্যিকারের dis (নির্দেশ ৯ থেকে ১৬) ধরে operand stack-কে ধাপে ধাপে দেখুন:

9LOAD_GLOBAL    3   ; next10CALL           011CONST          3   ; 1012MUL13LOAD_GLOBAL    3   ; next14CALL           015ADD16PRINT
নির্দেশের পরে
operand stack
cell n
কী ঘটল
  1. Callee. LOAD_GLOBAL 3 global next-এর মান তোলে: counter-এর ফেরত দেওয়া closure step, যার ভেতরের n একটি cell-এ, এখনো 0.
  2. প্রথম ডাক। CALL 0 closure-টি ডাকে; step-এর STORE_FREE cell-কে 1 বানায়, আর ফেরত মান 1 stack-এ আসে। এটি এই expression-এর প্রথম side effect.
  3. Constant. CONST 3 constant টেবিলের ৩ নম্বর ঘর, 10, তোলে।
  4. গুণ। MUL ওপরের দুটি নামিয়ে 1 × 10 = 10 তোলে। বাঁ operand-এর পুরো হিসাব শেষ, ডানের কিছুই এখনো শুরু হয়নি: নিয়ম (Add)-এর σ1.
  5. আবার callee. ডান operand শুরু: একই next আবার তোলা হয়।
  6. দ্বিতীয় ডাক। Cell এবার 2 হয়, ফেরত 2. বাঁ পাশ আগে চলেছিল বলেই এটি 2, 1 নয়।
  7. যোগ। ADD: 10 + 2 = 12. Bytecode-এর সরলরেখাই ক্রমের প্রমাণ: compiler গাছটি post-order-এ হেঁটে নির্দেশ লিখেছে, VM সেগুলো ওপর থেকে নিচে চালায়।
  8. ছাপা। PRINT 12 নামিয়ে ছাপে, stack খালি। Reference-এর দুই back end-এর আউটপুট এক, কারণ tree-walking interpreter-ও বাঁ সন্তান আগে হিসাব করে।

এবার অন্য ভাষাগুলো নিজের হাতে যাচাই করুন। নিচের JavaScript কোডে t(name, v) নিজের নাম একটি তালিকায় লিখে মান ফেরত দেয়, তাই তালিকাটিই হিসাবের ক্রম:

const log = [];
function t(name, v) { log.push(name); return v; }     // records the order
function show(label, value) {
  console.log(label, "=", value, "| order:", log.join(" ") || "-");
  log.length = 0;
}
show("f() + g() * h()", t("f", 1) + t("g", 2) * t("h", 3));
const order = { qty: [0, 0] };
t("obj", order).qty[t("idx", 1)] = t("val", 7);      // target before value
show("order.qty", JSON.stringify(order.qty));
let i = 1;
show("i + (i = 10) + i", i + (i = 10) + i);
let x = 5;
x += (x = 100);                                       // old x is read first
show("x += (x = 100)", x);
const pick = () => { log.push("callee"); return (a, b) => a - b; };
show("pick()(a1, a2)", pick()(t("a1", 9), t("a2", 4)));
show("c ? then : else", t("c", 0) ? t("then", "A") : t("else", "B"));
show("0 || 'BG-1' && 60", t("L", 0) || t("M", "BG-1") && t("R", 60));

আসল আউটপুট (ব্রাউজারের JavaScript; লেখকের যন্ত্রে Node 24-এও হুবহু এক):

f() + g() * h() = 7 | order: f g h
order.qty = [0,7] | order: obj idx val
i + (i = 10) + i = 21 | order: -
x += (x = 100) = 105 | order: -
pick()(a1, a2) = 5 | order: callee a1 a2
c ? then : else = B | order: c else
0 || 'BG-1' && 60 = 60 | order: L M R

প্রথম লাইন: f, g, h: precedence *-কে আগে প্রয়োগ করে, কিন্তু operand-গুলো বাঁ থেকে ডানে হিসাব হয়। দ্বিতীয়: assignment-এর বাঁ পাশ (object, তারপর index) ডান পাশের আগে। তৃতীয়: i + (i = 10) + i = 1 + 10 + 10 = 21: প্রথম i পুরোনো মান পড়ে ফেলেছে assignment-এর আগেই। চতুর্থ: x += (x = 100)-এর ফল 105, 200 নয়: compound assignment বাঁ পাশের পুরোনো মান (5) আগে পড়ে রাখে, তারপর ডান পাশ চালায়। পঞ্চম: callee আগে, তারপর argument, Haat-এর মতোই। ষষ্ঠ আর সপ্তম অংশ ৬-এর বিষয়: conditional শুধু একটি শাখা চালায়, আর ||/&& দরকার হলে তবেই ডানে যায়।

Python-এ একই পরীক্ষা, আর একটি অপ্রত্যাশিত পার্থক্য:

log = []
def t(name, v):                       # records the order of evaluation
    log.append(name); return v
def show(label, value):
    print(f"{label:24} = {value!s:9} | order: {' '.join(log) or '-'}")
    log.clear()
show("f() + g() * h()", t("f", 1) + t("g", 2) * t("h", 3))
order = {"qty": [0, 0]}
t("obj", order)["qty"][t("idx", 1)] = t("val", 7)   # value first in Python
show("order['qty']", order["qty"])
show("a() < b() < c()", t("a", 1) < t("b", 5) < t("c", 3))
show("a() < b() < c() [a=9]", t("a", 9) < t("b", 5) < t("c", 3))
show("0 or 'BG-1' and 60", t("L", 0) or t("M", "BG-1") and t("R", 60))
show("-2 ** 2", -2 ** 2)
cart = [520]; alias = cart
cart += [60]                          # in place: list.__iadd__
show("after cart += [60]", alias)
cart = cart + [10]                    # a new list; alias keeps the old one
show("after cart = cart + [10]", alias)
if (n := len(cart)) > 2:              # := is an assignment expression
    show("n := len(cart)", n)

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

f() + g() * h()          = 7         | order: f g h
order['qty']             = [0, 7]    | order: val obj idx
a() < b() < c()          = False     | order: a b c
a() < b() < c() [a=9]    = False     | order: a b
0 or 'BG-1' and 60       = 60        | order: L M R
-2 ** 2                  = -4        | order: -
after cart += [60]       = [520, 60] | order: -
after cart = cart + [10] = [520, 60] | order: -
n := len(cart)           = 3         | order: -

দ্বিতীয় লাইনে ক্রম val obj idx: JavaScript-এর ঠিক উল্টো। Python-এর Language Reference (§6.16, “Evaluation order”) স্পষ্ট বলে, assignment-এ ডান পাশ বাঁ পাশের আগে হিসাব হয়। দুটি ভাষাই “বাঁ থেকে ডানে” বলে পরিচিত, অথচ assignment-এ তারা আলাদা; এজন্যই প্রতিটি দাবি ভাষা আর version ধরে যাচাই করতে হয়। তৃতীয় আর চতুর্থ লাইনে Python-এর শৃঙ্খলিত তুলনা: b একবারই হিসাব হয়েছে, আর a = 9 হলে প্রথম তুলনাই False, তাই c ছোঁয়া হয়নি: a < b and b < c-এর মতোই short-circuit. পঞ্চম লাইনে or/and Bool নয়, একটি operand-ই ফেরত দেয়, এখানে 60. শেষ তিন লাইন অংশ ৭-এর জন্য রাখা।

৫ · Side effect, sequencing আর C-র undefined behavior

C কেন ক্রম নির্দিষ্ট করে না? মূল কারণ compiler-কে স্বাধীনতা দেওয়া: যে যন্ত্রে argument ডান থেকে বাঁয়ে stack-এ তোলা স্বাভাবিক, সেখানে ডান থেকে হিসাব করলে মান রেখে আবার সাজাতে হয় না; আর register কম থাকলে জটিল operand আগে হিসাব করা লাভজনক। এই স্বাধীনতার দাম মেটাতে C-র standard তিন ধরনের “অনির্দিষ্টতা” আলাদা করে:

ধরনঅর্থউদাহরণ
Unspecifiedকয়েকটি বৈধ ফলের যেকোনোটি; compiler-কে জানাতে হয় না, প্রতিবার একই বাছাই করতেও হয় নাf() + g()-এ কোনটি আগে
Implementation-definedcompiler একটি বেছে নিয়ে নথিতে লিখে রাখেঋণাত্মক signed সংখ্যার ডানে shift
Undefinedstandard কোনো দাবিই রাখে না; program-এর পুরো অর্থ হারায়i++ + i++, signed overflow

কোন ক্ষেত্রে unspecified থেকে undefined-এ পৌঁছায়? পুরোনো C (C89, C99) এটি বলত sequence point দিয়ে: ;, &&, ||, ?:-এর প্রথম অংশ, comma operator আর function call-এর আগের মুহূর্ত, যেখানে আগের সব side effect শেষ। C11 থেকে নিয়মটি লেখা হয় একটি সম্পর্ক দিয়ে, sequenced before: A sequenced before B মানে A-র হিসাব আর তার side effect B শুরুর আগেই শেষ। দুটি কাজের কোনোটি অন্যটির আগে sequenced না হলে তারা unsequenced. আর C17-এর §6.5-এর মূল বাক্যটির ভাব এরকম:

নিয়ম ২৬.৩ — C17 §6.5 (ভাবানুবাদ)

একটি scalar object-এর ওপর একটি side effect যদি একই object-এর ওপর আরেকটি side effect-এর সঙ্গে, অথবা সেই object-এর মান ব্যবহার করা কোনো হিসাবের সঙ্গে unsequenced হয়, তাহলে আচরণ undefined.

তাই f() + g() শুধু unspecified (দুটি call একে অপরের সঙ্গে interleave হয় না, শুধু ক্রম অজানা), কিন্তু i++ + i++ undefined: একই i-এ দুটি unsequenced লেখা। i = i++ + 1 আর a[i] = i++-ও C-তে undefined. সত্যিকারের Clang এগুলো compile-এর সময়েই ধরে, আর -Wunsequenced এই Clang-এ ডিফল্টেই চালু:

#include <stdio.h>
int main(void) {
    int i = 1;
    int a = i++ + i++;      /* two unsequenced changes to i */
    i = i++ + 1;            /* also undefined in C */
    printf("%d %d\n", a, i);
    return 0;
}
~/haat $ zig cc -std=c17 -Wall -S -o ub.s ub.c
ub.c:4:14: warning: multiple unsequenced modifications to 'i' [-Wunsequenced]
    4 |     int a = i++ + i++;      /* two unsequenced changes to i */
      |              ^     ~~
ub.c:5:10: warning: multiple unsequenced modifications to 'i' [-Wunsequenced]
    5 |     i = i++ + 1;            /* also undefined in C */
      |       ~  ^
2 warnings generated.

এই program আমরা ইচ্ছা করে চালাইনি, শুধু compile করেছি। Undefined behavior-এর কোনো “সঠিক উত্তর” নেই: কোনো একটি compiler কোনো একদিন 3 ছাপল মানে এই নয় যে উত্তর 3; অন্য optimization স্তরে, অন্য compiler-এ বা পাশের কোড বদলালে ফল বদলাতে পারে, কারণ optimizer ধরে নেয় UB কখনো ঘটে না। পরীক্ষায় বা ইন্টারভিউতে “i++ + i++-এর মান কত?” প্রশ্নের সঠিক উত্তর: “C আর C++-এ undefined behavior; কোনো নির্দিষ্ট মান নেই।” Java বা JavaScript-এ একই লেখার মান নির্দিষ্ট (অনুশীলন ৪)। নিরাপদ C লেখার অভ্যাস নিয়ে আরও আছে C কোর্সের পর্ব ৪৮-এ।

অন্যদিকে unspecified ক্রম চালিয়ে দেখা নিরাপদ, শুধু ফলটিকে “এই compiler-এর এই বাছাই” হিসেবে পড়তে হয়:

#include <stdio.h>
static int f(void) { puts("f"); return 1; }
static int g(void) { puts("g"); return 2; }
int main(void) {
    int s = f() + g();            /* order unspecified, not undefined */
    printf("s = %d\n", s);
    printf("%d %d\n", f(), g());  /* argument order unspecified too */
    return 0;
}
~/haat $ zig cc -std=c17 -Wall -O0 -fno-sanitize=undefined order.c -o order.exe
~/haat $ ./order.exe
f
g
s = 3
f
g
1 2

এই Clang (22.1.8, -O0) দুই জায়গাতেই বাঁ থেকে ডানে হিসাব করেছে। কিন্তু এটি standard-এর প্রতিশ্রুতি নয়: অন্য compiler, অন্য version বা অন্য optimization স্তর ভিন্ন ক্রম বেছে নিতে পারে, আর তখনো সেটি সঠিক C. যোগফল s সবসময় 3, কারণ f আর g একে অপরের ফল বদলায় না; শুধু ছাপার ক্রম অনির্দিষ্ট। নিরাপদ নিয়ম: যে expression-এর ক্রমে ফল বদলায়, তাকে আলাদা statement-এ ভাঙুন: int a = f(); int b = g(); s = a + b;. ; সবসময় ক্রম নিশ্চিত করে।

C++ এখানে আংশিক পথ বদলেছে। C++17-এ (প্রস্তাব P0145, Dos Reis, Sutter আর Caves) কিছু ক্রম বাঁধা হয়েছে: a.b, a->b, a[b], a << b আর a >> b-এ বাঁ পাশ আগে; সব assignment-এ ডান পাশ আগে; আর function argument-গুলো যেকোনো ক্রমে হলেও একটির হিসাব আরেকটির সঙ্গে মিশে যায় না। তাই C++17-এ i = i++ + 1 বৈধ আর নির্দিষ্ট, অথচ C17-এ undefined; i++ + i++ দুই ভাষাতেই undefined. একই চিহ্ন, ভাষা আর version-ভেদে ভিন্ন সত্য।

৬ · Short-circuit আর conditional expression — যা হিসাব হয় না

এ পর্যন্ত প্রতিটি operator তার সব operand হিসাব করেছে। &&, || আর conditional expression ব্যতিক্রম: এদের একটি অংশ ইচ্ছা করে বাদ যায়। পর্ব ১৯-এ দেখেছেন এরা strict ভাষার ভেতরের “lazy ফাঁক”, আর n != 0 && total / n > 500-এর মতো পাহারা কীভাবে কাজ করে। এখানে নিয়মগুলো formal আকারে লিখি, আর ||-এর বাস্তবায়ন ধাপে ধাপে দেখি। Short-circuit-এর big-step নিয়ম:

⟨e1, σ⟩ ⇓ ⟨true, σ1⟩
⟨e1 or e2, σ⟩ ⇓ ⟨true, σ1⟩
(Or-T)
⟨e1, σ⟩ ⇓ ⟨false, σ1⟩    ⟨e2, σ1⟩ ⇓ ⟨b, σ2⟩
⟨e1 or e2, σ⟩ ⇓ ⟨b, σ2⟩
(Or-F)

এখানে “or” মানে Haat-এর ||. (Or-T)-তে e2-এর কোনো উল্লেখই নেই: e2 ⊥ হোক, ছাপুক বা চিরকাল চলুক, ফল true আর memory σ1. &&-এর দুটি নিয়ম ঠিক উল্টো: e1 false হলে থামে। খেয়াল করুন, (Add)-এর মতো এখানেও σ বাঁ থেকে ডানে বয়ে যায়। Haat-এ বাস্তবায়ন:

// বাজারঘর: ফ্রি ডেলিভারি কে পাবে
fn big(total: Int) -> Bool {
    print("big checked");
    return total >= 1000;
}
fn free(vip: Bool, total: Int) -> Bool {
    return vip || big(total);
}
print(free(true, 500));
print(free(false, 1200));
~/haat $ python haat.py run free.haat
true
big checked
true
~/haat $ python haat.py dis free.haat      # only free shown
== free (arity 2, locals 2) ==
   0  LOAD_LOCAL     0     ; vip
   1  JUMP_IF_FALSE  4
   2  CONST          0     ; true
   3  JUMP           7
   4  LOAD_GLOBAL    0     ; big
   5  LOAD_LOCAL     1     ; total
   6  CALL           1
   7  RETURN

সত্যিকারের run (vm-এও একই তিন লাইন)। প্রথম ডাকে “big checked” ছাপা হয়নি। কেন, তা bytecode ধরে দেখুন; জাম্পের লক্ষ্যগুলো নির্দেশের ক্রমিক নম্বর (নকশা-সিদ্ধান্ত ২৮):

0LOAD_LOCAL     0   ; vip1JUMP_IF_FALSE  42CONST          0   ; true3JUMP           74LOAD_GLOBAL    0   ; big5LOAD_LOCAL     1   ; total6CALL           17RETURN
নির্দেশের পরে
ডাক
operand stack
পরের নির্দেশ
big ডাকা
  1. প্রথম ডাক, বাঁ পাশ। free(true, 500): LOAD_LOCAL 0 parameter vip-এর মান true তোলে।
  2. পরীক্ষা। JUMP_IF_FALSE 4 মানটি নামিয়ে দেখে। True, তাই লাফ নেই, পরের নির্দেশ ২.
  3. ফল নিশ্চিত। বাঁ পাশ true হলে or-এর ফল true, তাই compiler এখানে সরাসরি CONST true বসিয়েছে: নিয়ম (Or-T).
  4. ডান পাশ লাফ। JUMP 7 নির্দেশ ৪, ৫, ৬ পুরো এড়িয়ে যায়। ডান পাশের পুরো কোড, big-এর call-সহ, এই তিন নির্দেশে; সেগুলো চলেইনি।
  5. ফেরত। RETURN true ফেরত দেয়, print “true” ছাপে। “big checked” নেই: short-circuit একটি সত্যিকারের side effect বাদ দিয়েছে।
  6. দ্বিতীয় ডাক। free(false, 1200): vip false তোলা হয়।
  7. এবার লাফ। JUMP_IF_FALSE 4 false দেখে সোজা নির্দেশ ৪-এ যায়; ২ আর ৩ বাদ। নিয়ম (Or-F): ফল এখন পুরোপুরি ডান পাশের হাতে।
  8. ডান পাশের প্রস্তুতি। নির্দেশ ৪ আর ৫ callee big আর argument total = 1200 তোলে: আবার callee আগে, argument পরে।
  9. Call. CALL 1: এবার big চলে, “big checked” ছাপে, আর 1200 ≥ 1000 বলে true ফেরত দেয়।
  10. ফেরত। RETURN সেই true-ই ফেরত দেয়। দুই ডাকে big চলেছে মোট একবার। লক্ষ করুন, ||-এর জন্য কোনো OR opcode নেই: short-circuit পুরোটাই jump দিয়ে বানানো control flow.

ফল কী: Bool, না একটি operand?

Haat-এ && আর ||-এর দুই operand-ই Bool হতে হবে, ফলও Bool (নকশা-সিদ্ধান্ত ১১)। Python আর JavaScript-এ তা নয়: 0 || 'BG-1' && 60-এর মান 60, কারণ এরা যে operand-এ থামে সেটিই ফেরত দেয় (JS আর Python দুই run-এই দেখেছেন)। এতে name || "অতিথি"-এর মতো সংক্ষিপ্ত default লেখা যায়, কিন্তু 0 বা খালি string-ও “মিথ্যা” ধরা হয় বলে ভুলও হয়; JavaScript এজন্য পরে ?? যোগ করেছে, যা শুধু null আর undefined-এ ডানে যায়। C-তে ফল সবসময় int 0 বা 1.

Short-circuit সবসময় ছিল না। ISO Pascal and/or-এ দুই পাশ হিসাব হবে কি না নির্দিষ্ট করেনি, তাই পাহারা-লেখা অনিশ্চিত ছিল। Ada (১৯৮৩) সমাধান করল দুটি আলাদা রূপ দিয়ে: and-এ দুই পাশের হিসাবের নিশ্চয়তা নেই, and then সবসময় short-circuit করে। C && আর ||-কে short-circuit আর sequence point দুটিই বানিয়েছে।

Conditional expression একই পরিবারের: শর্ত হিসাব হয়, তারপর শুধু একটি শাখা। C, Java আর JavaScript-এ ternary operator c ? a : b, Python-এ a if c else b, আর এর শিকড় McCarthy-র LISP-এর conditional expression (১৯৬০) আর ALGOL 60-এর if b then e1 else e2. Haat v1-এ conditional expression নেই: if একটি statement. দরকার হলে একটি ছোট function লিখুন, যেমন fn fee(total: Int) -> Int { if total >= 1000 { return 0; } return 60; }. সাবধান: fn choose(c: Bool, a: Int, b: Int) -> Int লিখে conditional বানানো যায় না, কারণ strict ভাষায় call-এর আগে দুই শাখাই চলবে, পর্ব ১৯-এর মূল শিক্ষা।

৭ · Assignment: expression না statement? Compound assignment-এর desugaring

C-তে = একটি operator, আর x = e একটি assignment expression: e-এর মান x-এ বসায় আর সেই মান নিজেও দেয়। তাই paid = due = 0 চলে (= ডান-সংযোগী: paid = (due = 0)), আর while ((c = getchar()) != EOF)-এর মতো সংক্ষিপ্ত loop লেখা যায়। দামটিও বিখ্যাত: ==-এর জায়গায় ভুলে =. সত্যিকারের Clang:

#include <stdio.h>
int main(void) {
    int paid, due, stock = 5;
    paid = due = 0;               /* = is an expression: right to left */
    if (stock = 0)                /* meant: stock == 0 */
        puts("out of stock");
    printf("%d %d %d\n", paid, due, stock);
    return 0;
}
~/haat $ zig cc -std=c17 -Wall -O0 -fno-sanitize=undefined assign.c -o assign.exe
assign.c:5:15: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]
1 warning generated.
~/haat $ ./assign.exe
0 0 0

(Clang-এর দুটি “note” লাইন বাদ।) স্টক ৫ ছিল; শর্তটি স্টককে 0 বানিয়ে দিয়েছে, আর 0 মিথ্যা বলে “out of stock”-ও ছাপা হয়নি। একটি পরীক্ষা ভুল করে, সঙ্গে ডেটাও নষ্ট করে। Haat এই দরজা বন্ধ রেখেছে: assignment একটি statement (নকশা-সিদ্ধান্ত ৯), তাই অংশ ২-এর print(stock = 4) সরাসরি syntax error. Python-ও assignment-কে statement রেখেছিল; Python 3.8 (PEP 572) আলাদা চিহ্ন := দিয়ে assignment expression আনে, যাতে = আর ==-এর গোলমাল ফিরে না আসে (অংশ ৪-এর Python run-এর শেষ লাইন)। Rust আর Swift-এ assignment একটি expression, কিন্তু তার মান () বা Void, তাই if x = 0 type error.

Compound assignment আর desugaring

Compound assignment x op= e-কে সাধারণত বলা হয় x = x op e-এর সংক্ষেপ। Compiler-এর কাছে এটি একটি desugaring: বড় ভাষার একটি রূপকে ছোট core-এর রূপে নামানো (পর্ব ৫৫-এ পুরো কৌশল)। কিন্তু হুবহু লেখা-বদল তিন জায়গায় ভুল হয়:

  • বাঁ পাশ একবার হিসাব হয়: a[f()] += 1 মানে t = f(); a[t] = a[t] + 1, a[f()] = a[f()] + 1 নয়; নইলে f দুবার চলত। তাই সঠিক desugaring-এ একটি temporary লাগে।
  • লুকানো cast: Java-তে byte b-এর জন্য b += 1 বৈধ, কিন্তু b = b + 1 type error, কারণ JLS §15.26.2 অনুযায়ী E1 op= E2 মানে E1 = (T) ((E1) op (E2)), যেখানে T হলো E1-এর type.
  • In-place বদল: Python-এ list-এর += __iadd__ ডাকে আর একই list বদলায়, কিন্তু cart = cart + [10] নতুন list বানায়। অংশ ৪-এর Python run-এ alias প্রথমটিতে [520, 60] দেখেছে, দ্বিতীয়টিতে বদলায়নি। Aliasing-এর পুরো গল্প পর্ব ২৯-এ (Parameter passing).

JavaScript run-এর x += (x = 100) = 105-ও এই নিয়মের ফল: বাঁ পাশের পুরোনো মান আগে পড়া হয়, তারপর ডান পাশ। C-র increment operator i++ আসলে আরও একটি desugaring: “পুরোনো মান দাও, আর কোনো এক সময় i-কে এক বাড়াও”। “কোনো এক সময়” শব্দটিই অংশ ৫-এর UB-এর উৎস।

Haat-এর বর্ধিত রূপ — x += e;: ধরুন Haat-এ += -= *= /= %= যোগ করতে চাই। Haat-এ assignment-এর লক্ষ্য সবসময় একটি সাধারণ নাম (নকশা-সিদ্ধান্ত ৯), তাই desugaring সহজ আর নিরাপদ: parser x op= e; পেলে সরাসরি Assign(x, Binary(op, Var(x), e)) বানাবে। নাম পড়ার কোনো side effect নেই, তাই x দুবার লেখায় কিছু বদলায় না; বাঁ-থেকে-ডান নিয়মে পুরোনো x আগে পড়া হয়, ঠিক JavaScript-এর মতো। Resolver আর type checker নতুন কিছু শিখবে না: x অবশ্যই var হবে (নকশা-সিদ্ধান্ত ১৯), আর x + e-এর type-নিয়ম আগের মতোই। শুধু error message-এর জায়গা ঠিক রাখতে নতুন node-গুলোর position += চিহ্নের হতে হবে। পরে array এলে (বর্ধিত রূপ) a[f()] += 1-এর জন্য temporary লাগবে।

৮ · Operator overloading আর constant folding — compiler-এর চোখে operator

Haat-এর + দুই কাজ করে: দুটি Int-এ যোগ, দুটি Str-এ জোড়া; বাঁ operand-এর type ঠিক করে ডানটি কী হবে (নকশা-সিদ্ধান্ত ১১)। এটি operator overloading-এর সরলতম রূপ, যা ভাষা নিজে ঠিক করে দেয়। অনেক ভাষা ব্যবহারকারীকেও এই ক্ষমতা দেয়: Python-এ class-এ __add__ লিখলে a + b সেটি ডাকে (বাঁ পাশ NotImplemented ফেরত দিলে ডান পাশের __radd__), আর C++-এ operator+ লেখা যায় (C++ কোর্সের পর্ব ২৩)। একটি জরুরি সীমা: overloading শুধু operator-এর অর্থ বদলায়, তার precedence, associativity বা arity নয়, কারণ সেগুলো parser-এর সিদ্ধান্ত, যা type জানার আগেই নেওয়া হয়ে গেছে। আর একটি পরিচিত ফাঁদ: C++-এ && বা || overload করলে সেটি একটি সাধারণ function call হয়ে যায়, ফলে দুই operand-ই হিসাব হয়, short-circuit হারায়। Overloading কীভাবে সঠিক function বেছে নেয়, তা পর্ব ৩৬-এ (Polymorphism).

Constant folding: compiler আগেই হিসাব করে রাখে

Expression-এর সব operand compile-এর সময়েই জানা থাকলে compiler নিজেই হিসাব করে ফল বসিয়ে দিতে পারে; এর নাম constant folding. শর্ত একটিই: চলার সময়ের আচরণ হুবহু একই থাকতে হবে। CPython-এর compiler কী করে, ব্রাউজারেই দেখুন (Pyodide-এর CPython 3.14.2; লেখকের যন্ত্রের CPython 3.14.4-এও নির্দেশগুলো হুবহু এক):

import dis, sys
print("CPython", sys.version.split()[0])
def consts(src):                       # which constants did the compiler keep?
    code = compile(src, "<bazar>", "eval")
    return [f"{i.opname} {i.argrepr or i.argval}" for i in
            dis.get_instructions(code) if i.opname not in ("RESUME", "RETURN_VALUE")]
for src in ["2 * 520 - 104",          # all constants: folded
            "qty * 520 + 2 * 30",     # only the constant part folds
            "qty + 2 + 30",           # (qty + 2) + 30: nothing to fold
            "qty + (2 + 30)",         # brackets make a constant subtree
            "1 / 0"]:                 # would raise: left for run time
    print(f"{src:20} -> " + ", ".join(consts(src)))

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

CPython 3.14.2
2 * 520 - 104        -> LOAD_CONST 936
qty * 520 + 2 * 30   -> LOAD_NAME qty, LOAD_CONST 520, BINARY_OP *, LOAD_SMALL_INT 60, BINARY_OP +
qty + 2 + 30         -> LOAD_NAME qty, LOAD_SMALL_INT 2, BINARY_OP +, LOAD_SMALL_INT 30, BINARY_OP +
qty + (2 + 30)       -> LOAD_NAME qty, LOAD_SMALL_INT 32, BINARY_OP +
1 / 0                -> LOAD_SMALL_INT 1, LOAD_SMALL_INT 0, BINARY_OP /

প্রথম: পুরো expression একটি constant, 936. দ্বিতীয়: শুধু 2 * 30 অংশটি 60 হয়েছে; qty-এর মান চলার সময় জানা যাবে। তৃতীয়টিই আসল শিক্ষা: qty + 2 + 30-এ 2 আর 30 দুটিই constant, তবু কিছু fold হয়নি। কারণ বাঁ-সংযোগে গাছটি (qty + 2) + 30; 2 আর 30 কখনো একই node-এর সন্তান নয়। 2 + 30 আগে করতে হলে গাছ নতুন করে সাজাতে হবে (reassociation), আর Python-এ +-এর অর্থ qty-এর type-এর ওপর নির্ভর করে (string, list, নিজের class), তাই compiler এই ঝুঁকি নেয় না। চতুর্থ: বন্ধনী দিলে constant subtree তৈরি হয়, 32. পঞ্চম: 1 / 0 fold হয়নি: compile-এর সময় error দিলে program-এর অর্থ বদলে যেত, কারণ হয়তো এই লাইন কখনো চলতই না।

C-র compiler আরও সাহসী, কারণ সেখানে int-এর অর্থ নির্দিষ্ট আর signed overflow UB. সত্যিকারের Clang 22.1.8, LLVM IR (প্রতিটি কমান্ডে আরও আছে -std=c17 -g0 --target=x86_64-linux-musl; শুধু হিসাবের লাইনগুলো রাখা, বাকিটা ছাঁটা):

int bill(int q) { return q * 2 * 520 + 3 * 20; }
double ship(double w) { return w + 1.0 + 2.0; }
int too_big(void) { return 2147483647 + 1; }
~/haat $ zig cc -O0 -fno-sanitize=undefined -emit-llvm -S fold.c   # bill, ship
  %4 = mul nsw i32 %3, 2
  %5 = mul nsw i32 %4, 520
  %6 = add nsw i32 %5, 60
  %4 = fadd double %3, 1.000000e+00
  %5 = fadd double %4, 2.000000e+00
~/haat $ zig cc -O2 -fno-sanitize=undefined -emit-llvm -S fold.c   # bill, ship
  %2 = mul nsw i32 %0, 1040
  %3 = add nsw i32 %2, 60
  %2 = fadd double %0, 1.000000e+00
  %3 = fadd double %2, 2.000000e+00
~/haat $ zig cc -O2 -ffast-math -emit-llvm -S fold.c               # ship
  %2 = fadd fast double %0, 3.000000e+00
~/haat $ zig cc -O0 -emit-llvm -S fold.c                           # too_big
fold.c:3:39: warning: overflow in expression; result is -2'147'483'648 with type 'int' [-Winteger-overflow]
  ret i32 -2147483648

-O0-তেও 3 * 20 সরাসরি 60: optimization বন্ধ থাকলেও Clang শুধু-constant অংশটি fold করেছে। q * 2 * 520 কিন্তু -O0-তে দুটি গুণ, ঠিক Python-এর তৃতীয় লাইনের মতো, কারণ গাছ (q * 2) * 520. -O2-তে optimizer গাছ নতুন করে সাজিয়ে একটি গুণে নামিয়েছে, q * 1040: int গুণ associative, আর nsw (“no signed wrap”) চিহ্ন বলে overflow হলে UB, তাই এই বদলে কোনো বৈধ program-এর ফল বদলায় না। Double-এ -O2-ও w + 1.0 + 2.0-কে ছোঁয়নি: IEEE 754 যোগ associative নয় (rounding-এর কারণে (w + 1.0) + 2.0 আর w + 3.0 কিছু w-এ আলাদা), তাই নিরাপদ নয়। -ffast-math দিয়ে প্রোগ্রামার যখন সেই নিশ্চয়তা ছেড়ে দেন, তখনই fadd fast … 3.0. too_big: constant হিসাবে overflow, Clang সতর্ক করে wrap করা মান বসিয়েছে; C-তে এটি UB, তাই সতর্কবার্তাটিই আসল খবর।

Haat-এর reference compiler কোনো fold করে না: print(2 * 520 - 104);-এর dis-এ সত্যিই CONST 2, CONST 520, MUL, CONST 104, SUB আসে। একটি নিরাপদ Haat folder কেমন হবে, তা অনুশীলন ১-এ লিখবেন; নিয়মগুলো এই অংশ থেকেই আসে: wrap মেনে, C-ধাঁচের / আর % মেনে, শূন্য দিয়ে ভাগ চলার সময়ের জন্য রেখে, আর side effect-ওয়ালা অংশ কখনো ফেলে না দিয়ে। Constant propagation, CSE আর অন্য local optimization-এর পুরো আলোচনা পর্ব ৬৫-এ।

আরও গভীরে: প্রথম FORTRAN compiler (১৯৫৭) precedence সামলাত একটি চতুর কৌশলে, বলা হয়: প্রতিটি operator-এর চারপাশে নির্দিষ্ট সংখ্যক বন্ধনী বসিয়ে দেওয়া (যেমন +-কে ))+((), যাতে পুরো লেখা আপনা থেকেই সঠিকভাবে বন্ধনীবদ্ধ হয়। C++17-এর ক্রম-বদলের প্রস্তাব P0145-এর একটি বিখ্যাত প্রেরণা ছিল, বলা হয়, একটি নামকরা বইয়ের chained s.replace(…).replace(s.find(…), …) উদাহরণ, যা অভিজ্ঞ পর্যালোচকদের চোখ এড়িয়ে গিয়েছিল অথচ পুরোনো নিয়মে unspecified ছিল। আর optimizer-এর দিক থেকে, LLVM-এর nsw/nuw চিহ্ন আর “poison” মান ঠিক এই কাজটিই করে: source ভাষার UB-কে IR-এ বহন করা, যাতে q * 2 * 520-এর মতো reassociation বৈধ হয়।

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

  • Precedence আর evaluation order-এর পার্থক্য? Precedence গাছের আকার (কে কার operand) ঠিক করে; order ঠিক করে স্বাধীন operand-গুলো কোন ক্রমে হিসাব হবে।
  • C-তে i++ + i++-এর মান? নেই: একই object-এ দুটি unsequenced বদল, undefined behavior.
  • Short-circuit কীভাবে compile হয়? বাঁ পাশ হিসাবের পরে একটি conditional jump ডান পাশ লাফিয়ে যায়; আলাদা AND/OR নির্দেশ লাগে না।
  • একটি expression-এর AST আঁকুন / postfix লিখুন। Precedence আর associativity ধরে গাছ বানান, তারপর post-order হাঁটুন: 2 + 3 * 4 - 1 → 2 3 4 * + 1 -.
  • Constant folding কখন অবৈধ? যখন ফল চলার সময়ের আচরণ থেকে আলাদা হতে পারে: শূন্য দিয়ে ভাগ, floating-point reassociation, side effect-ওয়ালা অংশ ফেলে দেওয়া।

৯ · AI-এর যুগে expression আর evaluation order

Expression-এর প্রশ্নে AI assistant প্রায়ই খুব আত্মবিশ্বাসী উত্তর দেয়, কারণ প্রশ্নগুলো ছোট দেখায়। অথচ এখানেই এক ভাষার নিয়ম অন্য ভাষায় চাপানো সবচেয়ে সহজ। বারবার দেখা ভুল:

AI-এর ভুলকীভাবে ধরবেন
i++ + i++ বা i = i++ + 1-এর জন্য C-তে একটি নির্দিষ্ট সংখ্যা বলা-Wall দিয়ে compile করে -Wunsequenced দেখা; ভাষা আর version ধরে প্রশ্ন করা (C17 বনাম C++17)
“Python-ও JavaScript-এর মতো assignment-এ বাঁ পাশ আগে হিসাব করে”লগ-করা function দিয়ে দুই ভাষায় a[k()] = v() চালানো
Precedence থেকে evaluation order অনুমান: “* আগে, তাই g() আগে চলে”প্রতিটি operand-এ ছাপা রেখে সত্যিকারের run
হাতে লেখা parser-এ - বা /-কে ভুল করে ডান-সংযোগী বানানো10 - 4 - 3 আর 100 / 10 / 5-এর মতো পরীক্ষা, আর reference parser-এর সঙ্গে differential test
“Optimization” হিসেবে a && f()-কে f() && a বানানো, বা floating-point যোগ নতুন করে সাজানোSide effect আর ⊥ রেখে দুই সংস্করণ চালানো; সীমার কাছের মান দিয়ে double পরীক্ষা
বানানো compiler flag বা warning-এর নামনিজের compiler-এ flag চালিয়ে দেখা; Clang-এর diagnostic নাম আসল আউটপুটে মেলানো

AI-কে কাজে লাগানোর ভালো উপায়: ভাষা আর version স্পষ্ট বলা, গাছ আর হিসাবের ক্রম আলাদা করে চাওয়া, আর প্রতিটি দাবির পাশে spec-এর উৎস বা “নিশ্চিত নই” লিখতে বলা।

আমি প্রোগ্রামিং ভাষায় expression আর evaluation order শিখছি। নিচের expression-টি [ভাষা ও version, যেমন C17 / Java 21 / Python 3.14] অনুযায়ী বিশ্লেষণ করো। ১. প্রথমে precedence আর associativity ধরে AST একটি S-expression আকারে লেখো। ২. তারপর আলাদা করে evaluation order লেখো: কোন operand বা call কোন ক্রমে হিসাব হবে, আর প্রতিটি side effect কখন ঘটবে। ৩. কোনো অংশ unspecified বা undefined behavior হলে স্পষ্ট বলো, আর তখন কোনো নির্দিষ্ট মান বলবে না। ৪. প্রতিটি নিয়মের জন্য spec-এর কোন অংশ থেকে বলছ লেখো; নিশ্চিত না হলে “নিশ্চিত নই” লেখো। ৫. শেষে একটি ছোট পরীক্ষা-program দাও, যেখানে প্রতিটি operand নিজের নাম ছাপে, যাতে আমি নিজে চালিয়ে ক্রম যাচাই করতে পারি। [এখানে expression]

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

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

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

প্র ০১C-তে bitwise & কেন ==-এর চেয়ে দুর্বল, আর পরের ভাষাগুলো এই ভুল থেকে কী শিখল?

উত্তরটি ইতিহাসে। C-র পূর্বসূরি B ভাষায় (আর BCPL-এ) && আর || ছিল না। & আর | দুই কাজ করত: সাধারণ জায়গায় bitwise, আর if-এর শর্তে যুক্তির “এবং/অথবা”। if (a == b & c == d) লিখলে প্রোগ্রামার চাইতেন দুটি তুলনা আগে হোক, তাই &-কে ==-এর নিচে রাখা স্বাভাবিক ছিল। Dennis Ritchie তাঁর ১৯৯৩ সালের প্রবন্ধ “The Development of the C Language”-এ লিখেছেন, C-তে && আর || আলাদা করে আনার সময় তাঁরা &-এর precedence বদলানোর কথা ভেবেছিলেন, কিন্তু ততদিনে যে কোড লেখা হয়ে গিয়েছিল তার সামঞ্জস্য রাখতে বদলাননি; তিনি নিজেই এই সিদ্ধান্তকে একটি দুর্ভাগ্যজনক অবশেষ হিসেবে দেখেছেন।

ফল আমরা অংশ ২-এ দেখেছি: qty & 1 == 0 জোড় সংখ্যাতেও 0 দেয়। আর C-র টেবিল উত্তরাধিকার সূত্রে C++, Java, C# আর JavaScript-এও গেছে, কারণ নতুন ভাষা C প্রোগ্রামারদের কাছে পরিচিত থাকতে চেয়েছিল। এটি ভাষা নকশার একটি পুনরাবৃত্ত সত্য: পুরোনো সিদ্ধান্ত ভুল প্রমাণিত হলেও লাখো লাইন কোড আর অভ্যাসের ভার তাকে টিকিয়ে রাখে। Java অন্তত type দিয়ে আংশিক রক্ষা পায়: int & boolean type error, তাই ভুলটি compile-এর সময় ধরা পড়ে।

কিছু ভাষা সাহস করে পথ বদলেছে। Go-র spec binary operator-এর মাত্র পাঁচটি স্তর রাখে, আর &-কে *-এর স্তরে, |-কে +-এর স্তরে বসায়, তুলনার ওপরে। তাই Go-তে x & 1 == 0 মানে (x & 1) == 0, যা প্রায় সবাই চান। Rust-ও bitwise operator-কে তুলনার ওপরে রেখেছে। Haat-এর নকশা আরও সরল: bitwise operator নেই, আর তুলনা non-associative, তাই সবচেয়ে বড় ফাঁদগুলো grammar-ই বন্ধ করে। Compiler-এর দিক থেকে আরেকটি শিক্ষা: যেখানে ভাষা বদলানো যায় না, সেখানে diagnostic সাহায্য করে; Clang-এর -Wparentheses ঠিক এই কাজটিই করে, আর নতুন version শৃঙ্খলিত তুলনাকে ডিফল্টে error বানিয়ে আরও এক ধাপ এগিয়েছে।

মূল উপলব্ধি: precedence টেবিল প্রকৃতির নিয়ম নয়, ইতিহাসের ফল; একটি ছোট সামঞ্জস্য-সিদ্ধান্ত কয়েক দশক ধরে ভুল কোড জন্ম দিতে পারে, আর নতুন ভাষা হয় টেবিল বদলায়, নয় type বা diagnostic দিয়ে পাহারা দেয়।

প্র ০২Precedence আদৌ কি দরকার? APL, Smalltalk আর LISP কী বিকল্প নিয়েছিল?

Precedence-এর একমাত্র কারণ মানুষের অভ্যাস: স্কুলের গণিত শিখিয়েছে গুণ আগে, যোগ পরে। কিন্তু প্রোগ্রামিং ভাষায় operator অনেক বেশি; C-র মতো ১৫টি স্তর কেউ মুখস্থ রাখে না, আর না-জানা জায়গায় মানুষ হয় বন্ধনী দেয়, নয় ভুল করে। তাই কয়েকটি বিখ্যাত ভাষা precedence পুরো বাদ দিয়েছে।

APL (Kenneth Iverson-এর ১৯৬২ সালের বইয়ে বর্ণিত notation থেকে) সব operator-কে সমান রাখে আর ডান থেকে বাঁয়ে পড়ে: 2×3+4 মানে 2×(3+4) = 14. APL-এ শত শত operator, তাই একটি সরল নিয়মই সবচেয়ে কম বোঝা। Smalltalk-এ + আর * সাধারণ “binary message”, আর সব binary message বাঁ থেকে ডানে: 2 + 3 * 4 = 20. ভাষাটির দর্শন হলো, সবকিছু object আর message, operator-এর জন্য আলাদা নিয়ম রাখার কারণ নেই; তবে unary, binary আর keyword message-এর মধ্যে তিন স্তরের একটি ছোট নিয়ম আছে। LISP পুরো সমস্যা এড়িয়েছে prefix লেখা দিয়ে: (- (+ 2 (* 3 4)) 1). এখানে লেখাটিই গাছ; precedence, associativity, এমনকি parser-এর বেশিরভাগ কাজই লাগে না। আমাদের reference-এর ast আউটপুট ঠিক এই আকারেই। Forth আর PostScript উল্টো দিকে postfix নিয়েছে: 2 3 4 * + 1 -, যা সরাসরি একটি stack machine-এর নির্দেশ, ঠিক Haat VM-এর মতো।

প্রতিটি বিকল্পের দাম আছে। APL আর Smalltalk-এ গণিতের অভ্যাস নিয়ে আসা নতুন পাঠক ভুল পড়েন; LISP-এ বন্ধনীর ভিড় অনেককে দূরে রাখে। অন্যদিকে লাভ: কোনো লুকানো নিয়ম নেই, তাই পাঠক লেখা দেখেই গাছ বোঝেন। মাঝামাঝি পথ হলো অল্প কয়েকটি স্তর রাখা আর বিপজ্জনক মিশ্রণে বন্ধনী বাধ্যতামূলক করা: JavaScript-এর -2 ** 2 নিষেধ, Haat-এর non-associative তুলনা, বা Rust-এ শৃঙ্খলিত তুলনা নিষেধ। Haat গণিতের পরিচিত স্তরগুলো রেখেছে, কারণ এর পাঠক মূলত সাধারণ ভাষা থেকে আসেন।

মূল উপলব্ধি: precedence একটি সুবিধা, যা মানুষের অভ্যাস মেনে চলে কিন্তু লুকানো নিয়ম যোগ করে; ভালো নকশা স্তর কম রাখে আর অস্পষ্ট জায়গায় বন্ধনী চায়।

প্র ০৩Evaluation order বাঁধা থাকা উচিত, নাকি compiler-কে স্বাধীনতা দেওয়া উচিত?

দুই পক্ষেরই শক্ত যুক্তি আছে। স্বাধীনতার পক্ষে C-র ঐতিহ্য: ১৯৭০-এর দশকের যন্ত্রগুলোর register কম, calling convention ভিন্ন; compiler যদি জটিল operand আগে হিসাব করতে পারে, কম register-এ কাজ সারে (register allocation-এর পুরোনো কৌশল, যাকে Sethi–Ullman numbering বলে, ঠিক এই প্রশ্নের উত্তর দেয়: কোন subtree আগে হিসাব করলে সবচেয়ে কম register লাগে)। Argument stack-এ ডান থেকে বাঁয়ে তোলা হলে ডান থেকে হিসাবই স্বাভাবিক। এই স্বাধীনতা ছিল C-র গতির একটি অংশ।

নিশ্চয়তার পক্ষে Java-র যুক্তি: “একবার লিখুন, সবখানে চালান”-এর প্রতিশ্রুতি রাখতে একই program প্রতিটি JVM-এ একই আচরণ করবে, তাই JLS §15.7 বাঁ-থেকে-ডান বাধ্যতামূলক করে। JavaScript-কেও একই কারণে প্রতিটি browser-এ এক আচরণ দিতে হয়। আর আধুনিক compiler-এর জন্য দামটি সামান্য: যেখানে operand-গুলোর side effect নেই (বেশিরভাগ ক্ষেত্রে), optimizer তবু ইচ্ছামতো সাজাতে পারে, কারণ বাইরে থেকে পার্থক্য দেখা যায় না; শুধু side effect-ওয়ালা অংশে ক্রম মানতে হয়।

C++-এর গল্প দেখায় মাঝপথের চাপ। বছরের পর বছর অভিজ্ঞ প্রোগ্রামাররাও chained call আর stream-এ (std::cout << f() << g()) unspecified ক্রমের ফাঁদে পড়তেন। C++17-এর P0145 প্রস্তাব কিছু ক্রম বেঁধে দিল (<<-এ বাঁ আগে, assignment-এ ডান আগে), কিন্তু সাধারণ binary operator আর function argument-এ স্বাধীনতা রাখল, কারণ পুরো বাঁধন কিছু বিদ্যমান optimization আর ABI-তে খরচ বাড়াত বলে আশঙ্কা ছিল। অর্থাৎ ফল একটি আপস: যেখানে মানুষ সবচেয়ে বেশি ভুল করে, সেখানে নিশ্চয়তা।

Haat-এর নির্দিষ্ট ক্রম (নকশা-সিদ্ধান্ত ১২) শেখার ভাষার জন্য স্বাভাবিক বাছাই, আর এর একটি ব্যবহারিক লাভও আছে: reference-এর tree-walking interpreter আর VM-এর আউটপুট হুবহু মেলানো যায়, ৪০০টি random expression-এর differential test-সহ। Unspecified ক্রম থাকলে দুই back end ভিন্ন ক্রম বেছে নিয়েও “সঠিক” হতো, আর পরীক্ষা অনেক কঠিন হতো।

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

প্র ০৪Assignment কি expression হওয়া উচিত? Python-এর := নিয়ে বিতর্ক থেকে কী শেখা যায়?

C-তে assignment expression হওয়ার লাভ সংক্ষিপ্ততা: while ((c = getchar()) != EOF)-এ পড়া আর পরীক্ষা এক লাইনে, a = b = 0-এ দুটি ঘর একসাথে। দাম অংশ ৭-এর if (stock = 0): একটি অক্ষরের ভুল, যা পরীক্ষা ভুল করে আর ডেটাও বদলায়। এর প্রতিকার হিসেবে প্রোগ্রামাররা “Yoda condition” লিখতেন, if (0 == stock), যাতে ভুলে = লিখলে compile error হয়; আর compiler-গুলো সতর্কবার্তা যোগ করল, যা বন্ধনী দিলে চুপ থাকে।

Python শুরু থেকে assignment-কে statement রেখেছিল, ঠিক এই ভুল এড়াতে। কিন্তু regex মেলানো বা loop-এ পড়ার মতো কাজে একই হিসাব দুবার লিখতে হতো। ২০১৮ সালে PEP 572 আলাদা চিহ্ন := (ডাকনাম “walrus”) দিয়ে assignment expression প্রস্তাব করে। প্রস্তাবটি নিয়ে Python সম্প্রদায়ে তীব্র বিতর্ক হয়; Guido van Rossum প্রস্তাবটি গ্রহণ করেন, আর তার পরপরই, ২০১৮ সালের জুলাইয়ে, ভাষার একক সিদ্ধান্তদাতার (“BDFL”) ভূমিকা থেকে সরে দাঁড়ান, বিতর্কের ক্লান্তিকে একটি কারণ হিসেবে উল্লেখ করে। := এসেছে Python 3.8-এ (২০১৯)। নকশার দিক থেকে মূল কৌশলটি হলো আলাদা চিহ্ন: = statement-এ, := expression-এ, তাই if x = 0: এখনো syntax error.

অন্য ভাষাগুলো ভিন্ন পথে একই লক্ষ্যে গেছে। Rust-এ assignment একটি expression, কিন্তু তার type (), তাই if x = 0 type error আর a = b = 0 অর্থহীন; Swift-এ একইভাবে assignment-এর মান Void. Java-তে C-র মতো assignment expression, কিন্তু if-এর শর্ত boolean হতে হয়, তাই if (stock = 0) type error, যদিও if (flag = false) boolean-এর জন্য ধরা পড়ে না। Haat সবচেয়ে সরল পথ নিয়েছে: assignment statement (নকশা-সিদ্ধান্ত ৯), লক্ষ্য শুধু একটি নাম। ফলে অংশ ৫-এর মতো unsequenced লেখা Haat-এ লেখাই যায় না: একটি expression-এর ভেতরে variable বদলানোর একমাত্র উপায় একটি function call, আর call-গুলো নির্দিষ্ট ক্রমে চলে।

মূল উপলব্ধি: assignment-কে expression বানানো লেখা ছোট করে কিন্তু ভুলের দরজা খোলে; আধুনিক নকশা হয় আলাদা চিহ্ন (:=), নয় type (()), নয় statement-নিয়ম দিয়ে সেই দরজা পাহারা দেয়।

প্র ০৫Constant folding কখন বিপজ্জনক হয়ে ওঠে, আর compiler কীভাবে নিরাপদ থাকে?

Constant folding দেখতে নিরীহ: 2 * 520-এর জায়গায় 1040. কিন্তু এর একটি কঠিন শর্ত আছে: compile-এর সময়ের হিসাব আর চলার সময়ের হিসাব হুবহু এক হতে হবে। এই শর্ত ভাঙার অন্তত চারটি পথ আছে। এক, লক্ষ্য-যন্ত্রের পাটিগণিত: একটি cross-compiler হয়তো ৬৪-বিট যন্ত্রে চলছে কিন্তু ৩২-বিট লক্ষ্যের জন্য code বানাচ্ছে। Fold করার সময় host-এর int নয়, লক্ষ্যের int-এর মাপ আর wrap মানতে হবে। Haat folder-এ তাই wrap লাগে, Python-এর অসীম int নয়। দুই, floating-point: অংশ ৮-এর Clang run দেখিয়েছে, -O2-ও w + 1.0 + 2.0 ছোঁয় না, কারণ IEEE 754 যোগ associative নয়, আর rounding mode বা exception flag-ও চলার সময়ের অবস্থা হতে পারে। -ffast-math প্রোগ্রামারের অনুমতি নিয়ে এই নিশ্চয়তা ছাড়ে।

তিন, error আর UB: 1 / 0-কে compile-এর সময় error বানালে program-এর অর্থ বদলায়, কারণ হয়তো লাইনটি কখনো চলত না; CPython আর আমাদের Haat folder তাই একে রেখে দেয়। C-তে 2147483647 + 1 UB, তাই Clang সতর্ক করে; কিন্তু optimizer UB-কে “ঘটে না” ধরে নিতে পারে বলেই q * 2 * 520-কে q * 1040 বানানো বৈধ: overflow হলে দুটিই UB, না হলে দুটি সমান। Java-তে int wrap করে, তাই সেখানে এই reassociation-ও বৈধ, কিন্তু অন্য কারণে: wrapping গুণ সবসময় associative. চার, side effect: f() && false-কে false বানানো যায় না, কারণ f() কিছু ছাপতে পারে; অথচ false && f()-কে false বানানো নিরাপদ, কারণ short-circuit-এ f এমনিতেই চলত না।

Compiler নিরাপদ থাকে দুটি অভ্যাসে। প্রথমত, folding-এর জন্য একই runtime-এর পাটিগণিত ব্যবহার করা: Haat reference-এর runtime.py interpreter আর VM দুজনেই ব্যবহার করে, folder-ও তাই করবে। দ্বিতীয়ত, প্রতিটি বদলের পক্ষে একটি স্পষ্ট যুক্তি রাখা, যা IR-এর চিহ্নে লেখা থাকে: LLVM-এর nsw, fast বা nnan চিহ্ন বলে দেয় কোন অনুমান বৈধ। আর পরীক্ষার দিক থেকে: আসল আর fold-করা program দুটিই চালিয়ে আউটপুট মেলানো, ঠিক যেমন অনুশীলন ১-এর উত্তরে করা হয়েছে।

মূল উপলব্ধি: constant folding নিরাপদ কেবল তখনই, যখন compile-এর সময়ের হিসাব লক্ষ্য-ভাষার চলার সময়ের অর্থ হুবহু অনুকরণ করে; সীমার মান, floating-point, error আর side effect-ই এর চার বিপদ।

অনুশীলন

প্রথমে নিজে করুন, তারপর উত্তর খুলে মেলান। Haat-এর প্রতিটি আউটপুট সত্যিকারের Haat reference-এ, আর বাকিগুলো ছোট Python, Node বা Clang run-এ মেলানো।

  1. নকশা ও বাস্তবায়ন — Haat-এর constant folder: Reference-এর AST node (Num, Bool, Unary, Binary, Call) নিয়ে একটি fold(e) function লিখুন, যা যেখানে নিরাপদ সেখানে constant অংশ হিসাব করে। শর্ত: Int wrap আর C-ধাঁচের / % মানতে হবে, শূন্য দিয়ে ভাগ রেখে দিতে হবে, আর কোনো call বা side effect ফেলে দেওয়া যাবে না। && আর ||-এ কী করবেন, তাও ঠিক করুন।

    Reference-এর runtime.py-র wrap আর arith ব্যবহার করলে interpreter আর VM-এর সঙ্গে পাটিগণিত হুবহু এক থাকে:

    from runtime import wrap, arith
    
    def fold(e):
        if isinstance(e, Unary):
            x = fold(e.operand)
            if isinstance(x, Num) and e.op == "-":
                return Num(wrap(-x.value), e.line, e.col)
            if isinstance(x, Bool) and e.op == "!":
                return Bool(not x.value, e.line, e.col)
            return Unary(e.op, x, e.line, e.col)
        if isinstance(e, Binary):
            a, b = fold(e.left), fold(e.right)
            if e.op in ("&&", "||") and isinstance(a, Bool):
                if a.value == (e.op == "||"):
                    return a                  # true || b, false && b: b never runs
                return b                      # true && b, false || b: the value is b
            if isinstance(a, Num) and isinstance(b, Num):
                if e.op in ("/", "%") and b.value == 0:
                    return Binary(e.op, a, b, e.line, e.col)   # keep the run-time error
                v = arith(e.op, a.value, b.value, e.line, e.col)
                return (Bool if isinstance(v, bool) else Num)(v, e.line, e.col)
            return Binary(e.op, a, b, e.line, e.col)
        if isinstance(e, Call):
            return Call(fold(e.callee), [fold(x) for x in e.args], e.line, e.col)
        return e

    পরীক্ষার ফাইলের প্রতিটি print-এর expression-এ চালালে (সত্যিকারের run; বাঁয়ে আসল গাছ, ডানে fold-এর পরে):

    (- (* 2 520) 104)                  => 936
    (* (* qty 2) 520)                  => (* (* qty 2) 520)
    (* qty (* 2 520))                  => (* qty 1040)
    (+ (/ 1 0) (* 2 3))                => (+ (/ 1 0) 6)
    (+ 9223372036854775807 1)          => -9223372036854775808
    (/ (- 7) 2)                        => -3
    (&& false (call big qty))          => false
    (&& (call big qty) false)          => (&& (call big qty) false)
    (|| (> (* 2 3) 5) (call big qty))  => true

    পাঁচটি সিদ্ধান্ত খেয়াল করুন। (* (* qty 2) 520) অক্ষত, কারণ আমরা reassociate করি না (অংশ ৮-এর CPython-এর মতো)। 1 / 0 রেখে দেওয়া হয়েছে, কিন্তু পাশের 2 * 3 fold হয়েছে। Overflow wrap করে INT_MIN, যা Haat source-এ একটি literal হিসেবে লেখাই যায় না (নকশা-সিদ্ধান্ত ৩), তাই একটি বাস্তব folder-কে AST-তেই মান রাখতে হয়। false && big(qty) → false নিরাপদ (call এমনিতেই চলত না), কিন্তু big(qty) && false অক্ষত, কারণ call-টি ফেলে দেওয়া যাবে না। যাচাই: শূন্য-ভাগের লাইন বাদ দিয়ে আসল ফাইলটি python haat.py run আর vm-এ চালালে ছাপে 936, 3120, 3120, −9223372036854775808, −3, false, false, true (qty = 3): fold-এর পরের প্রতিটি গাছ হিসাব করলেও ঠিক এই মানগুলোই আসে।

  2. ভুল খুঁজুন ও প্রমাণ: একজন শিক্ষার্থী Pratt loop-এ ডান operand পড়েছেন expr(lbp(op)) দিয়ে, expr(lbp(op) + 1)-এর বদলে। (ক) 10 - 4 - 3-এর গাছ আর মান কী হবে? (খ) প্রমাণ করুন, rbp = lbp + 1 হলে একই স্তরের operator-এর যেকোনো শিকল a0 op1 a1 … opn an বাঁ-সংযোগী গাছ দেয় (প্রমাণের রূপরেখা যথেষ্ট)।

    (ক) অংশ ৩-এর কোডে শুধু এই এক জায়গা বদলে সত্যিকারের run: tree: (- 10 (- 4 3)) value: 9. ডান পাশ সীমা 50 দিয়ে পড়া হয়, তাই পরের - (lbp 50 ≥ 50) ভেতরেই বাঁধা পড়ে: - ডান-সংযোগী হয়ে গেছে, আর 10 − (4 − 3) = 9, সঠিক 3 নয়। এই ভুল 2 + 3 * 4-এর মতো পরীক্ষায় ধরা পড়ে না, কারণ সেখানে একই স্তরের দুটি operator পাশাপাশি নেই; তাই 10 - 4 - 3 আর 100 / 10 / 5 সবসময় test-এ রাখুন।

    (খ) দাবি: সব opk-এর lbp = p, শিকলের আগে-পরে কোনো বেশি-শক্তির operator নেই (atom-গুলো সংখ্যা), আর ডাকটি expr(m) যেখানে m ≤ p. তাহলে ফল ((a0 op1 a1) op2 a2) … opn an. প্রমাণের রূপরেখা, k-এর ওপর induction:

    1. ভিত্তি: atom পড়ার পরে left = a0, যা শূন্য operator-এর বাঁ-সংযোগী গাছ।
    2. অনুমান: loop-এর কোনো এক মুহূর্তে left = Lk, প্রথম k operator-এর বাঁ-সংযোগী গাছ, আর পরের token opk+1.
    3. ধাপ: p ≥ m, তাই loop opk+1 খায় আর ডান পাশ পড়ে expr(p + 1) দিয়ে। সেই ভেতরের ডাক ak+1 পড়ে; পরের token opk+2 (lbp p) বা শেষ। p ≥ p + 1 মিথ্যা, তাই ভেতরের ডাক কিছু না বেঁধে ak+1 ফেরত দেয়। তাই left = (opk+1 Lk ak+1) = Lk+1.
    4. n ধাপের পরে শেষ চিহ্নে loop থামে আর Ln ফেরত দেয়, যা বাঁ-সংযোগী গাছ। ∎

    ভুল সংস্করণে ধাপ ৩ ভেঙে পড়ে: ভেতরের ডাকের সীমা p, আর p ≥ p সত্য, তাই opk+2 ভেতরে চলে যায় আর গাছ ডানে ঝোঁকে।

  3. আউটপুট অনুমান করুন: নিচের Haat program কী ছাপবে? প্রতিটি লাইনের জন্য আগে গাছ, তারপর হিসাবের ক্রম লিখুন।
    fn tag(s: Str, v: Int) -> Int { print(s); return v; }
    fn ok(s: Str, b: Bool) -> Bool { print(s); return b; }
    print(tag("a", 2) + tag("b", 3) * tag("c", 4));
    print(ok("p", false) && ok("q", true) || ok("r", true));
    print(tag("x", 7) - tag("y", 2) - tag("z", 1) < 5 == ok("w", true));
    print(ok("s", true) || tag("t", 1) / 0 == 0);
    ~/haat $ python haat.py run predict.haat
    a
    b
    c
    14
    p
    r
    true
    x
    y
    z
    w
    true
    s
    true

    সত্যিকারের run (vm-এও হুবহু এক)। লাইন ৩: গাছ (+ a (* b c)), কিন্তু ক্রম a, b, c; মান 2 + 12 = 14. লাইন ৪: && বেশি জোরে বাঁধে, তাই (or (and p q) r). p false, তাই q বাদ (And-F); তারপর or-এর বাঁ পাশ false, তাই r চলে, true. লাইন ৫: (== (< (- (- x y) z) 5) w): বিয়োগ বাঁ-সংযোগী, 7 − 2 − 1 = 4 < 5 true; দুই তুলনা ভিন্ন স্তরে, তাই বৈধ; w চলে, true == true. লাইন ৬: s true, তাই ডান পাশের পুরোটা, শূন্য দিয়ে ভাগ-সহ, কখনো চলে না; “t” ছাপা হয় না, কোনো error নেই। Type checker তবু ডান পাশ পরীক্ষা করেছে: short-circuit একটি dynamic নিয়ম, static নয়।

  4. Trace — এক লেখা, চার ভাষা: শুরুতে i = 1, j = 1, m = 0, arr = {7, 7, 7}. তিনটি লেখা: (১) a = i++ + i++ (২) j = j++ + 1 (৩) arr[m] = m++. JavaScript, C17 আর C++17-এ প্রতিটির পরে a, i, j, arr আর m কী? Java-তে কী হবে বলে আশা করেন?
    লেখাJavaScript (Node 24, run)C17C++17 (Clang 22.1.8, run)
    (১) a = i++ + i++a = 3, i = 3UBUB
    (২) j = j++ + 1j = 2UBj = 2
    (৩) arr[m] = m++arr = 0 7 7, m = 1UBarr = 7 0 7, m = 1

    JavaScript: বাঁ থেকে ডানে। (১) প্রথম i++ 1 দেয়, i = 2; দ্বিতীয় 2 দেয়, i = 3; a = 3. (২) j++ 1 দেয় (j সাময়িক 2), তারপর 1 + 1 = 2 বসে, তাই j = 2. (৩) বাঁ পাশ আগে: লক্ষ্য arr[0] ঠিক হয়ে যায়, তারপর m++ 0 দেয় আর m = 1; তাই arr[0] = 0. C++17: assignment-এ ডান পাশ আগে sequenced: (২) একই 2; কিন্তু (৩)-এ m++ আগে চলে, m = 1, তারপর লক্ষ্য arr[1], তাই 7 0 7. (১) C++17-এও unsequenced, তাই UB. Clang C17-এ তিনটি লেখাতেই -Wunsequenced সতর্কবার্তা দেয়, আর C++14 মোডে (২) আর (৩)-এও দেয়। C17: তিনটিই একই object-এ unsequenced বদল বা পড়া-লেখা, তাই কোনো উত্তর নেই। Java: JLS §15.7 বাঁ-থেকে-ডান আর §15.26.1-এর array assignment-এর নিয়ম অনুযায়ী ফল JavaScript-এর মতো হওয়ার কথা (a = 3, j = 2, arr = 0 7 7); এখানে Java চালানো হয়নি, তাই এটি spec থেকে অনুমান, run নয়। শিক্ষা: একই লেখার তিনটি আলাদা “সঠিক” উত্তর, আর একটিতে কোনো উত্তরই নেই।

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

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

ক্রমHaat-এ pick একটি function ফেরত দেয় যা a - b হিসাব করে, আর tag(s, v) s ছেপে v ফেরত দেয়। print(pick()(tag("arg1", 9), tag("arg2", 4))); চলার সময় ঘটনাগুলো সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. pick() চলে আর callee হিসেবে একটি function-মান দেয়
  2. tag("arg1", 9) চলে আর arg1 ছাপে
  3. tag("arg2", 4) চলে আর arg2 ছাপে
  4. ফেরত পাওয়া function 9 আর 4 নিয়ে 9 − 4 হিসাব করে
  5. print 5 ছাপে

Haat-এ print(10 - 4 - 3); কী ছাপে, আর কেন?

  • 9, কারণ ডান দিক থেকে জোড়া লাগে
  • 3, কারণ - বাঁ-সংযোগী: (10 - 4) - 3
  • Syntax error, কারণ - non-associative
  • ফল unspecified, back end-ভেদে আলাদা

C17-এ int i = 1; int a = i++ + i++;-এর পরে a-এর মান কত?

  • 3
  • 2
  • 2 বা 3, compiler যেটি বেছে নেয়
  • কোনো নির্দিষ্ট মান নেই: undefined behavior

Python 3.14-এ t("obj", order)["qty"][t("idx", 1)] = t("val", 7) চালালে, যেখানে t নিজের নাম একটি তালিকায় লিখে মান ফেরত দেয়, তালিকায় ক্রম কী হবে?

  • val obj idx
  • obj idx val
  • idx obj val
  • ক্রম নির্দিষ্ট নয়, প্রতি run-এ আলাদা হতে পারে

Haat-এ fn free(vip: Bool, total: Int) -> Bool { return vip || big(total); }, আর big “big checked” ছাপে। print(free(true, 500)); চালালে কী হয়?

  • big checked, তারপর true
  • big checked, তারপর false
  • শুধু true; big ডাকাই হয় না
  • Type error

একটি Pratt parser-এ loop-এর শর্ত lbp(next) >= min_bp. একটি operator-কে ডান-সংযোগী (যেমন Python-এর **) করতে তার ডান operand কোন সীমায় পড়তে হবে?

  • min_bp = lbp + 1
  • min_bp = lbp
  • min_bp = 0
  • min_bp = 70, prefix-এর মতো

CPython 3.14-এর compiler qty + 2 + 30-এর bytecode-এ 2 আর 30-কে 32-এ fold করে না। সবচেয়ে সঠিক কারণ কোনটি?

  • CPython কোনো constant folding করে না
  • 30 খুব বড় সংখ্যা
  • qty-এর মান compile-এর সময় জানা নেই, তাই কিছুই fold করা যায় না
  • গাছটি (qty + 2) + 30, আর গাছ নতুন করে সাজানো নিরাপদ নয়

শব্দকোষ

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

মনে রাখুন

  1. তিন স্তর: গঠন (precedence, associativity; parser), ক্রম (কোন operand আগে; semantics), প্রভাব (side effect). Precedence কখনো evaluation order বলে না।
  2. Pratt loop: while lbp(next) >= min_bp; ডান পাশ lbp + 1 সীমায় পড়লে বাঁ-সংযোগ, lbp সীমায় ডান-সংযোগ। Haat-এর তুলনা non-associative: 1 < 2 < 3 syntax error.
  3. Order ভাষাভেদে: Haat, Java, JavaScript বাঁ থেকে ডানে; Python-এ assignment-এর ডান পাশ আগে; C-তে unspecified, আর একই object-এ unsequenced বদল UB (i++ + i++); C++17 কিছু ক্রম বেঁধেছে।
  4. Short-circuit আর conditional: একটি অংশ ইচ্ছা করে বাদ; bytecode-এ JUMP_IF_FALSE আর JUMP. Python/JS operand ফেরত দেয়, Haat শুধু Bool.
  5. Desugaring আর folding: x op= e-এ বাঁ পাশ একবার; Haat-এ assignment statement. Constant folding চলার সময়ের অর্থ হুবহু রাখে: wrap, শূন্য দিয়ে ভাগ, floating-point আর side effect মেনে।

পরের পর্বে: expression থেকে statement-এর দিকে। পর্ব ২৭-এ (Control flow) দেখবেন selection আর iteration-এর নকশা, dangling else, switch কখন jump table হয়, আর Haat-এর while কীভাবে JUMP_IF_FALSE আর JUMP-এ নামে: এই পর্বের short-circuit-এর jump-এরই বড় রূপ।

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

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