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

Type system — static, dynamic, strong আর weak typing

Type Systems — Static, Dynamic, Strong and Weak Typing

Taught in Bangla, this lesson defines a type system as a proof that certain errors cannot happen and separates type errors from other bugs. It covers trapped and untrapped errors and safe languages, static versus dynamic checking with a real tsc run against JavaScript, replaces the vague strong/weak label with three questions applied to six languages, contrasts explicit and inferred, nominal and structural typing, and runs a tiny type checker in in-page Python (Pyodide) to show soundness versus completeness.

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

  • Type system-এর একটি নির্ভুল সংজ্ঞা, আর type error-কে অন্য ভুল (syntax, নাম, runtime, যুক্তি) থেকে আলাদা করা
  • Static আর dynamic যাচাই, trapped আর untrapped ভুল, আর “safe language”-এর অর্থ
  • Strong/weak, explicit/inferred, nominal/structural — তিনটি আলাদা অক্ষে ছয়টি ভাষাকে প্রমাণসহ বসানো
  • Soundness আর completeness-এর পার্থক্য, আর কেন প্রতিটি ব্যবহারযোগ্য type checker রক্ষণশীল
  • Python-এ ৩৫ লাইনের একটি type checker চালানো, আর type system-এর লাভ-ক্ষতির বিতর্কে প্রমাণ কোথায় দাঁড়িয়ে তা জানা

১ · Type system কী — “এই ভুলটি ঘটবে না”-র প্রমাণ

ঢাকার মেট্রো রেলে ঢুকতে হলে আগে গেটে কার্ড ছোঁয়াতে হয়। গেট আপনার যাত্রা দেখে না, কোথায় নামবেন তাও জানে না; শুধু একটি সহজ প্রশ্নের উত্তর খোঁজে: “এই কার্ডে কি ঢোকার অনুমতি আছে?” উত্তর না হলে ট্রেনে ওঠার আগেই আপনাকে থামানো হয়। বাসে নিয়মটি আলাদা: কন্ডাক্টর ভাড়া চান চলতি পথে, আর ভাড়া না পেলে সেখানেই নামিয়ে দেন। আর কোনো কোনো লোকাল বাসে কেউ কিছুই জিজ্ঞেস করে না; ভুল টিকিট নিয়ে যাত্রী দিব্যি গন্তব্যে পৌঁছে যান, ভুলটি কেউ টেরই পায় না।

প্রোগ্রামিং ভাষার type system ঠিক এই তিন রকম পাহারার গল্প। মেট্রোর গেট হলো static typing: চালানোর আগেই যাচাই। কন্ডাক্টর হলো dynamic typing: চলার সময় যাচাই। আর পাহারাহীন বাস হলো এমন ভাষা, যেখানে কিছু ভুল কোনো সময়ই ধরা পড়ে না। এই পর্বে প্রথমে সংজ্ঞাটি নির্ভুল করব, তারপর প্রতিটি ধারণা সত্যিকারের compiler আর interpreter-এ চালিয়ে দেখব।

সংজ্ঞা ৩৩.১ — Type system

Benjamin Pierce তাঁর Types and Programming Languages (২০০২) বইয়ে যে সংজ্ঞা দিয়েছেন, তা আজ সবচেয়ে বেশি উদ্ধৃত: “A type system is a tractable syntactic method for proving the absence of certain program behaviors by classifying phrases according to the kinds of values they compute.” বাংলায়: type system হলো একটি সহজে চালানো যায় এমন (tractable), লেখা দেখে কাজ করা (syntactic) পদ্ধতি, যা program-এর প্রতিটি অংশকে সে কোন ধরনের মান তৈরি করবে সেই অনুযায়ী শ্রেণিতে ভাগ করে, আর এর মাধ্যমে প্রমাণ করে যে কিছু নির্দিষ্ট আচরণ কখনো ঘটবে না।

সংজ্ঞার প্রতিটি শব্দ কাজের। Tractable মানে যাচাই দ্রুত শেষ হয়, সাধারণত program-এর আকারের প্রায় সমানুপাতিক সময়ে; compiler একটি ফাইল দেখে ঘণ্টার পর ঘণ্টা ভাবতে পারে না। Syntactic মানে checker program-এর লেখা (আসলে AST) দেখে কাজ করে, চালিয়ে নয়; তাই ভুলটি যে লাইনে আছে সে লাইন কোনো test কখনো না ছুঁলেও ধরা পড়ে। Proving absence মানে এটি একটি নিশ্চয়তা, অনুমান নয়: “এই program-এ Int-এর সঙ্গে Bool যোগ কখনো ঘটবে না।” আর certain behaviors শব্দ দুটি সবচেয়ে গুরুত্বপূর্ণ: কোন ভুলগুলো বাদ দেওয়ার প্রতিশ্রুতি, তা ভাষার নকশাকার ঠিক করেন। Haat-এর type system প্রতিশ্রুতি দেয় যে কোনো operator ভুল ধরনের মান পাবে না; কিন্তু শূন্য দিয়ে ভাগের কোনো প্রতিশ্রুতি দেয় না।

Checker কীভাবে কাজ করে, তা লেখা হয় typing judgment দিয়ে: Γ ⊢ e : τ. পড়ুন “Γ জানা থাকলে expression e-এর type τ”। এখানে Γ (গামা) হলো নাম থেকে type-এর একটি তালিকা, যেমন total : Int, member : Bool; ⊢ চিহ্নটির অর্থ “প্রমাণ করা যায়”; আর τ (টাউ) যেকোনো একটি type. খেয়াল করুন, Γ-তে মান নেই, শুধু type. Checker জানে total একটি Int, কিন্তু জানে না সেটি 1040 না 540. Typing rule-গুলো inference rule আকারে লেখা হয়; পর্ব ২০-এ T-Int, T-Bool আর T-Eq দেখেছেন, আর পর্ব ১২-এ T-Add. যোগের নিয়মটি আরেকবার:

Γ ⊢ e1 : Int    Γ ⊢ e2 : Int
Γ ⊢ e1 + e2 : Int
(T-Add)
(x : τ) ∈ Γ
Γ ⊢ x : τ
(T-Var)

T-Add বলে: দুই পাশ Int প্রমাণ করা গেলে যোগফলও Int. কোনো নিয়মে 1 + true-এর type প্রমাণ করা যায় না, তাই checker program-টি বাতিল করে। নিয়মগুলোর পূর্ণ গণিত, derivation tree আর প্রমাণ আসবে পর্ব ৩৪-এ (Typing rule আর type judgment). এখানে নিয়মগুলোকে কোডে নামিয়ে দেখি: একটি ছোট expression ভাষা (Haat নয়; এতে if একটি expression), যার checker মাত্র কয়েকটি নিয়ম জানে।

# A tiny expression language (not Haat): Int, Bool, +, <, &&, if-expression
def check(e, env):
    kind = e[0]
    if kind == "num": return "Int"                       # T-Int
    if kind == "bool": return "Bool"                     # T-Bool
    if kind == "var":                                    # T-Var
        if e[1] not in env: raise TypeError(f"undefined variable '{e[1]}'")
        return env[e[1]]
    if kind in ("+", "<", "&&"):                         # T-Add, T-Lt, T-And
        need = "Bool" if kind == "&&" else "Int"
        for side in (e[1], e[2]):
            t = check(side, env)
            if t != need:
                raise TypeError(f"type mismatch: expected {need}, found {t}")
        return "Int" if kind == "+" else "Bool"
    if kind == "if":                                     # T-If
        if check(e[1], env) != "Bool": raise TypeError("condition must be Bool")
        t1, t2 = check(e[2], env), check(e[3], env)
        if t1 != t2:
            raise TypeError(f"branches differ: {t1} vs {t2}")
        return t1

env = {"total": "Int", "member": "Bool"}     # Γ: only types, no values
V, N, B = (lambda x: ("var", x)), (lambda n: ("num", n)), (lambda b: ("bool", b))
tests = [
    ("total + 60",              ("+", V("total"), N(60))),
    ("1 + true",                ("+", N(1), B(True))),
    ("total < 1000 && member",  ("&&", ("<", V("total"), N(1000)), V("member"))),
    ("if member then 0 else 60",    ("if", V("member"), N(0), N(60))),
    ("if member then 0 else false", ("if", V("member"), N(0), B(False))),
    ("totl + 1",                ("+", V("totl"), N(1))),
]
for src, e in tests:
    try: print(f"{src:28} : {check(e, env)}")
    except TypeError as err: print(f"{src:28} x {err}")

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

total + 60                   : Int
1 + true                     x type mismatch: expected Int, found Bool
total < 1000 && member       : Bool
if member then 0 else 60     : Int
if member then 0 else false  x branches differ: Int vs Bool
totl + 1                     x undefined variable 'totl'

চারটি জিনিস লক্ষ করুন। এক, check কোনো কিছু হিসাব করে না; total + 60-এর উত্তর “Int”, কোনো সংখ্যা নয়। এটিই type checker আর interpreter-এর মৌলিক পার্থক্য: একটি মানের শ্রেণি দেখে, অন্যটি মান নিজে। দুই, প্রতিটি if kind == … শাখা একটি typing rule; comment-এ নামগুলো লেখা আছে। এটিকে বলে syntax-directed checking: AST-এর প্রতিটি node-এর জন্য ঠিক একটি নিয়ম। তিন, 1 + true-এর বার্তা Haat reference-এর বার্তার ধাঁচে: expected Int, found Bool. চার, শেষ লাইনটি type error নয়, নামের ভুল: totl Γ-তে নেই। বাস্তব compiler-এ এটি ধরে name resolution-এর ধাপ (পর্ব ৫১), type checking-এর আগে; এখানে সরলতার জন্য একই function-এ রাখা হয়েছে।

২ · কোন ভুল type error — trapped আর untrapped

বাজারঘরের অর্ডার-program-এ নানা রকম ভুল হতে পারে, আর প্রতিটি ধরা পড়ে আলাদা ধাপে। Type error তাদের একটি মাত্র শ্রেণি: কোনো operation এমন মান পেল, যার ধরনের জন্য operation-টি সংজ্ঞায়িতই নয়। Haat reference বাস্তবায়নে (python haat.py check আর run) সত্যিকারের run থেকে নেওয়া উদাহরণ:

