এক্সপ্রেশন ও ইভালুয়েশন অর্ডার

১ · এক্সপ্রেশন বনাম স্টেটমেন্ট

একটি এক্সপ্রেশনExpressionএমন একটি কোড-খণ্ড যা ইভালুয়েট হয়ে একটি ভ্যালু প্রোডিউস করে — যেমন 3 + 4 — এবং সাধারণত একটি বড় এক্সপ্রেশনের ভেতরে নেস্ট করা যায়। ইভালুয়েট হয়ে একটি ভ্যালু প্রোডিউস করে (যেমন 3 + 4)। একটি স্টেটমেন্টStatementএমন একটি কোড-খণ্ড যা একটি অ্যাকশন/এফেক্ট ঘটায় কিন্তু নিজে ব্যবহারযোগ্য কোনো ভ্যালু দেয় না — বেশিরভাগ ইম্পারেটিভ ভাষায় assignment বা loop এর উদাহরণ। একটি অ্যাকশন/এফেক্ট ঘটায় কিন্তু নিজে ব্যবহারযোগ্য কোনো ভ্যালু দেয় না (বেশিরভাগ ইম্পারেটিভ ভাষায় একটি অ্যাসাইনমেন্ট বা একটি লুপ)। কিছু ভাষা — বিশেষত ফাংশনাল-ঝোঁকের ভাষা, M2/L08-এর সরাসরি সম্প্রসারণ — এই সীমারেখা ঝাপসা করে দিয়ে সবকিছুকেই এক্সপ্রেশন বানিয়ে দেয়। এটি একটি genuine, বাস্তব ভাষা-ডিজাইন সিদ্ধান্ত যার পরিণতি আছে composability-তে — একটি এক্সপ্রেশন একটি বড় এক্সপ্রেশনের ভেতরে নেস্ট করা যায়, কিন্তু একটি খাঁটি স্টেটমেন্ট সাধারণত পারে না।

২ · প্রিসিডেন্স ও অ্যাসোসিয়েটিভিটি

প্রিসিডেন্স ঠিক করে একাধিক অপারেটর প্যারেন্থিসিস ছাড়া একসাথে থাকলে কোনটি "বেশি শক্ত করে বাঁধে" (M3/L14-এর 2+3*4 উদাহরণের সরাসরি reuse — গুণ যোগের চেয়ে শক্ত করে বাঁধে বলেই ফলাফল 14, 20 নয়)। অ্যাসোসিয়েটিভিটি ঠিক করে একই-প্রিসিডেন্সের অপারেটর বারবার এলে কীভাবে গ্রুপ হয় — যেমন 10 - 3 - 2 কি (10-3)-2=5 (লেফট-অ্যাসোসিয়েটিভ, বিয়োগের জন্য প্রায়-সার্বজনীন বাস্তব-জগতের কনভেনশন) নাকি 10-(3-2)=9 (রাইট-অ্যাসোসিয়েটিভ)?

$$10 - 3 - 2 \;=\; (10 - 3) - 2 \;=\; 5 \quad \text{(লেফট-অ্যাসোসিয়েটিভ, প্রায় সব ভাষায় স্ট্যান্ডার্ড)}$$

৩ · অপারেন্ড ইভালুয়েশন অর্ডার — একটি স্বতন্ত্র প্রশ্ন

প্রিসিডেন্স ও অ্যাসোসিয়েটিভিটি ঠিক করে এক্সপ্রেশনটি কীভাবে গ্রুপ হবে — কিন্তু একটি সম্পূর্ণ ভিন্ন, প্রায়ই-উপেক্ষিত প্রশ্ন থেকে যায়: f() + g() ইভালুয়েট করার সময়, f() নাকি g() আগে কল হয়? বেশিরভাগ ভাষা একটি নির্দিষ্ট (deterministic) অর্ডার ফিক্স করে — সাধারণত বাম-থেকে-ডান — কিন্তু যদি f() ও g()-এর সাইড-এফেক্ট থাকে (যেমন কিছু প্রিন্ট করা, বা শেয়ার্ড স্টেট পরিবর্তন করা), তাহলে ইভালুয়েশন অর্ডার সত্যিকারের observable আউটপুট/আচরণ বদলে দেয় — শুধু একটি internal ইমপ্লিমেন্টেশন খুঁটিনাটি নয়, বরং একটি real, মাঝেমধ্যে বিস্ময়কর bug-এর উৎস, যদি একটি ভাষার ইভালুয়েশন অর্ডার ঠিকমতো বোঝা না থাকে।

