Type System — static, dynamic, strong, weak আসলে কী গ্যারান্টি দেয়

লক্ষ্য: Python দিয়ে dynamic typing-এর engine বানানো — যাতে দেখা যায় “dynamic” মানে কোনো absence না, একটা সুনির্দিষ্ট mechanical protocol।

class DynTypeError(TypeError):
    pass

class Tagged:
    """একটা runtime value — tag + payload। CPython-এর PyLongObject-
    এর শিক্ষামূলক নকল।"""
    __slots__ = ('tag', 'payload')

    def __init__(self, tag, payload):
        self.tag = tag
        self.payload = payload

    def __repr__(self):
        return f"[{self.tag}: {self.payload!r}]"

def t_int(n):   return Tagged('int', n)
def t_bool(b):  return Tagged('bool', b)
def t_str(s):   return Tagged('str', s)

WEAK = False          # True = JS-মোড, False = Python-মোড
CHECKS = 0            # কতবার tag পড়লাম — dynamic-এর runtime বিল

def note_check():
    global CHECKS
    CHECKS += 1

def t_add(a, b):
    note_check()
    if a.tag == 'int' and b.tag == 'int':
        return t_int(a.payload + b.payload)
    if a.tag == 'str' and b.tag == 'str':
        return t_str(a.payload + b.payload)
    if WEAK:                                   # JS-মোড: নীরবে string-এ ফেলে দাও
        def flat(v):
            return v.payload if v.tag == 'str' else repr(v.payload)
        return t_str(flat(a) + flat(b))
    raise DynTypeError(
        f"cannot add {a.tag} and {b.tag}")     # Python-মোড: চিৎকার

def t_eq(a, b):
    note_check()
    return t_bool(False) if a.tag != b.tag \
        else t_bool(a.payload == b.payload)

def t_if(cond, then_v, else_v):
    """আমাদের mini-language-এ condition হতেই হবে bool — Python-এর
    truthiness এখানে নেই (লক্ষ্য করুন: dynamic ≠ permissive)"""
    note_check()
    if cond.tag != 'bool':
        raise DynTypeError(f"condition must be bool, got {cond.tag}")
    return then_v if cond.payload else else_v

# ── Demo ─────────────────────────────────────────────────────
n1, n2 = t_int(40), t_int(2)
print(t_add(n1, n2))                 # [int: 42]

try:
    t_add(t_str("5"), t_int(5))
except DynTypeError as e:
    print("strong মোড:", e)          # চিৎকার

WEAK = True
print(t_add(t_str("5"), t_int(5)))   # [str: '55'] — JS-এর জগৎ
WEAK = False

try:
    t_if(t_int(1), t_str("yes"), t_str("no"))
except DynTypeError as e:
    print("strict condition:", e)    # 1 truthy হওয়া সত্ত্বেও — ট্যাগ-ই সব

# বিল-মাপা: ১০০০ বার add — প্রতিটায় কয়টা check?
start_checks = CHECKS
acc = t_int(0)
for _ in range(1000):
    acc = t_add(acc, t_int(1))
print(f"{CHECKS - start_checks} tag-checks "
      f"for 1000 additions ({(CHECKS - start_checks) / 10:.0f}% overhead)")

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

[int: 42]
strong মোড: cannot add str and int
[str: '55']
strict condition: condition must be bool, got int
1000 tag-checks for 1000 additions (100% overhead)

তিনটা সিদ্ধান্ত নোট করুন:

1. WEAK flag-ই পুরো strong/weak axis — একই interpreter, এক boolean পালটালেই JS হয়ে যায়। Weak typing কোনো ক্ষমতার ব্যাপার না (দুই মোডেই সব কাজ সম্ভব), policy-র ব্যাপার।
2. প্রতিটা operation-এ অন্তত এক tag-read — 100% overhead মাপা গেল। এটাই hood section-এর C-vs-Python diagram-এর সংখ্যাগত রূপ।
3. t_if-এর strictness ইচ্ছাকৃত — dynamic ভাষা মানেই সব জায়গায় উদার না; কোন ট্যাগ কোথায় বাধ্য তা প্রতিটা ভাষার নিজস্ব সিদ্ধান্ত।

নিজে বাড়ান:

1. t_mul আর t_len যোগ করুন (t_len শুধু str-এ চলবে)।
2. Small-int cache নকল করুন: −5..256 range-এর t_int-এর জন্য shared instance ফেরত দিন — তারপর t_eq(t_int(5), t_int(5)).payload আর id()-ভিত্তিক তুলনার পার্থক্য দেখুন। CPython-এর interned ints-এর রহস্য খুলে যাবে।
3. চ্যালেঞ্জ: word-tagging মোড যোগ করুন — payload ৬১-bit হিসেবে রেখে top-3 bit tag (Erlang-এর মতো)। ছোট int-এ কোনো box-allocation লাগে না — মেমরি-খরচের পার্থক্য মেপে দেখুন।