ভুলের ধরনHaat উদাহরণকে, কখন ধরে (আসল বার্তা)
Syntax errorlet x = 5 (; নেই)Parser, চালানোর আগে: expected ';' after variable declaration
নামের ভুলprint(totl);Resolver, চালানোর আগে: undefined variable 'totl'
Type errorprint(total + true);Type checker, চালানোর আগে: 2:15: error: type mismatch: expected Int, found Bool
Runtime errorper_item(1040, 0), ভেতরে total / qtycheck বলে ok; চলার সময়: 2:18: runtime error: division by zero
যুক্তির ভুল৫% ছাড়ের বদলে ৫০% ছাড়কেউ না; শুধু test আর মানুষের চোখ

চতুর্থ সারিটি বিশেষ করে দেখুন। per_item function-এর type (Int, Int) -> Int একদম ঠিক; type checker আপত্তি করেনি, আর প্রথম call 520 ছাপল। শূন্য দিয়ে ভাগ type-এর প্রশ্নই নয়, কারণ 0 একটি বৈধ Int. Haat-এর প্রতিশ্রুতির তালিকায় এটি নেই (reference-এর সিদ্ধান্ত ২৬-এ runtime error-এর তালিকা)। তাই type system-এর কাছে “program ঠিক চলবে” আশা করা ভুল; সে শুধু ঘোষিত ভুলগুলো বাদ দেয়।

Trapped আর untrapped ভুল

Luca Cardelli তাঁর বহুল-পঠিত প্রবন্ধ “Type Systems”-এ (১৯৯০-এর দশকের মাঝামাঝি, পরে সংশোধিত) চলার সময়ের ভুলকে দুই ভাগে ভাগ করেছেন। Trapped error ঘটলে হিসাব সঙ্গে সঙ্গে থেমে যায়: Python-এর TypeError, Haat-এর division by zero, Java-র ArrayIndexOutOfBoundsException. Untrapped error ঘটলে কিছুই থামে না; program ভুল মেমরি পড়ে বা লেখে আর চলতে থাকে, পরে কোথাও অদ্ভুত আচরণ দেখা দেয়, বা কখনোই দেয় না। C-তে array-র সীমার বাইরে লেখা এর সবচেয়ে চেনা উদাহরণ। Cardelli-র সংজ্ঞায় যে ভাষায় untrapped ভুল অসম্ভব, সেটি safe ভাষা; এই নিশ্চয়তাকে সাধারণভাবে বলা হয় type safety, আর মেমরির দিকটিকে memory safety.

একই বাজারঘরের ভুল, “একটি সংখ্যার সঙ্গে একটি লেখা যোগ”, পাঁচ ভাষায় সত্যিকারের run-এ (CPython 3.14.4, Node.js 24.15.0, TypeScript 5.9.2, Clang 22.1.8; Java উদাহরণ, চালানো হয়নি) কী পেল:

ভাষাযা লেখা হলোফলধরন
Haatprint(1040 + " taka");1:14: error: type mismatch: expected Int, found Strstatic, চালানোর আগে
Python 3.141040 + " taka"TypeError: unsupported operand type(s) for +: 'int' and 'str'dynamic, trapped
JavaScript1040 + " taka"1040 taka (রূপান্তর করে জোড়া)নিয়মে বৈধ, কোনো error নেই
Java 211040 + " taka""1040 taka" — string concatenation-এর নিয়ম (উদাহরণ, চালানো হয়নি)নিয়মে বৈধ
C17total + " taka"Pointer arithmetic! শুধু একটি warning; ফল একটি অবৈধ pointeruntrapped (undefined behavior)

C-র সারিটি এই পর্বের সবচেয়ে শিক্ষণীয় উদাহরণ। C-তে string literal আসলে একটি char array, যা expression-এ প্রথম অক্ষরের pointer হয়ে যায়; pointer-এর সঙ্গে int যোগ মানে “এতগুলো ঘর সামনে যাও”। ১০৪০ ঘর সামনে মানে ৬ অক্ষরের string-এর অনেক বাইরে; এমন pointer তৈরি করাই C17-এ undefined behavior. সত্যিকারের run (Windows x64-এ zig cc -O0 -fno-sanitize=undefined -Wall -Wextra weak.c, Zig 0.17.1-এর ভেতরের Clang 22.1.8):

int total = 1040;
const char *label = total + " taka";  /* pointer arithmetic */
double price = 99.75;
int paid = price;                      /* silent truncation */
unsigned char qty = 300;               /* does not fit */

weak.c:4:31: warning: adding 'int' to a string does not append to the string [-Wstring-plus-int]
weak.c:7:25: warning: implicit conversion from 'int' to 'unsigned char' changes value from 300 to 44 [-Wconstant-conversion]
2 warnings generated.
paid = 99, qty = 44

তিনটি লাইনই C-র নিয়মে বৈধ, তাই error নেই, শুধু warning. label আমরা ইচ্ছা করেই কখনো পড়িনি ((void)label;), কারণ পড়লে কী হবে তার কোনো নিশ্চয়তা নেই। price থেকে paid-এ ৭৫ পয়সা নীরবে কেটে গেল; -Wall -Wextra-এও কোনো warning আসেনি, এল শুধু -Wconversion যোগ করলে (implicit conversion turns floating-point number into integer). আর ৩০০টি পণ্য হয়ে গেল ৪৪টি, কারণ unsigned char-এ মান 256 দিয়ে ভাগশেষ নেয় (পর্ব ২০-এর নিয়ম)। C-র type system আছে, এবং static; কিন্তু তার প্রতিশ্রুতি দুর্বল, আর ফাঁক দিয়ে untrapped ভুল ঢুকতে পারে।

৩ · কখন যাচাই — static, dynamic, আর দুটোই

Static আর dynamic typing-এর মূল আপস (নির্ভরযোগ্যতা আর tool-এর সাহায্য বনাম নমনীয়তা আর দ্রুত পরীক্ষা) পর্ব ০৬-এ দেখেছেন, আর dynamic ভাষায় type কীভাবে মানের গায়ে type tag হয়ে থাকে, তা পর্ব ১২-এ। এখানে আরও নির্ভুলভাবে বলি। Static checking program-এর লেখার ওপর একবার চলে, সব পথ একসাথে বিবেচনা করে, আর কোনো input লাগে না। Dynamic checking চলে প্রতিবার একটি operation চলার মুহূর্তে, শুধু সেই মুহূর্তের মানগুলোর ওপর। তাই dynamic checking ঠিক ততগুলো পথ দেখে, যতগুলো পথ আপনার test বা ব্যবহারকারী আসলে ছুঁয়েছেন।

অনেক ভাষা দুটোই করে। Java static type দেখে, কিন্তু downcast ((String) obj) চলার সময়ও যাচাই করে আর না মিললে ClassCastException দেয়। Haat static, তবু শূন্য দিয়ে ভাগ চলার সময় ধরে। উল্টো দিকে TypeScript একটি বিরল উদাহরণ: তার পরীক্ষা পুরোপুরি static, আর tsc JavaScript বানানোর সময় সব type মুছে ফেলে (type erasure), তাই চলার সময় কোনো TypeScript-যাচাই থাকে না। নিচের বাজারঘরের কোডে ভুলটি শুধু শুক্রবারের পথে: delivery charge ভুল করে লেখা হয়েছে "80", সংখ্যা নয়। আগে JavaScript-এ চালিয়ে দেখুন:

// বাজারঘর: delivery charge, শুক্রবারে আলাদা
function deliveryCharge(day) {
  if (day === "Fri") return "80";   // ভুল: সংখ্যার বদলে string
  return 60;
}
function receipt(total, day) {
  const sum = total + deliveryCharge(day);
  return day + ": " + sum.toFixed(2) + " taka";
}
for (const day of ["Sat", "Sun", "Mon"]) {
  console.log(receipt(936, day));
}
try {
  console.log(receipt(936, "Fri"));
} catch (e) {
  console.log(e.name + ": " + e.message);
}

আসল আউটপুট (ব্রাউজারে; লেখকের Node.js 24.15.0-তেও হুবহু এক):

Sat: 996.00 taka
Sun: 996.00 taka
Mon: 996.00 taka
TypeError: sum.toFixed is not a function

তিনটি “test” পাস করল। শুক্রবারে প্রথমে কোনো error হয়নি: 936 + "80" JavaScript-এর নিয়মে string জোড়া, ফল "93680". Error এল এক লাইন পরে, যখন একটি string-এর ওপর সংখ্যার method toFixed ডাকা হলো। অর্থাৎ ভুলের কারণ এক জায়গায়, ভুলের বার্তা আরেক জায়গায়। এবার একই কোড TypeScript-এ, শুধু type লিখে।

সত্যিকারের run: TypeScript 5.9.2 (Apache-2.0 licence; tsc-এ কোনো telemetry নেই), tsc --noEmit --strict --target es2022. প্রথম সংস্করণে deliveryCharge(day: string): number, দ্বিতীয়টিতে ফেরত type লেখা হয়নি, TypeScript নিজে বের করেছে:

~/haat $ tsc --noEmit --strict --target es2022 friday.ts
friday.ts(2,22): error TS2322: Type 'string' is not assignable to type 'number'.
~/haat $ tsc --noEmit --strict --target es2022 friday2.ts
friday2.ts(6,15): error TS2365: Operator '+' cannot be applied to types 'number' and 'string | number'.

দুটিতেই ভুল ধরা পড়ল একটি লাইনও না চালিয়ে, আর কোনো শুক্রবারের test ছাড়াই। প্রথমটিতে বার্তা ঠিক কারণের লাইনে (লাইন ২, কলাম ২২: "80"), কারণ ফেরত type লেখা ছিল। দ্বিতীয়টিতে TypeScript নিজে ফেরত type বের করেছে string | number, আর ভুলটি ধরা পড়েছে ব্যবহারের জায়গায় (লাইন ৬)। লেখা type যেন একটি চুক্তি: চুক্তি থাকলে ভুল ধরা পড়ে চুক্তি-ভঙ্গের জায়গায়। পুরো গল্পটি ধাপে ধাপে:

1function deliveryCharge(day) {2  if (day === "Fri") return "80";3  return 60;4}5function receipt(total, day) {6  const sum = total + deliveryCharge(day);7  return day + ": " + sum.toFixed(2) …;8}
এই মুহূর্তে
কে দেখছে
charge
sum
  1. tsc: চালানোর আগেই। Checker সব পথ একসাথে দেখে। ঘোষণা বলছে function একটি number ফেরত দেবে, কিন্তু লাইন ২-এর পথে ফেরত যায় একটি string. কোন দিন শুক্রবার, তা জানার দরকারই নেই: পথটি থাকাই যথেষ্ট। একটি লাইনও চলেনি।
  2. node, শনিবার। Type ছাড়া JavaScript চলছে। শর্ত মিথ্যা, তাই লাইন ৩: charge 60, sum 996, আর রসিদ ঠিকঠাক। চলার সময়ের যাচাই শুধু এই পথটি দেখল, এবং কোনো সমস্যা পেল না।
  3. রবি আর সোমবার। একই পথ, একই ফল। তিনটি test পাস। একজন ডেভেলপার এখানে সন্তুষ্ট হয়ে কোড পাঠিয়ে দিতে পারেন; লাইন ২-এর ভুল পথটি কোনো test ছোঁয়নি।
  4. শুক্রবার: নীরব রূপান্তর। এবার লাইন ২ চলে, charge "80". লাইন ৬-এ 936 + "80": JavaScript-এর + একটি দিক string দেখে অন্যটিকে string বানিয়ে জোড়ে। ফল "93680", কোনো error নেই। এটি weak typing-এর চিহ্ন (অংশ ৪)।
  5. দেরিতে ধরা। লাইন ৭-এ string-এর ওপর toFixed: এবার tag-যাচাই আটকাল, TypeError. কিন্তু বার্তা লাইন ৭-এর, আর আসল ভুল লাইন ২-এ। ব্যবহারকারী রসিদ পেলেন না।
  6. দুই প্রহরীর হিসাব। Static checker কোনো run ছাড়াই কারণের লাইনটি দেখাল। Dynamic যাচাইয়ের দরকার হলো ঠিক সেই input (শুক্রবার), আর বার্তা এল উপসর্গের লাইনে। দুটিই ভুল ধরেছে; পার্থক্য কখন আর কোথায়.

TypeScript-এর error থাকা সত্ত্বেও tsc ডিফল্টে JavaScript ফাইল তৈরি করে (--noEmitOnError না দিলে)। সত্যিকারের run-এ tsc --strict --target es2022 --outDir out friday.ts error দেখিয়েও out/friday.js লিখল, আর তাতে type-এর কোনো চিহ্ন নেই: function deliveryCharge(day) { if (day === "Fri") return "80"; … }. Build-এর error উপেক্ষা করলে বা any দিয়ে চুপ করালে চলার সময় আর কোনো পাহারা থাকে না। Erasure-এর বিস্তারিত পর্ব ৩৭-এ (Generics-এর বাস্তবায়ন)।

৪ · Strong আর weak — একটি ঝাপসা শব্দ, তিনটি স্পষ্ট প্রশ্ন

“Python strongly typed নাকি weakly typed?” প্রশ্নটি ইন্টারভিউতে প্রায়ই আসে, আর উত্তর নির্ভর করে কে কোন অর্থে শব্দটি ব্যবহার করছেন। পর্ব ১২-এ এই কোর্সের কাজের সংজ্ঞা দেওয়া হয়েছে (অমিল type-এ রূপান্তর না করে error দিলে strong); কিন্তু মনে রাখুন, strong typing আর weak typing-এর কোনো সর্বসম্মত সংজ্ঞা নেই. বই আর প্রবন্ধে অন্তত তিনটি আলাদা অর্থ চলে:

  1. রূপান্তরের পরিমাণ: ভাষা কতটা নিজে থেকে implicit conversion করে। এই অর্থে JavaScript weak ("1040" - 60 = 980), Python তুলনায় strong (1040 + " taka" TypeError).
  2. Safety: untrapped ভুল সম্ভব কি না। এই অর্থে C weak (pointer cast, union দিয়ে বিট অন্যভাবে পড়া), আর Python ও JavaScript দুটিই “strong”, কারণ কোনোটিতেই সাধারণ কোডে ভুল মেমরি পড়া যায় না।
  3. Static-এর প্রতিশব্দ: কেউ কেউ “strongly typed” বলতে বোঝান “compile time-এ type দেখা হয়”। এটি সবচেয়ে বিভ্রান্তিকর ব্যবহার, কারণ C তখন strong হয়ে যায়।

তাই দক্ষ প্রোগ্রামার আর ভাষা-গবেষকেরা শব্দ দুটি এড়িয়ে তিনটি আলাদা প্রশ্ন করেন: (ক) type যাচাই কখন হয়, static না dynamic? (খ) ভাষা কতটা নীরব রূপান্তর করে? (গ) untrapped ভুল সম্ভব কি না, অর্থাৎ ভাষা safe কি না? তিনটি প্রশ্ন একে অন্যের থেকে স্বাধীন। নিচের ছবিতে প্রথম দুটি অক্ষ, আর তৃতীয়টি লাল দাগে।

ছবি ৩৩.১ — দুই অক্ষে ছয়টি ভাষা

বাঁ থেকে ডানে: যাচাই কখন; ওপর থেকে নিচে: নীরব রূপান্তর কতটা। অবস্থান লেখকের গুণগত বিচার, মাপা সংখ্যা নয়।

Six languages on two axes: static vs dynamic checking, and few vs many implicit conversions; C marked as unsafe static dynamic রূপান্তর কম রূপান্তর বেশি Haat Java TypeScript C Python JavaScript ← চালানোর আগে চলার সময় → লাল দাগ = untrapped ভুল

TypeScript-কে মাঝখানে কেন? চলার সময় তার মান JavaScript-এর নিয়মেই চলে, তাই 1040 + " taka" TypeScript-এও বৈধ string; কিন্তু checker JavaScript-এর অনেক রূপান্তর আটকায়। সত্যিকারের run-এ const bad = "1040" - 60; দিল error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. অর্থাৎ JavaScript-এর যে রূপান্তর চলার সময় ঘটত, TypeScript তার একটি অংশ চালানোর আগেই নিষেধ করে। এবার ছয়টি ভাষাকে একে একে বিচার করুন:

1Haat:   print(1040 + " taka");2Python: print(1040 + " taka")3JS:     1040 + " taka"4TS:     1040 + " taka"5Java:   1040 + " taka"6C:      total + " taka"
তিন প্রশ্নের উত্তর
কখন
রূপান্তর
safe?
  1. Haat. Type checker চালানোর আগেই বাতিল করে; কোনো implicit conversion নেই (Haat spec v1), আর ভাষায় কোনো pointer নেই বলে untrapped ভুলও নেই। ছবির বাঁ-ওপরের কোণ।
  2. Python 3.14. চলার সময় + দুই মানের tag দেখে, int আর str-এর কোনো নিয়ম পায় না, তাই trapped TypeError. রূপান্তর কম (int থেকে float হয়, আর bool int-এর subclass), তাই ওপরের দিকে, ডান পাশে।
  3. JavaScript. চলার সময়, কিন্তু error নয়: 1040-কে string বানিয়ে জোড়ে। "1040" - 60-এ উল্টো দিকে string-কে সংখ্যা বানায় (980; সত্যিকারের Node run). রূপান্তর অনেক, তবু safe: ভুল মেমরি পড়া যায় না।
  4. TypeScript 5.9. Static checker; 1040 + " taka" বৈধ string, কিন্তু "1040" - 60 TS2362. তারকা চিহ্ন: any আর error উপেক্ষা করে build-এর মতো ফাঁক আছে, আর চলার সময় type মুছে যায়; ফাঁকগুলো পর্ব ৩৮-এ।
  5. Java 21 (উদাহরণ, চালানো হয়নি). Java Language Specification-এ +-এর একটি দিক String হলে অন্যটি String-এ রূপান্তরিত হয় (string concatenation), তাই "1040 taka". কিন্তু "1040" - 60 compile error. Downcast চলার সময়ও যাচাই হয়।
  6. C17 (Clang 22.1.8). Static type আছে, কিন্তু int + char* হলো pointer arithmetic: বৈধ syntax, শুধু warning, আর ফল undefined behavior. রূপান্তর অনেক (double থেকে int নীরবে কাটা), আর untrapped ভুল সম্ভব: ছবির লাল দাগ।
  7. শিক্ষা। “C strongly typed কারণ static” আর “Python weakly typed কারণ dynamic”, দুটি দাবিই প্রশ্ন গুলিয়ে ফেলে। কখন যাচাই, কতটা রূপান্তর, আর safe কি না — তিনটি আলাদা করে বললে আর কোনো তর্ক থাকে না।

৫ · Type লেখা, না বের করা — explicit আর inferred

আরেকটি স্বাধীন অক্ষ: type কে লেখে? Explicit typing-এ (manifest typing নামেও পরিচিত) programmer প্রতিটি ঘোষণায় type লেখেন, যেমন C-র int paid = …;. Type inference-এ compiler নিজে বের করে। দুটি static typing-এরই রূপ; inference মানে dynamic typing নয়। Python-এ x = 5 লিখে type না লেখা আর Rust-এ let x = 5; লেখা দেখতে একরকম, কিন্তু Rust-এর compiler x-এর একটি স্থির type বের করে রাখে, আর পরে x = "five"; লিখলে compile error; Python-এ নামটির কোনো type-ই নেই।

Inference-এর মাত্রাও আলাদা। Local inference শুধু একটি ঘোষণার ডান পাশ দেখে: C++11-এর auto, Java 10-এর var, Go-র :=, আর Haat-এর let. Global inference পুরো function, এমনকি parameter-এর type-ও বের করে: ML, OCaml আর Haskell-এর Hindley–Milner পদ্ধতি, যা পর্ব ৩৫-এ বানাবেন। Haat spec v1-এ function-এর parameter আর ফেরত type লিখতেই হয়, কিন্তু let-এর type initializer থেকে আসে। Reference বাস্তবায়নে সত্যিকারের run:

let p = 2 * 520;        // p : Int, কেউ লেখেনি
let ok: Bool = p;       // লেখা type আর বের-করা type মেলে না
print(ok);

~/haat $ python haat.py check e2.haat
2:16: error: type mismatch: expected Bool, found Int

প্রথম লাইনে checker 2 * 520 থেকে T-Mul দিয়ে Int বের করে Γ-তে p : Int যোগ করল। দ্বিতীয় লাইনে লেখা type Bool একটি চুক্তি, আর বের-করা Int চুক্তি ভাঙল; বার্তার কলাম ১৬ ঠিক p-এর শুরু। Haat কেন parameter-এ type লেখায়? পর্ব ০৬-এ দেখেছেন: শেখার ভাষায় function-এর মাথায় লেখা type একটি পড়ার মতো documentation, আর error বার্তা কারণের কাছাকাছি থাকে, ঠিক যেমন অংশ ৩-এর TypeScript-এ ফেরত type লিখলে বার্তা লাইন ২-এ এল।

