Syntax বনাম Semantics — লেখা, অর্থ, আর ভুল হওয়ার তিনটা সময়

লক্ষ্য: syntax আর AST একবারও না ছুঁয়ে শুধু semantic rule বদলে একই প্রোগ্রামের উত্তর বদলে ফেলা — অর্থ আসে rule থেকে, লেখা থেকে নয়, হাতে-কলমে প্রমাণ।

import re
import math
from dataclasses import dataclass
from operator import add, sub, mul, truediv, floordiv

# ── ধাপ ১: tokenizer — লেখা → token (lexical structure) ──────
TOKEN_RE = re.compile(r"\d+(?:\.\d+)?|[A-Za-z_]\w*|\*\*|[+\-*/%()]")

def tokenize(text):
    return TOKEN_RE.findall(text)

# ── AST nodes ────────────────────────────────────────────────
@dataclass
class Num:
    value: float

@dataclass
class Var:
    name: str

@dataclass
class BinOp:
    op: str
    left: object
    right: object

# ── ধাপ ২: recursive-descent parser — token → AST ────────────
# Grammar (syntax!):
#   expr   := term (('+'|'-') term)*
#   term   := factor (('*'|'/'|'%') factor)*
#   factor := '-' factor | power
#   power  := atom ('**' factor)?
#   atom   := NUMBER | NAME | '(' expr ')'

class Parser:
    def __init__(self, tokens):
        self.toks = tokens
        self.i = 0

    def peek(self):
        return self.toks[self.i] if self.i < len(self.toks) else None

    def eat(self):
        tok = self.peek()
        self.i += 1
        return tok

    def expr(self):
        node = self.term()
        while self.peek() in ('+', '-'):
            node = BinOp(self.eat(), node, self.term())
        return node

    def term(self):
        node = self.factor()
        while self.peek() in ('*', '/', '%'):
            node = BinOp(self.eat(), node, self.factor())
        return node

    def factor(self):
        if self.peek() == '-':
            self.eat()
            return BinOp('-', Num(0), self.factor())   # unary minus = desugar
        return self.power()

    def power(self):
        node = self.atom()
        if self.peek() == '**':
            return BinOp(self.eat(), node, self.factor())  # right-assoc
        return node

    def atom(self):
        tok = self.eat()
        if tok == '(':
            node = self.expr()
            assert self.eat() == ')'
            return node
        if tok.replace('.', '', 1).isdigit():
            return Num(float(tok))
        return Var(tok)

def parse(text):
    p = Parser(tokenize(text))
    node = p.expr()
    assert p.peek() is None, f"অবশিষ্ট token: {p.peek()} — parse error"
    return node

# ── ধাপ ৩: evaluator — rule-dictionary প্যারামিটার নেয় ───────
def evaluate(node, env, rules):
    if isinstance(node, Num):
        return node.value
    if isinstance(node, Var):
        if node.name not in env:
            raise NameError(f"unbound variable: {node.name}")
        return env[node.name]
    if isinstance(node, BinOp):
        lv = evaluate(node.left, env, rules)    # লক্ষ্য: evaluation
        rv = evaluate(node.right, env, rules)   # order নিজেও একটা
        return rules[node.op](lv, rv)           # semantic সিদ্ধান্ত!
    raise TypeError(f"unknown node: {node!r}")

# ── ধাপ ৪: তিনটা semantic rule-set — syntax এক, অর্থ তিন ─────
RULES_TRUE_DIV = {'+': add, '-': sub, '*': mul, '/': truediv}

RULES_FLOOR = {'+': add, '-': sub, '*': mul,
               '/': floordiv,                          # নিচের পূর্ণসংখ্যায়
               '%': lambda a, b: a - floordiv(a, b) * b}

RULES_C_TRUNC = {'+': add, '-': sub, '*': mul,
                 '/': lambda a, b: float(math.trunc(a / b)),  # C: শূন্যর দিকে
                 '%': lambda a, b: a - math.trunc(a / b) * b}  # remainder-এর sign = dividend

# ── ধাপ ৫: একই লেখা, তিন ভাগ্য ───────────────────────────────
env = {'price': 100.0, 'qty': 3.0, 'total': 7.0}

for expr_text in ["price * qty / total", "-7 / 2"]:
    ast = parse(expr_text)          # ← একবারই parse — একই AST
    print(f"{expr_text:>22}")
    for name, rules in [("true-div ", RULES_TRUE_DIV),
                        ("floor-div", RULES_FLOOR),
                        ("C-trunc  ", RULES_C_TRUNC)]:
        print(f"    {name}: {evaluate(ast, env, rules)}")

প্রত্যাশিত output:

   price * qty / total
    true-div : 42.857142857142854
    floor-div: 42.0
    C-trunc  : 42.0
              -7 / 2
    true-div : -3.5
    floor-div: -4.0
    C-trunc  : -3.0

-7 / 2-এর তিনটা উত্তর দেখুন — -3.5, -4, -3। Tokenizer একবার চলেছে, parser একবার, AST-এর প্রতিটা node একবারই তৈরি — বদলেছে শুধু / চিহ্নের পেছনের function। আপনি নিজের হাতে দেখলেন: C আর Python একই লেখা পেয়ে ভিন্ন উত্তর দেয়, কারণ rule-book আলাদা — আর সেই rule-book-ই semantics।

নিজে বাড়ান:

1. চতুর্থ rule-set যোগ করুন — saturating arithmetic (audio DSP-তে ব্যবহৃত): ফল 0–255-এর বাইরে গেলে সীমায় আটকায়। 200 + 100 কী দেয় দেখুন — overflow-ও একটা semantic সিদ্ধান্ত।
2. evaluate-এ counter বসিয়ে মাপুন প্রতিটা rule-check কতবার চলে — dynamic checking-এর runtime খরচের প্রথম স্বাদ (লেসন ৩-এর মূল বিষয়)।
3. চ্যালেঞ্জ: evaluate-কে right-to-left operand evaluation করান — pure expression-এ ফল বদলাবে না (কেন?), কিন্তু Var lookup-এ log বসালে ক্রমের পার্থক্য দেখা যাবে। Side effect থাকলে evaluation order নিজেই semantics — পরের লেসনের formal rules-এ এটা স্পষ্ট হবে।