৪ · কোড: একই মান, ভিন্ন সাইড-এফেক্ট লগ

নিচের কোড সেলে আমরা একটি ছোট এক্সপ্রেশন গাছ বানাব — (a * b) + c — যার প্রতিটি লিফ নোডে একটি সাইড-এফেক্ট আছে (একটি শেয়ার্ড লগ লিস্টে নিজের নাম যোগ করা, তারপর তার ভ্যালু রিটার্ন করা)। এরপর দুটো আলাদা ট্রি-ইভালুয়েটর চালাব — একটি সবসময় প্রতিটি অপারেটরের বাম অপারেন্ড আগে ইভালুয়েট করে, আরেকটি সবসময় ডান অপারেন্ড আগে — এবং দেখব চূড়ান্ত মান অভিন্ন থাকলেও লগের ক্রম সম্পূর্ণ ভিন্ন হয়ে যায়।

# এক্সপ্রেশন গাছ (নেস্টেড টাপল) -- (a * b) + c
# leaf নোড: ("leaf", নাম, ভ্যালু)
# অপারেটর নোড: (অপারেটর, বাম-সাবট্রি, ডান-সাবট্রি)

def leaf(name, value):
    return ("leaf", name, value)

expr_tree = ("+", ("*", leaf("a", 2), leaf("b", 3)), leaf("c", 4))
# আশানুরূপ মান: (2 * 3) + 4 = 10


def apply_op(op, left_value, right_value):
    if op == "+":
        return left_value + right_value
    if op == "*":
        return left_value * right_value
    raise ValueError(f"অজানা অপারেটর: {op!r}")


def evaluate_left_to_right(node, log):
    if node[0] == "leaf":
        _, name, value = node
        log.append(name)  # -- সাইড এফেক্ট: এই লিফটি কখন ইভালুয়েট হলো তা লগ করা
        return value
    op, left, right = node
    left_value = evaluate_left_to_right(left, log)   # বাম আগে
    right_value = evaluate_left_to_right(right, log)  # ডান পরে
    return apply_op(op, left_value, right_value)


def evaluate_right_to_left(node, log):
    if node[0] == "leaf":
        _, name, value = node
        log.append(name)
        return value
    op, left, right = node
    right_value = evaluate_right_to_left(right, log)  # ডান আগে
    left_value = evaluate_right_to_left(left, log)     # বাম পরে
    return apply_op(op, left_value, right_value)


log_ltr = []
value_ltr = evaluate_left_to_right(expr_tree, log_ltr)

log_rtl = []
value_rtl = evaluate_right_to_left(expr_tree, log_rtl)

print(f"বাম-থেকে-ডান  -> চূড়ান্ত মান = {value_ltr}, সাইড-এফেক্ট লগ = {log_ltr}")
print(f"ডান-থেকে-বাম  -> চূড়ান্ত মান = {value_rtl}, সাইড-এফেক্ট লগ = {log_rtl}")

assert value_ltr == value_rtl == 10, "চূড়ান্ত গণনাকৃত মান অর্ডার নির্বিশেষে অভিন্ন থাকার কথা"
assert log_ltr == ["a", "b", "c"], "বাম-থেকে-ডান ইভালুয়েশনে a, তারপর b, তারপর c লগ হওয়ার কথা"
assert log_rtl == ["c", "b", "a"], "ডান-থেকে-বাম ইভালুয়েশনে c, তারপর b, তারপর a লগ হওয়ার কথা"
assert log_ltr != log_rtl, "একই মান হলেও লগের ক্রম ভিন্ন হওয়ার কথা"

print("\nযাচাই সফল -- চূড়ান্ত মান অভিন্ন (10), কিন্তু সাইড-এফেক্ট লগের ক্রম genuinely ভিন্ন।")