৬ · Nominal আর structural — দুটি type কখন মেলে

পর্ব ২২-এ দেখেছেন দুটি type কখন “একই”: name equivalence (একই ঘোষণা থেকে এলে) আর structural equivalence (গঠন এক হলে)। Type system-এর বড় প্রশ্নটি একটু আলাদা: একটি মান যেখানে চাওয়া হয়েছে সেখানে বসতে পারবে কি না, অর্থাৎ সামঞ্জস্য. Nominal typing-এ সম্পর্কটি নাম দিয়ে ঘোষণা করতে হয়: Java-তে একটি class Comparable হতে চাইলে implements Comparable লিখতেই হবে, method একই থাকলেও। Structural typing-এ আকার মিললেই চলে: TypeScript-এর object type আর Go-র interface এভাবে কাজ করে। Duck typing (পর্ব ১২) হলো structural ধারণার dynamic রূপ: যাচাই হয় চলার সময়, শুধু যে method আসলে ডাকা হলো সেটির।

Structural typing নমনীয়, কিন্তু একটি ফাঁদ আছে: আকারে এক কিন্তু অর্থে আলাদা দুটি জিনিস গুলিয়ে যায়। টাকা আর কেজি দুটিই সংখ্যা। সত্যিকারের run (TypeScript 5.9.2, tsc --noEmit --strict):

type Taka = number;
type Kg = number;
function pay(amount: Taka): void { console.log("paid", amount); }
const rice: Kg = 2;
pay(rice);                         // ২ কেজি চাল দিয়ে টাকা শোধ?

type TakaB = number & { readonly __brand: "Taka" };
type KgB = number & { readonly __brand: "Kg" };
function payB(amount: TakaB): void { console.log("paid", amount); }
const riceB = 2 as KgB;
payB(riceB);

units.ts(16,6): error TS2345: Argument of type 'KgB' is not assignable to parameter of type 'TakaB'.
  Type 'KgB' is not assignable to type '{ readonly __brand: "Taka" }'.
    Types of property '__brand' are incompatible.
      Type '"Kg"' is not assignable to type '"Taka"'.

প্রথম অংশে কোনো error নেই: Taka আর Kg শুধু number-এর ডাকনাম (type alias), তাই pay(rice) বৈধ। (একই ফাইলে আরেকটি পরীক্ষাও নীরবে পাস করেছে: {name, phone} চাওয়া function-এ বাড়তি city field-সহ একটি variable দেওয়া; আকারে প্রয়োজনের চেয়ে বেশি থাকলেও structural typing মেনে নেয়।) দ্বিতীয় অংশে একটি পরিচিত কৌশল, branded type: প্রতিটি type-এ একটি কাল্পনিক field জুড়ে দেওয়া, যা চলার সময় নেই, শুধু checker-এর চোখে। এখন আকার আলাদা, তাই error. অর্থাৎ structural ভাষায় nominal আচরণ নকল করতে হলো। উল্টো দিকে Rust আর Haskell-এ struct Taka(i64) বা newtype সরাসরি nominal নতুন type দেয়। TypeScript-এর type, interface আর structural নিয়মের ব্যবহারিক পরিচয় আছে JavaScript কোর্সের পর্ব ৪৭-এ (TypeScript-এর শুরু).

৭ · Soundness আর completeness — কেন checker রক্ষণশীল

একজন type checker দুই রকম ভুল করতে পারে। খারাপ program-কে ভালো বলে মেনে নেওয়া (false negative), আর ভালো program-কে খারাপ বলে বাতিল করা (false positive). প্রথমটি না করার গুণের নাম soundness: checker যা মেনে নেয়, তা চলার সময় প্রতিশ্রুত ভুলগুলোর কোনোটিতে পড়ে না। Robin Milner ১৯৭৮ সালের প্রবন্ধে এর বিখ্যাত রূপ দেন: “well-typed programs cannot go wrong”. দ্বিতীয়টি না করার গুণের নাম completeness: যে program কখনো ভুলে পড়ে না, তার প্রত্যেকটি মেনে নেওয়া। Static analysis-এর ভাষায় প্রথমটি sound analysis, দ্বিতীয়টি complete analysis.

উপপাদ্য ৩৩.১ — দুটো একসাথে নয়

যে ভাষায় যেকোনো হিসাব লেখা যায় (Turing-complete), সেখানে এমন কোনো checker নেই যা সবসময় থামে, sound, আর complete, যদি প্রতিশ্রুত আচরণ (যেমন “কখনো Int-এ Bool যোগ হবে না”) program-এর চলার ওপর নির্ভর করে।

প্রমাণের রূপরেখা. ১. ধরুন এমন একটি নিখুঁত checker K আছে। ২. যেকোনো program P নিন, আর বানান Q = “P চালাও; তারপর 1 + true হিসাব করো”। ৩. Q ভুলে পড়ে ঠিক তখনই, যখন P থামে। ৪. তাহলে K(Q) দেখে বলা যেত P থামে কি না, অর্থাৎ K halting problem সমাধান করত। ৫. Halting problem undecidable, তাই K থাকতে পারে না। ∎ এটি Rice-এর theorem-এর একটি বিশেষ রূপ; সাধারণ প্রমাণ আছে গণনার তত্ত্ব কোর্সের পর্ব ৫৩-এ (Rice-এর theorem — program-এর আচরণ নিয়ে প্রশ্ন).

তাহলে type checker কী বাছে? প্রায় সব ভাষা soundness রাখে (অন্তত লক্ষ্য হিসেবে) আর completeness ছাড়ে: সন্দেহ হলেই বাতিল। একে বলে রক্ষণশীল (conservative) checker. Haat-এ তিনটি সত্যিকারের উদাহরণ, যেখানে program কখনো ভুলে পড়ত না, তবু python haat.py check বাতিল করল:

// c1.haat — ভুল লাইনটি কখনো চলে না
if false {
    print(1 + true);
}
print("done");
2:15: error: type mismatch: expected Int, found Bool

// c2.haat — প্রতিটি সংখ্যা হয় ≥ 0, নয় < 0
fn sign(x: Int) -> Int {
    if x >= 0 { return 1; }
    if x < 0 { return -1; }
}
1:4: error: missing return: not every path of function 'sign' returns Int

// c3.haat — while true থেকে বের হওয়ার একমাত্র পথ return
fn first_big(x: Int) -> Int {
    while true { return x; }
}
1:4: error: missing return: not every path of function 'first_big' returns Int

প্রথমটিতে checker শর্তের মান দেখে না, দুটি শাখাই যাচাই করে। দ্বিতীয় আর তৃতীয়টিতে কাজ করছে reference-এর সিদ্ধান্ত ২১: missing return-এর নিয়ম সম্পূর্ণ syntactic, শর্তের অর্থ বোঝে না, আর while-কে কখনো “ফেরত দেয়” ধরে না, while true-কেও না। মানুষ এক নজরে বোঝেন x >= 0 আর x < 0 মিলে সব সংখ্যা ঢাকে; কিন্তু সাধারণভাবে দুটি শর্ত মিলে সব ঢাকে কি না, তা সিদ্ধান্ত করা অসম্ভব (শর্ত দুটি যেকোনো function-call হতে পারে)। Haat তাই সহজ, পূর্বানুমেয় নিয়ম বেছেছে; সমাধান সহজ: দ্বিতীয় if-কে else বানানো। Java-ও একই ধাঁচের নিয়ম রাখে, তবে Java-তে ধ্রুবক শর্তের while (true) বিশেষভাবে বিবেচনা করা হয়, তাই তৃতীয় উদাহরণটি Java-তে বৈধ হতো (উদাহরণ, চালানো হয়নি)। সত্যিকারের checker কতটা রক্ষণশীল, তা একটি ছোট ভাষায় গুনে দেখা যায়:

# Every term up to depth 2: does the checker accept it? does it run?
from itertools import product
ATOMS = [("num", 1), ("bool", True)]
def terms(d):
    if d == 0: return list(ATOMS)
    s = terms(d - 1)
    return (ATOMS + [("+", a, b) for a, b in product(s, repeat=2)]
            + [("if", c, a, b) for c, a, b in product(s, repeat=3)])
def check(e):                       # static: a type, or None = reject
    if e[0] in ("num", "bool"): return "Int" if e[0] == "num" else "Bool"
    ts = [check(x) for x in e[1:]]
    if e[0] == "+": return "Int" if ts == ["Int", "Int"] else None
    return ts[1] if ts[0] == "Bool" and ts[1] == ts[2] != None else None
def run(e):                         # dynamic: a value, or TypeError = stuck
    if e[0] in ("num", "bool"): return e[1]
    if e[0] == "+":
        a, b = run(e[1]), run(e[2])
        if type(a) is int and type(b) is int: return a + b
        raise TypeError("+ on non-Int")
    c = run(e[1])
    if type(c) is not bool: raise TypeError("if on non-Bool")
    return run(e[2]) if c else run(e[3])     # only one branch runs
count = {}
for e in terms(2):
    try: run(e); r = "runs"
    except TypeError: r = "stuck"
    key = ("accepted" if check(e) else "rejected", r)
    count[key] = count.get(key, 0) + 1
print("terms:", sum(count.values()))
for k in product(("accepted", "rejected"), ("runs", "stuck")):
    print(f"  {k[0]:8} + {k[1]:5} : {count.get(k, 0)}")
ex = ("+", ("num", 1), ("if", ("bool", True), ("num", 1), ("bool", True)))
print("1 + (if true then 1 else true): check", check(ex), "| run", run(ex))

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

terms: 2942
  accepted + runs  : 37
  accepted + stuck : 0
  rejected + runs  : 275
  rejected + stuck : 2630
1 + (if true then 1 else true): check None | run 2

দুটি পরমাণু (1, true) থেকে গভীরতা ২ পর্যন্ত সব ২৯৪২টি expression বানানো হলো, আর প্রতিটিকে checker আর evaluator দুজনকেই দেওয়া হলো। “accepted + stuck : 0” হলো soundness-এর সাক্ষ্য: মেনে নেওয়া ৩৭টির একটিও চলার সময় আটকায়নি। এটি প্রমাণ নয়, শুধু এই সীমার ভেতরে পরীক্ষা; সব গভীরতার জন্য প্রমাণ (progress আর preservation) পর্ব ৩৮-এ। “rejected + runs : 275” হলো incompleteness-এর মাপ: ২৭৫টি expression দিব্যি একটি মান দেয়, তবু বাতিল, কারণ if-এর যে শাখা কখনো চলে না, তার type-ও checker দেখে। অর্থাৎ এই ছোট জগতে চলতে পারা ৩১২টির মধ্যে মাত্র ৩৭টি checker-এর অনুমতি পেয়েছে; রক্ষণশীলতার দাম চোখে পড়ার মতো। শেষ লাইনে এমন একটির নমুনা: checker দেয় None (বাতিল), অথচ চালালে মান 2. নিচের stepper-এ এটিকেই ধাপে ধাপে দেখুন।

11 +2  (if true3     then 14     else true)
দুই চোখে
checker
evaluator
  1. Checker শুরু। সবার ওপরে +, তাই T-Add: দুই দিক Int প্রমাণ করতে হবে। বাঁ দিকের 1 T-Int দিয়ে Int. এবার ডান দিক।
  2. শর্ত। ডান দিক একটি if-expression. T-If প্রথমে শর্ত দেখে: true একটি Bool, ঠিক আছে। খেয়াল করুন, checker শর্তের মান ব্যবহার করে না, শুধু type.
  3. দুই শাখা। T-If চায় দুই শাখার type এক হোক, কারণ চালানোর আগে জানা নেই কোনটি নেওয়া হবে, অথচ পুরো if-এর জন্য একটিই type দিতে হবে। then Int, else Bool: মেলে না, তাই branches differ: Int vs Bool, program বাতিল।
  4. Evaluator শুরু। এবার একই expression চালানো হলো। বাঁ দিক 1. শর্ত true, তাই then-শাখা নেওয়া হবে; else-এর দিকে evaluator তাকাবেই না।
  5. শাখার মান। then-শাখা 1 দিল। else-শাখার true চলার সময় কখনো তৈরিই হয়নি, তাই T-Add-এর প্রয়োজনীয় “দুই দিক Int” চলার সময় সত্যিই মানা হয়েছে।
  6. ফল আর শিক্ষা। 1 + 1 = 2, কোনো ভুল নেই। তবু checker বাতিল করেছে। এটি bug নয়, নকশা: শর্তটি true না হয়ে যেকোনো function-call হলে, কোন শাখা চলবে তা সাধারণভাবে জানা অসম্ভব (উপপাদ্য ৩৩.১)। এমন ২৭৫টির মধ্যে এটি একটি।

বাস্তবের অনেক ভাষা উল্টো দিকের আপসও করে: কিছু জায়গায় soundness ছেড়ে দেয়, ব্যবহারের সুবিধার জন্য। TypeScript-এর any, Java-র covariant array (পর্ব ৩৬-এ চালিয়ে দেখবেন), আর C-র cast এর উদাহরণ। এই ফাঁকগুলো কোথায় আর কেন, তা পর্ব ৩৮-এ (Type soundness — progress আর preservation).

৮ · লাভ-ক্ষতির বিতর্ক — প্রমাণ কী বলে

“Static typing কি bug কমায়?” প্রশ্নটি নিয়ে বহু বছর ধরে তর্ক চলছে, আর সেখানে মতামত প্রমাণের চেয়ে অনেক বেশি। লাভের দিকগুলো যুক্তিতে স্পষ্ট: কিছু শ্রেণির ভুল চালানোর আগেই ধরা, type লেখা function-এর মাথা যেন হালনাগাদ documentation, IDE-র autocomplete আর নিরাপদ নাম বদল (refactoring), আর compiler-এর জন্য দ্রুত কোড বানানোর তথ্য (Int জানা থাকলে প্রতিটি যোগে tag দেখতে হয় না; পর্ব ১২-এর অংশ ৮)। খরচের দিকও স্পষ্ট: বেশি লেখা, কিছু সঠিক program বাতিল (অংশ ৭), শেখার শুরুতে বাধা, আর জটিল type-এর কঠিন error বার্তা।

পরিমাপ কঠিন, কারণ ভাষা, দল, প্রজেক্ট আর অভিজ্ঞতা একসাথে বদলায়। দুটি পরিচিত গবেষণা উদাহরণ হিসেবে (সংখ্যা তাঁদের নিজস্ব, নির্দিষ্ট পরিস্থিতির):

  • Gao, Bird আর Barr (ICSE ২০১৭), “To Type or Not to Type”: GitHub-এর JavaScript প্রজেক্টের ৪০০টি প্রকাশ্য bug নিয়ে তাঁরা দেখেন, প্রাসঙ্গিক জায়গায় type annotation যোগ করলে Flow আর TypeScript প্রায় ১৫% bug ধরতে পারত (Flow ৫৯টি, TypeScript ৫৮টি)। এটি “যা ধরা যেত” তার মাপ; বাকি প্রায় ৮৫% এই দুই checker-এর নাগালের বাইরে ছিল, যার বড় অংশ যুক্তি বা চাহিদা বোঝার ভুল বলে মনে করা হয়।
  • বড় repository-ভিত্তিক তুলনা: ২০১৪ সালে Ray ও সহকর্মীরা GitHub-এর বহু প্রজেক্টে ভাষার ধরন আর bug-এর মধ্যে ছোট একটি সম্পর্ক পেয়েছিলেন; ২০১৯ সালে Berger ও সহকর্মীদের পুনরাবৃত্তি-গবেষণা (TOPLAS) পদ্ধতিগত সমস্যা ঠিক করার পর দেখান যে সেই প্রভাবের বেশিরভাগই আর টেকে না। অর্থাৎ “ভাষার ধরন বদলালেই bug কমে” দাবিটি প্রমাণিত নয়।

তাহলে বাস্তব সিদ্ধান্ত কী? বেশিরভাগ দল নিজেদের পরিস্থিতি দেখে বেছে নেয়: ছোট script আর দ্রুত পরীক্ষায় dynamic ভাষা, বড় আর দীর্ঘজীবী codebase-এ static type বা অন্তত type hint. এই কারণেই মাঝামাঝি পথ এত জনপ্রিয়: JavaScript-এর ওপর TypeScript, Python-এ type hint আর mypy (Python কোর্সের পর্ব ৪০), যাকে বলে gradual typing; তত্ত্ব আসবে পর্ব ৩৯-এ।

আরও গভীরে: “Type” ধারণাটির শুরু প্রোগ্রামিংয়েরও আগে, গণিতের ভিত্তি নিয়ে সংকট থেকে: Bertrand Russell ১৯০০-এর দশকের শুরুতে তাঁর paradox এড়াতে type-এর তত্ত্ব প্রস্তাব করেন, আর Alonzo Church ১৯৪০ সালে simply typed lambda calculus দেন (পর্ব ৪৩-এ)। প্রোগ্রামিংয়ে FORTRAN (১৯৫৭) integer আর real আলাদা করেছিল মূলত দক্ষ machine code-এর জন্য, নিরাপত্তার জন্য নয়; ALGOL 68, Pascal আর ML-এর পথে type ধীরে ধীরে “ভুল বাদ দেওয়ার প্রমাণ” হয়ে ওঠে। আজ গবেষণার সীমান্তে আছে dependent type (Lean, Coq, Agda), যেখানে type দিয়ে প্রায় যেকোনো গাণিতিক ধর্ম লেখা যায়, আর সেখানে type checking মানে প্রমাণ যাচাই।

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

  • Static আর dynamic typing-এর পার্থক্য? Static: চালানোর আগে লেখা দেখে, সব পথ; dynamic: চলার সময় মানের tag দেখে, শুধু যে পথ চলে।
  • Python strong না weak? “Strong/weak”-এর সর্বসম্মত সংজ্ঞা নেই; Python dynamic, কম implicit conversion করে (1 + "a" TypeError), আর safe.
  • Type inference মানে কি dynamic typing? না; inference static typing-এর অংশ, compiler type বের করে স্থির রাখে।
  • Sound আর complete checker? Sound: মেনে নেওয়া program ভুলে পড়ে না; complete: নিরাপদ সব program মেনে নেয়। Turing-complete ভাষায় দুটো একসাথে অসম্ভব (Rice), তাই checker রক্ষণশীল।
  • Trapped আর untrapped error? Trapped ঘটলে সঙ্গে সঙ্গে থামে (TypeError); untrapped নীরবে চলে (C-তে সীমার বাইরে লেখা)। Untrapped ভুল অসম্ভব হলে ভাষা safe.

৯ · AI-এর যুগে type system

Type-সংক্রান্ত প্রশ্নে AI assistant-এর উত্তর প্রায়ই এক ভাষার নিয়মকে সব ভাষায় চাপায়, আর ঝাপসা শব্দকে নির্ভুল সংজ্ঞার মতো বলে। এই বিষয়ে বারবার দেখা ভুল আর যাচাইয়ের উপায়:

AI-এর ভুলকীভাবে ধরবেন
“C strongly typed কারণ static”, “JavaScript-এ type নেই”: ঝাপসা শব্দ নিশ্চিত সত্য হিসেবেতিন প্রশ্নে ভেঙে জিজ্ঞেস করা: কখন যাচাই, কতটা রূপান্তর, untrapped ভুল সম্ভব কি না
এক ভাষার রূপান্তর-নিয়ম অন্য ভাষায় চাপানো (Java-র string concatenation-কে C-তে ধরে নেওয়া)নির্দিষ্ট ভাষা আর version-এ চালিয়ে দেখা; C-তে -Wall -Wextra -Wconversion
Type error চুপ করাতে any, as, // @ts-ignore বা C cast বসানোDiff-এ এগুলো খোঁজা; --strict আর --noEmitOnError চালু রাখা; cast-এর প্রতিটি জায়গায় কেন নিরাপদ তা লিখে রাখা
“TypeScript চলার সময় type যাচাই করে” বা “type hint Python-কে static বানায়”Compile-করা JavaScript পড়া (type মুছে গেছে); Python-এ ভুল type দিয়ে চালিয়ে দেখা, hint উপেক্ষিত হয়
“Type checker পাস করেছে, তাই program ঠিক”Type কোন ভুল বাদ দেয় তা জানা (শূন্য দিয়ে ভাগ, যুক্তির ভুল নয়); test, বিশেষত বিরল পথের test লেখা
বানানো compiler error বার্তা বা ভুল error code (TS-এর নম্বর)আসল tsc, mypy বা compiler চালিয়ে বার্তা কপি করা

AI-কে ভালোভাবে কাজে লাগাতে ভাষা আর version বলে দিন, আর প্রতিটি দাবির জন্য যাচাইয়ের উপায় চান:

আমি type system শিখছি; ভাষা: Python 3.14, TypeScript 5.9 (--strict), C17 (Clang), Java 21. ১. প্রতিটি ভাষাকে "strong/weak" না বলে তিনটি আলাদা প্রশ্নে বিচার করো: type যাচাই কখন হয় (static/dynamic), কতটা implicit conversion হয়, আর untrapped ভুল সম্ভব কি না। প্রতিটি দাবির পাশে একটি ছোট উদাহরণ দাও। ২. নিচের কোডে কোন ভুল type checker ধরবে, কোনটি চলার সময় ধরা পড়বে, আর কোনটি কেউই ধরবে না, ভাগ করে বলো: [এখানে আমার কোড] ৩. কোনো error বার্তা বা আউটপুট অনুমান করে লিখবে না; কোনটি আমাকে tsc, python বা clang-এ চালিয়ে দেখতে হবে, তার তালিকা দাও। ৪. Type error চুপ করাতে any, cast বা ignore-comment প্রস্তাব করবে না; করলে কেন নিরাপদ তা প্রমাণসহ বলো।

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

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

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

প্র ০১Type system যদি শুধু “কিছু নির্দিষ্ট” ভুল বাদ দেয়, তবে কোন ভুলগুলো বাদ দেওয়া হবে তা কে ঠিক করে, আর কীভাবে?

ঠিক করেন ভাষার নকশাকার, আর সিদ্ধান্তটি তিনটি জিনিসের টানাপোড়েন: কোন ভুল সবচেয়ে ক্ষতিকর, কোনটি checker দ্রুত আর নির্ভরযোগ্যভাবে ধরতে পারে, আর প্রোগ্রামারকে কতটা বাড়তি লেখা সহ্য করাতে হবে। Haat-এর তালিকা ছোট: ভুল ধরনের operand, ভুল সংখ্যক argument, ফেরত type-এর অমিল, আর ফেরত না দেওয়া পথ। শূন্য দিয়ে ভাগ তালিকায় নেই, কারণ ভাজকের মান চালানোর আগে সাধারণভাবে জানা যায় না; তা ধরতে হলে প্রতিটি সংখ্যার type-এ “শূন্য নয়” তথ্য বহন করতে হতো।

ইতিহাস দেখায়, তালিকা সময়ের সঙ্গে বড় হয়। Tony Hoare ২০০৯ সালের একটি বক্তৃতায় ALGOL W-তে (১৯৬৫) null reference আনাকে নিজের “billion-dollar mistake” বলে উল্লেখ করেছিলেন; null-এর ভুল তখন type system-এর তালিকার বাইরে ছিল। পরের প্রজন্মের ভাষাগুলো একে তালিকায় তুলেছে: Kotlin-এ nullable আর non-null type আলাদা, Rust আর Swift-এ Option/Optional, TypeScript-এ strictNullChecks. Rust আরও এগিয়ে data race আর use-after-free-কেও তালিকায় এনেছে (পর্ব ৭৬)। গবেষণার ভাষায় dependent আর refinement type দিয়ে array-র সীমা, এমনকি “ভাজক শূন্য নয়” পর্যন্ত লেখা যায় (পর্ব ৩৯), তবে দাম বাড়তি annotation আর ধীর বা জটিল যাচাই।

তালিকা বাড়ানোর সীমাও আছে, আর তা গাণিতিক: অংশ ৭-এর উপপাদ্য অনুযায়ী যে ধর্ম program-এর চলার ওপর নির্ভর করে, তা নিখুঁতভাবে ধরা অসম্ভব। তাই প্রতিটি নতুন ভুল তালিকায় তোলা মানে আরও কিছু নিরাপদ program বাতিল করার ঝুঁকি, বা প্রোগ্রামারকে প্রমাণের কাজে আরও বেশি টানা। ভালো নকশাকার এমন ভুল বাছেন যা ঘন ঘন ঘটে, ক্ষতিকর, আর লেখার গঠন থেকে প্রায় সহজেই দেখা যায়।

মূল উপলব্ধি: type system একটি চুক্তি, যার ধারাগুলো ভাষার নকশাকার লেখেন। “Type-safe” বলার আগে জিজ্ঞেস করুন: কোন ভুলের বিরুদ্ধে safe? উত্তরটি ভাষাভেদে আলাদা, আর সময়ের সঙ্গে বড় হচ্ছে।

প্র ০২C-তে static type আছে, তবু কেন একে প্রায়ই “unsafe” বলা হয়? C-র নকশাকারেরা কি ভুল করেছিলেন?

C-র type system-এর লক্ষ্য কখনোই Cardelli-র অর্থে safety ছিল না। C জন্মেছে ১৯৭০-এর দশকের শুরুতে, Bell Labs-এ Unix লেখার জন্য, যেখানে প্রোগ্রামারকে hardware-এর কাছাকাছি থাকতে হতো: device register-এ নির্দিষ্ট ঠিকানায় লেখা, মেমরিকে নিজের মতো ভাগ করা, এক type-এর বিটকে অন্য type হিসেবে পড়া। C-র পূর্বসূরি B ভাষায় প্রায় type-ই ছিল না; সব মান ছিল একটি machine word. C type এনেছিল মূলত compiler-কে বলতে যে কোন মান কত byte আর কোন নির্দেশ লাগবে, যেমন int আর char-এর আকার, বা pointer যোগে কত byte সরতে হবে।

এই নকশার ফল, এই পর্বে সত্যিকারের Clang 22.1.8-এ দেখা: total + " taka" বৈধ pointer arithmetic; int paid = price; নীরবে পয়সা কাটে; ৩০০ হয়ে যায় ৪৪. আর array-র সীমা, ছেড়ে দেওয়া মেমরির ব্যবহার, ভুল cast, এগুলো সবই undefined behavior, অর্থাৎ untrapped. নিরাপত্তার জগতে এর দাম অনেক বড়; বহু বছর ধরে বড় সফটওয়্যারের গুরুতর নিরাপত্তা-ত্রুটির একটি বড় অংশ এই ধরনের মেমরি-ভুল থেকে আসে বলে বিভিন্ন প্রতিষ্ঠান জানিয়েছে, যদিও সঠিক অনুপাত প্রজেক্টভেদে আলাদা।

তবু “ভুল করেছিলেন” বলা অন্যায্য। ১৯৭২ সালের যন্ত্রে প্রতিটি array access-এ সীমা পরীক্ষা বা garbage collection-এর খরচ বহন করা কঠিন ছিল, আর C-র নমনীয়তা ছাড়া Unix এত যন্ত্রে এত দ্রুত ছড়াত না। সমস্যা হলো নকশাটি তার যুগ পেরিয়ে টিকে গেছে। পরের উত্তরগুলো দুই দিক থেকে এসেছে: C-কে ঘিরে tool (sanitizer, -Wconversion, static analyzer, পর্ব ২৩), আর নতুন ভাষা যারা একই গতি রেখে safety দেয়, যেমন Rust, যেখানে unsafe কাজ unsafe block-এ আলাদা করে চিহ্নিত।

মূল উপলব্ধি: “static” আর “safe” আলাদা প্রশ্ন। C-র type system compiler-এর জন্য তথ্য, programmer-এর জন্য পাহারা নয়; তাই C-তে নিরাপত্তা আসে শৃঙ্খলা আর tool থেকে, type থেকে নয়।

প্র ০৩TypeScript সব type মুছে ফেলে আর ইচ্ছা করেই কিছু জায়গায় unsound — তাহলে এর মূল্য কোথায়?

TypeScript-এর নকশার লক্ষ্য লেখা আছে তার নিজের design goals-এ: বিদ্যমান JavaScript-এর ওপর বসা, চলার সময় কোনো বাড়তি খরচ না রাখা, আর একটি “sound বা প্রমাণযোগ্যভাবে সঠিক” type system-কে লক্ষ্য না করা, বরং সঠিকতা আর উৎপাদনশীলতার মধ্যে ভারসাম্য খোঁজা। এজন্যই tsc type মুছে দেয় (চলার সময় খরচ শূন্য), any রাখে (পুরোনো JavaScript ধাপে ধাপে আনার জন্য), আর কিছু পুরোনো নিয়ম, যেমন method parameter-এর bivariance, রেখেছে যাতে প্রচলিত JavaScript-এর ধাঁচ ভাঙে না।

তাহলে মূল্য কোথায়? অংশ ৩-এর শুক্রবারের উদাহরণেই উত্তর: যে ভুল test ছোঁয়নি, তা tsc কোনো run ছাড়াই ধরল, আর বার্তা দিল কারণের লাইনে। অংশ ৮-এর Gao–Bird–Barr গবেষণা অনুযায়ী প্রকাশ্য JavaScript bug-এর প্রায় ১৫% এভাবে ধরা যেত। Soundness-এর ফাঁক থাকা মানে প্রতিটি ভুল ধরা পড়বে না; কিন্তু বেশিরভাগ সাধারণ কোডে ফাঁকগুলো ছোঁয়াই হয় না, যদি কেউ ইচ্ছা করে any বা as না লেখেন। তার ওপর আছে editor-এর autocomplete আর নিরাপদ refactoring, যা বড় দলের দৈনন্দিন কাজে সম্ভবত সবচেয়ে বড় লাভ।

সীমাও মনে রাখা দরকার। বাইরের তথ্য (API-র JSON, ব্যবহারকারীর input) চলার সময় আসে, আর type মুছে যাওয়ায় সেগুলোকে কেউ যাচাই করে না; সেখানে আলাদা runtime validation লাগে। any একবার ঢুকলে তা ছড়ায়; unknown তার নিরাপদ বিকল্প (পর্ব ৩৯)। আর error উপেক্ষা করে build চালানো যায়, যা অংশ ৩-এর সতর্কবার্তায় দেখেছেন।

মূল উপলব্ধি: একটি type system sound না হয়েও দরকারি হতে পারে, যতক্ষণ জানা থাকে কোথায় সে নীরব থাকে। TypeScript-কে প্রমাণ-যন্ত্র নয়, অত্যন্ত দক্ষ একটি ভুল-খোঁজার যন্ত্র হিসেবে ব্যবহার করুন, আর সীমানায় চলার সময়ের যাচাই রাখুন।

প্র ০৪রক্ষণশীল checker নিরাপদ program বাতিল করে। এই অসুবিধা কমাতে ভাষাগুলো কী কী কৌশল নিয়েছে?

অংশ ৭-এর গণনায় ছোট একটি জগতেই চলতে পারা ৩১২টি expression-এর মধ্যে মাত্র ৩৭টি অনুমতি পেয়েছে। বাস্তব ভাষায় এই হার এত খারাপ নয়, কারণ প্রোগ্রামার সাধারণত type মেনে লেখেন; তবু ভাষাগুলো কয়েকটি পথে type system-কে আরও “বুদ্ধিমান” করেছে, যাতে বেশি নিরাপদ program গৃহীত হয়।

এক, আরও প্রকাশক্ষম type. if-এর দুই শাখা আলাদা type দিলে TypeScript বাতিল না করে union type number | string দেয় (অংশ ৩-এর দ্বিতীয় run-এ এটিই দেখেছেন)। Polymorphism একই function-কে নানা type-এ চালাতে দেয় (পর্ব ৩৬)। দুই, flow-sensitive typing বা narrowing: if (typeof x === "string")-এর ভেতরে TypeScript জানে x একটি string; Kotlin-এর smart cast একই কাজ করে। এখানে checker শর্তের অর্থের একটি সীমিত অংশ বোঝে, যা অংশ ৭-এর “শর্ত দেখে না” সমস্যা আংশিক কমায়। তিন, ভালো control-flow নিয়ম: Java ধ্রুবক শর্তের while (true)-কে বিশেষভাবে দেখে, তাই Haat যেটি বাতিল করে Java তা মানে। Rust-এর ! (never) type বলে দেয় কোনো function কখনো ফেরে না।

চার, পালানোর দরজা: cast, any, Rust-এর unsafe. এগুলো সচেতনভাবে soundness ছাড়ে, তবে চিহ্নিত জায়গায়, যাতে review-এ খুঁজে পাওয়া যায়। পাঁচ, gradual typing: type না লেখা অংশ dynamic-ভাবে যাচাই হয় (পর্ব ৩৯)। প্রতিটি কৌশলের দাম আছে: checker জটিল হয়, error বার্তা কঠিন হয়, আর inference (পর্ব ৩৫) কঠিন বা অসম্ভব হয়ে যেতে পারে।

মূল উপলব্ধি: completeness পুরোপুরি পাওয়া অসম্ভব, কিন্তু তার কাছাকাছি যাওয়ার একটি অবিরাম প্রকৌশল আছে। প্রতিটি নতুন type-feature আসলে “আরও বেশি নিরাপদ program মেনে নেওয়া, soundness না হারিয়ে” প্রচেষ্টার একটি ধাপ।

প্র ০৫Haat কেন static, explicit (function-এ) আর implicit conversion-হীন? একটি শেখার ভাষার জন্য এই তিন বাছাই কি সঠিক?

তিনটি বাছাই একই লক্ষ্যে: ভুল যেন আগে, স্পষ্ট বার্তায়, আর কারণের কাছে ধরা পড়ে। Static হওয়ায় শুক্রবারের মতো বিরল পথের ভুলও কোনো test ছাড়া ধরা পড়ে, আর কোর্সের পরের অংশে compiler বানানো সহজ হয়: bytecode compiler আর RISC-V back end (পর্ব ৫৮, ৭২) জানে প্রতিটি মান Int না Bool, তাই প্রতিটি যোগের আগে tag দেখার নির্দেশ লাগে না। Reference বাস্তবায়নে checker আগেই নিশ্চিত করে যে ADD-এর দুই operand একই ধরনের (Int বা Str), তাই VM-কে type-ভুলের কোনো runtime error বানাতে হয় না।

Function-এ explicit type শেখার জন্য দুই কারণে ভালো। প্রথমত, function-এর মাথা পড়েই তার চুক্তি বোঝা যায়, ঠিক যেমন fn price(qty: Int, unit: Int) -> Int. দ্বিতীয়ত, error বার্তা কারণের কাছে থাকে; অংশ ৩-এ দেখেছেন, TypeScript-এ ফেরত type লেখা থাকলে বার্তা লাইন ২-এ এসেছিল, না থাকলে লাইন ৬-এ। তবু let-এ local inference রাখা হয়েছে, কারণ let p: Int = qty * unit; লেখায় নতুন কোনো তথ্য নেই। পর্ব ৩৫-এ Haat-এর বর্ধিত রূপে parameter-এর type-ও Hindley–Milner দিয়ে বের করবেন, তুলনাটি নিজে দেখার জন্য।

Implicit conversion না থাকায় type checker-এর নিয়ম ছোট: T-Add-এ দুই দিক Int, কোনো রূপান্তর-টেবিল নেই। C-র usual arithmetic conversions (পর্ব ২০) বা JavaScript-এর +-এর নিয়ম যে কতটা জটিল, তা আগের পর্বগুলোতে দেখেছেন। দাম হলো কিছু বাড়তি লেখা, আর Haat-এ এখনো Int থেকে Str বানানোর কোনো function নেই, তাই "Total: " + 996 লেখা যায় না; spec v2-তে এমন একটি built-in যোগ করা স্বাভাবিক প্রস্তাব।

মূল উপলব্ধি: type system-এর প্রতিটি অক্ষে বাছাই ভাষার উদ্দেশ্য থেকে আসে। শেখা আর compiler বানানোর জন্য স্পষ্টতা আর পূর্বানুমেয়তা সবচেয়ে মূল্যবান, তাই Haat প্রতিটি অক্ষে “কঠোর” দিকটি নিয়েছে।

অনুশীলন

প্রথমে নিজে হিসাব করুন বা লিখুন, তারপর উত্তর খুলুন। প্রতিটি উত্তর সত্যিকারের run দিয়ে যাচাই করা।

  1. Checker বড় করুন (বাস্তবায়ন): অংশ ১-এর ছোট checker-এ Haat-এর নিয়ম মেনে দুটি জিনিস যোগ করুন: (ক) ==, যার দুই দিক একই type হতে হবে আর type হতে হবে Int, Bool বা Str (reference-এর সিদ্ধান্ত ১১); (খ) Str literal, আর +-এ Int + Int অথবা Str + Str, যেখানে বাঁ দিকের type ঠিক করে ডান দিকে কী চাই। total + " taka" আর true == 1-এর বার্তা কী হবে?
    old = check                     # the checker from section 1
    def check(e, env):
        kind = e[0]
        if kind == "str": return "Str"
        if kind == "==":
            t1, t2 = check(e[1], env), check(e[2], env)
            if t1 != t2 or t1 not in ("Int", "Bool", "Str"):
                raise TypeError(f"type mismatch: expected {t1}, found {t2}")
            return "Bool"
        if kind == "+":                 # left operand decides
            t1 = check(e[1], env)
            if t1 not in ("Int", "Str"):
                raise TypeError(f"type mismatch: expected Int, found {t1}")
            t2 = check(e[2], env)
            if t2 != t1: raise TypeError(f"type mismatch: expected {t1}, found {t2}")
            return t1
        return old(e, env)

    লেখকের CPython 3.14.4-এ চালিয়ে (env = total : Int):

    total == 1040        : Bool
    true == 1            x type mismatch: expected Bool, found Int
    "bazar" + "ghor"     : Str
    total + " taka"      x type mismatch: expected Int, found Str
    (1 == 1) == true     : Bool

    Haat reference-এর সঙ্গে মেলে: print(true == 1);-এ সত্যিকারের check দেয় 1:15: error: type mismatch: expected Bool, found Int, আর print(1040 + " taka");-এ expected Int, found Str. শেষ লাইনটি দেখায় ==-এর ফল Bool, তাই আবার Bool-এর সঙ্গে তুলনা বৈধ। (বাস্তব Haat-এ a == b == c লেখা যায় না, সিদ্ধান্ত ১০; এখানে বন্ধনী দিয়ে গঠনটি স্পষ্ট করা হয়েছে।) একটি সূক্ষ্মতা: reference function আর Unit-এর তুলনায় আলাদা বার্তা দেয় (cannot compare values of type …); এই ছোট checker-এ সেই ভেদ রাখা হয়নি।

  2. প্রমাণ করুন: একজন দাবি করলেন, “আমি Haat-এর জন্য এমন একটি checker বানিয়েছি যা সবসময় থামে, আর কোনো program বাতিল করে ঠিক তখনই, যখন চালালে সত্যিই কোনো if-এর শর্ত বা +-এর operand ভুল type পায়।” এই দাবি কেন অসম্ভব, ধাপে ধাপে দেখান। (ইঙ্গিত: ধরে নিন Haat-এ একটি program P লেখা আছে যার main-এর মতো একটি function p() আছে।)

    দাবিটি একটি sound আর complete, সবসময় থামা checker-এর। প্রমাণ reduction দিয়ে, অর্থাৎ দেখানো যে এমন checker থাকলে একটি পরিচিত অসম্ভব সমস্যারও সমাধান হতো:

    1. ধরুন এমন checker K আছে।
    2. যেকোনো Haat program P নিন, যার কাজ একটি function p()-এ, আর যার নিজের কোনো type-ভুল নেই। বানান Q: P-এর সব ঘোষণা, তারপর p();, তারপর print(1 + true);. দাবিকৃত K লেখা দেখে নয়, “চলার সময় সত্যিই ঘটে কি না” দেখে বিচার করে, তাই শেষ লাইনটি তার কাছে ভুল কেবল যদি সেখানে পৌঁছানো যায়।
    3. Q-তে ভুলটি চলার সময় ঘটে ঠিক তখনই, যখন p() থামে (Haat-এ loop আর recursion আছে, তাই p() চিরকাল চলতে পারে)।
    4. তাই K(Q) = “বাতিল” ঠিক তখনই, যখন P থামে। K সবসময় থামে বলে এটি halting problem-এর একটি সমাধান হতো।
    5. Halting problem undecidable (Turing ১৯৩৬), তাই K থাকতে পারে না। ∎

    Haat যে এই সমস্যায় পড়ে না, তার কারণ তার checker ঠিক উল্টো আপস করে: “চলার সময় সত্যিই ঘটে কি না” না দেখে, লেখায় ভুল সম্ভব হলেই বাতিল (if false { print(1 + true); }-এর সত্যিকারের run: 2:15: error: type mismatch: expected Int, found Bool). এটি sound কিন্তু incomplete, আর সবসময় থামে। Halting problem-এর প্রমাণ নিজে দেখতে চাইলে গণনার তত্ত্ব কোর্সের Rice-এর theorem-এর পর্বটি দেখুন।

  3. আউটপুট অনুমান করুন: প্রতিটির জন্য বলুন: চালানোর আগে error, চলার সময় error, নাকি কোনো error নেই (আর তখন ফল কী)? (ক) Python 3.14: def f(): return 1 + "a", তারপর শুধু print("defined ok"), f কখনো ডাকা হয় না। (খ) JavaScript: "5" * "2" আর তার typeof. (গ) TypeScript 5.9 --strict: const x: number = "5" * 2;. (ঘ) Haat: if false { print(1 + true); } print("done");. (ঙ) C17, Clang -Wall -Wextra: unsigned char qty = 300; তারপর qty ছাপা।

    সত্যিকারের run (CPython 3.14.4, Node.js 24.15.0, TypeScript 5.9.2, Haat reference, Clang 22.1.8):

    • (ক) কোনো error নেই, ছাপে defined ok. Python function-এর ভেতরের + যাচাই করে শুধু চলার সময়, আর f কখনো চলেনি।
    • (খ) 10 number. JavaScript-এর * দুই দিককেই সংখ্যা বানায়; +-এর মতো string-জোড়ার বিকল্প নেই। Weak typing-এর আরেক রূপ।
    • (গ) চালানোর আগে: p3.ts(1,19): error TS2362: The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type. TypeScript JavaScript-এর এই রূপান্তর নিষেধ করে।
    • (ঘ) চালানোর আগে: 2:15: error: type mismatch: expected Int, found Bool, আর done-ও ছাপা হয় না। রক্ষণশীল checker, অংশ ৭।
    • (ঙ) Compile হয়, warning implicit conversion from 'int' to 'unsigned char' changes value from 300 to 44 [-Wconstant-conversion], আর ছাপে 44.

    (ক) আর (ঘ) পাশাপাশি রাখুন: একই ধরনের “কখনো চলে না এমন ভুল”, Python চুপ, Haat বাতিল। এটিই static আর dynamic যাচাইয়ের সারকথা।

  4. ভাষার feature নকশা (Haat-এর বর্ধিত রূপ): বাজারঘরের কোডে টাকা আর পয়সা গুলিয়ে যাচ্ছে। Haat-এ একটি newtype Taka = Int; ঘোষণা যোগ করতে চান, যা nominal: Taka আর Int আলাদা type. (ক) একটি Int থেকে Taka কীভাবে বানাবেন আর ফেরত আনবেন? (খ) +-এর typing rule কীভাবে বদলাবে? (গ) চলার সময় কোনো খরচ হবে কি? (ঘ) TypeScript-এর branded type থেকে এটি কোথায় আলাদা?

    একটি সম্ভাব্য নকশা (একমাত্র সঠিক উত্তর নয়):

    • (ক) ঘোষণা দুটি function তৈরি করে: Taka(n) (Int → Taka) আর n.raw বা untaka(t) (Taka → Int). Checker-এ নিয়ম: Γ ⊢ e : Int থেকে Γ ⊢ Taka(e) : Taka, আর উল্টোটি।
    • (খ) দুটি পথ। সরল পথে + শুধু Int আর Str-এ, তাই Taka যোগ করতে হলে আগে untaka. সুবিধাজনক পথে নতুন নিয়ম: Γ ⊢ e1 : Taka আর Γ ⊢ e2 : Taka থেকে Γ ⊢ e1 + e2 : Taka; কিন্তু Taka + Int বাতিল (type mismatch: expected Taka, found Int), আর Taka * Taka-র অর্থ নেই বলে তাও বাতিল করা ভালো।
    • (গ) না। Type checking শেষে Taka মুছে Int বানানো যায় (erasure); VM-এ একই ADD. Rust-এর newtype আর Haskell-এর newtype-ও এই কারণে চলার সময় খরচহীন বলে পরিচিত।
    • (ঘ) TypeScript-এ 2 as KgB লিখে যেকোনো সংখ্যাকে যেকোনো brand দেওয়া যায় (অংশ ৬-এর run-এ এটিই করা হয়েছে); as যাচাই করে না। Haat-এর নকশায় Taka বানানোর একমাত্র পথ Taka(…), যা কোডে চোখে পড়ে আর খোঁজা যায়। আর ভাষাটি নিজেই nominal নিয়ম জানে, কৌশলের দরকার নেই।

    নিজে যাচাই: অনুশীলন ১-এর checker-এ ("taka", e) node আর Taka + Taka নিয়ম যোগ করে Taka(500) + Taka(436) (Taka) আর Taka(500) + 436 (error) চালিয়ে দেখুন।

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

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

ক্রমHaat-এর static checker let ok: Bool = 2 * 520; দেখে যে কাজগুলো করে, সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Parser লেখাটিকে AST বানায়: Let(ok, Bool, Binary(*, 2, 520))
  2. Resolver নামগুলো খোঁজে; নতুন নাম ok এই scope-এ ঘোষিত হয়
  3. Checker T-Int দিয়ে 2 আর 520-কে Int বলে
  4. Checker T-Mul দিয়ে 2 * 520-কে Int বলে
  5. লেখা type Bool আর বের-করা type Int মেলে না: type mismatch, program চলেই না

Pierce-এর সংজ্ঞা অনুযায়ী একটি type system মূলত কী করে?

  • Program চালিয়ে প্রতিটি মানের ধরন লিখে রাখে
  • Program-এর লেখা দেখে প্রতিটি অংশকে শ্রেণিতে ভাগ করে প্রমাণ করে যে কিছু নির্দিষ্ট ভুল ঘটবে না
  • Program-এর সব ভুল চালানোর আগে খুঁজে বের করে
  • Compiler-কে দ্রুত machine code বানাতে সাহায্য করে, আর কিছু নয়

C17-এ int total = 1040; const char *label = total + " taka"; — এর সবচেয়ে সঠিক বর্ণনা কোনটি?

  • label হয় "1040 taka"
  • Compile error, কারণ int আর string যোগ করা যায় না
  • বৈধ pointer arithmetic, শুধু warning; ফল string-এর সীমার বাইরের pointer, যা undefined behavior
  • চলার সময় একটি TypeError হয়

একটি JavaScript function-এ ভুলটি শুধু শুক্রবারের পথে আছে, আর test চালানো হয়েছে শুধু শনি, রবি ও সোমবার দিয়ে। একই কোড TypeScript-এ ঘোষিত ফেরত type-সহ লিখে tsc --strict চালালে কী হবে?

  • tsc-ও শুধু শুক্রবার চালালে ভুলটি ধরবে
  • চলার সময় TypeScript নিজে প্রতিটি মান যাচাই করবে
  • ভুলটি ধরা পড়বে না, কারণ test পাস করেছে
  • কোনো run ছাড়াই, ভুল লাইনেই error দেবে

“Strong typing” শব্দটি নিয়ে নিচের কোন কথাটি সবচেয়ে নির্ভুল?

  • এর কোনো সর্বসম্মত সংজ্ঞা নেই; তিনটি আলাদা প্রশ্নে ভেঙে বলা ভালো
  • Strong মানে static, তাই C strongly typed
  • সব dynamic ভাষা weakly typed
  • যে ভাষায় type লিখতে হয় সেটিই strongly typed

একটি sound কিন্তু incomplete type checker সম্পর্কে কোনটি সত্য?

  • এটি কিছু ভুল program মেনে নেয়, কিন্তু কোনো সঠিক program বাতিল করে না
  • এটি যা মেনে নেয় তা নিরাপদ, কিন্তু কিছু নিরাপদ program-ও বাতিল করে
  • এটি একটি ভুল বাস্তবায়ন, যা ঠিক করলে complete হয়ে যাবে
  • এটি নিশ্চিত করে যে program কখনো কোনো runtime error দেবে না

শেখার ভাষা Haat-এ (function-এর parameter আর ফেরত type লিখতে হয়, let-এর type initializer থেকে আসে) let p = 2 * 520; লিখলে কী ঘটে?

  • p dynamic, পরে যেকোনো type-এর মান রাখতে পারে
  • Compile error, কারণ type লেখা হয়নি
  • Checker নিজে p-এর type Int বের করে স্থির রাখে (local inference)
  • p-এর type চলার সময় প্রথম ব্যবহারে ঠিক হয়

TypeScript-এ type Taka = number; type Kg = number; লিখে pay(amount: Taka)-এ একটি Kg মান দিলে tsc --strict কী বলে, আর কেন?

  • Error, কারণ TypeScript nominal
  • চলার সময় error হয়
  • শুধু একটি warning
  • কোনো error নেই, কারণ দুটিই number-এর alias আর TypeScript structural

শব্দকোষ

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

মনে রাখুন

  1. Type system লেখা দেখে প্রতিটি expression-কে type দেয় আর প্রমাণ করে যে নির্দিষ্ট কিছু ভুল ঘটবে না; Haat-এ শূন্য দিয়ে ভাগ সেই তালিকায় নেই।
  2. Trapped ভুল সঙ্গে সঙ্গে থামায় (TypeError), untrapped নীরবে চলে (C-র total + " taka"); untrapped অসম্ভব হলে ভাষা safe.
  3. Static যাচাই সব পথ দেখে চালানোর আগে, dynamic যাচাই শুধু যে পথ চলে; TypeScript সব type মুছে ফেলে।
  4. Strong/weak ঝাপসা; তার বদলে তিন প্রশ্ন: কখন যাচাই, কতটা রূপান্তর, safe কি না। আলাদা অক্ষ: explicit/inferred আর nominal/structural.
  5. Sound কিন্তু incomplete: গৃহীত program নিরাপদ, কিছু নিরাপদ program বাতিল; Rice-এর theorem দুটো একসাথে হতে দেয় না।

পরের পর্বে: পর্ব ৩৪ (Typing rule আর type judgment — type checking-এর গণিত)। Haat-এর প্রতিটি expression আর statement-এর নিয়ম inference rule আকারে, price(2, 520) + 60-এর derivation tree নিচ থেকে ওপরে, আর একটি ব্যর্থ derivation কোথায় আটকে যায়।

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

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