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

Algebraic data type আর pattern matching

Algebraic Data Types and Pattern Matching

Taught in Bangla, this lesson builds algebraic data types from product and sum types, counting values with |A × B| and |A + B| to expose invalid states. One Payment type is written in Rust, Haskell, Java 21, TypeScript and Python, then matched arm by arm with bindings and guards. A stepper runs an exhaustiveness check that finds a missing Card case, and Python's match is shown doing nothing when no arm fits. It covers Option and Result, an AST as a recursive ADT and compiling matches to decision trees.

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

  • Product আর sum type চেনা, আর কোনো type-এর মানের সংখ্যা গুনে নকশার ভুল ধরা (প্রমাণসহ)
  • একই বাজারঘরের Payment type Rust, Haskell, Java 21, TypeScript আর Python-এ লেখা আর তুলনা করা
  • Pattern matching-এর নিয়ম (ক্রম, binding, guard) আর exhaustiveness check-এর algorithm হাতে চালানো
  • Option আর Result দিয়ে null আর exception এড়ানো; recursive ADT হিসেবে Haat-এর AST পড়া
  • Haat-এর বর্ধিত রূপে enum আর match নকশা করা, আর compiler কীভাবে match-কে decision tree-তে নামায় তা বোঝা

১ · “এবং” আর “অথবা” — algebraic data type কী

বাজারঘরের একটি অর্ডার স্লিপে লেখা থাকে: পরিমাণ এবং একক দাম এবং ঠিকানা। সবগুলো ঘরই একসাথে পূরণ করতে হয়। কিন্তু পেমেন্টের ঘরটি আলাদা: ক্রেতা নগদ দেবেন, অথবা কার্ডে, অথবা bKash-এ। তিনটির ঠিক একটি। আর প্রতিটি বিকল্পের সঙ্গে আলাদা তথ্য লাগে: কার্ড হলে টাকার অঙ্ক, bKash হলে নম্বর, নগদে কিছুই না।

প্রায় সব ডেটার গঠন এই দুটি জোড়ার নিয়মেই লেখা যায়। “এবং”-এর নাম product type: record, struct, tuple. “অথবা”-এর নাম sum type: কয়েকটি বিকল্পের একটি, সঙ্গে একটি চিহ্ন যা বলে কোনটি। এই দুই নিয়ম বারবার প্রয়োগ করে (দরকারে নিজের ভেতরেও) যে type তৈরি হয়, তাকে বলে algebraic data type (ADT). সাবধান: data structure-এর বইয়ে “ADT” মানে প্রায়ই abstract data type (stack, queue-এর মতো interface); এখানে ADT মানে algebraic.

সংজ্ঞা ২৪.১ — Product, sum আর constructor

A আর B দুটি type হলে product A × B-এর মান হলো জোড়া (a, b), যেখানে a ∈ A আর b ∈ B. Sum A + B-এর মান হলো হয় inl(a), নয় inr(b): বাঁ বা ডান বিকল্প, সঙ্গে চিহ্ন। চিহ্নসহ এই মোড়ক inl, inr-এর সাধারণ নাম constructor; বাস্তব ভাষায় এদের নাম আমরা নিজে দিই, যেমন Cash, Card, Bkash. চিহ্নটিই বাস্তবায়নে type tag.

Record, tuple আর C-র union কেমন দেখতে, কোথায় কোন byte-এ বসে, আর ট্যাগ ছাড়া union কেন বিপজ্জনক, তা পর্ব ২২-এ (Composite type — array, record, tuple আর union) সত্যিকারের Clang run দিয়ে দেখেছেন; সেখানে tag বদলে দিলে bKash-এর নম্বর কার্ডের অঙ্ক হিসেবে ছাপা হয়েছিল। এই পর্বের প্রশ্ন অন্য: ভাষা নিজে যদি “অথবা”-কে type-এর অংশ বানায়, তবে type checker কী কী নিশ্চয়তা দিতে পারে, আর compiler তা কীভাবে বাস্তবায়ন করে?

Haat v1-এ শুধু Int Bool Str Unit আর function type; record বা sum type নেই। তাই এই পর্বের Haat কোড Haat-এর বর্ধিত রূপ: একটি প্রস্তাব, যা reference বাস্তবায়ন করে না; পাতার Python কোড ধারণাটি চালিয়ে দেখায়। পর্ব ২২-এর record Order { qty: Int, unit: Int }-এর পাশে নতুন প্রস্তাব:

// Haat-এর বর্ধিত রূপ (reference-এ নেই)
enum Payment { Cash, Card(Int), Bkash(Str) }

fn fee(pay: Payment) -> Int {
    match pay {
        Cash => { return 0; }
        Card(a) if a >= 10000 => { return a / 100; }
        Card(a) => { return 50; }
        Bkash(n) => { return 20; }
    }
}
print(fee(Card(12000)));   // 120
print(fee(Cash));          // 0

Lexer-এ লাগবে নতুন keyword enum match আর নতুন token =>; parser-এ pattern-এর ব্যাকরণ; type checker-এ দুটি নতুন নিয়ম (অংশ ৪)। Reference-এর নকশা-সিদ্ধান্ত ২১ (missing return-এর syntactic নিয়ম) এখানে বাড়াতে হবে: যে match সব ক্ষেত্র ধরে আর যার প্রতিটি arm return করে, সেটিও “return করে” বলে গণ্য। নইলে ওপরের fee নিজেই missing return error পেত। মন্তব্যের 120 আর 0 অংশ ৭-এর Python মডেল চালিয়ে মেলানো।

২ · মান গোনা — নামটি কেন “algebraic”

একটি type-কে মানের সেট হিসেবে ভাবলে (পর্ব ২০-এর সংজ্ঞা) প্রশ্ন ওঠে: কতগুলো মান? |T| দিয়ে লিখি T-এর মানের সংখ্যা। |Bool| = 2, |Unit| = 1 (একটিমাত্র মান), আর বাজারঘরের ডেলিভারির সময় enum Slot { Morning, Evening, Night } হলে |Slot| = 3.

উপপাদ্য ২৪.১ — গুণ আর যোগ

A আর B সসীম type হলে |A × B| = |A| · |B| আর |A + B| = |A| + |B|. আর function type A → B-এর (পার্শ্ব-প্রতিক্রিয়াহীন, সব input-এ থামে এমন function ধরে) |A → B| = |B||A|.

প্রমাণ।

  1. A × B-এর প্রতিটি মান একটি জোড়া (a, b). a বাছার |A|টি উপায়, প্রতিটির জন্য b বাছার |B|টি উপায়, আর দুটি জোড়া সমান শুধু যখন দুই অবস্থানই সমান। গণনার গুণের নিয়মে মোট |A| · |B|.
  2. A + B-এর মান হয় inl(a), নয় inr(b). inl মোড়কটি এক-এক (আলাদা a থেকে আলাদা inl(a)), তাই inl-এর ছবিতে |A|টি মান; একইভাবে inr-এর ছবিতে |B|টি।
  3. চিহ্ন আলাদা, তাই কোনো inl(a) কোনো inr(b)-এর সমান নয়: দুটি ছবি পরস্পর-বিচ্ছিন্ন। বিচ্ছিন্ন সেটের মিলনের আকার আকারগুলোর যোগফল, তাই |A + B| = |A| + |B|.
  4. A → B-এর একটি function মানে A-র প্রতিটি মানের জন্য B থেকে একটি উত্তর বাছা: |A|টি স্বাধীন বাছাই, প্রতিটিতে |B|টি উপায়, মোট |B||A|. ∎

ধাপ ৩-এর চিহ্নটিই সব কিছু। চিহ্ন ছাড়া সাধারণ সেটের মিলন নিলে Bool ∪ Bool-এ মান মাত্র ২টি, কারণ দুই পাশের true মিশে যায়; চিহ্নসহ Bool + Bool-এ ৪টি। গুণ আর যোগের নিয়মটি Discrete Mathematics কোর্সের পর্ব ৩১-এ (গণনার মূল নিয়ম) বিস্তারে আছে। Stepper-এ দুটি type পাশাপাশি গুনে দেখুন:

1enum Slot { Morning, Evening, Night }2record Order { express: Bool, slot: Slot }3enum Pick { BySlot(Slot), ByFlag(Bool) }4|Order| = |Bool| · |Slot|5|Pick|  = |Slot| + |Bool|
এ পর্যন্ত গোনা
Order
Pick
  1. উপাদান। Slot-এর তিনটি মান, Bool-এর দুটি। এই দুটি দিয়ে একটি product আর একটি sum বানানো হবে।
  2. Product, প্রথম সারি। Order-এ দুটি ঘরই থাকে। express = false ধরে slot-এর তিনটি বাছাই: তিনটি আলাদা অর্ডার।
  3. Product, দ্বিতীয় সারি। express = true-এর জন্যও তিনটি। প্রতিটি express-মানের জন্য পুরো Slot আবার আসে, তাই 3 × 2 = 6: গুণ।
  4. Sum, প্রথম বিকল্প। Pick-এ দুটির একটিমাত্র ঘর থাকে। BySlot চিহ্নের সঙ্গে Slot-এর তিনটি মান।
  5. Sum, দ্বিতীয় বিকল্প। ByFlag চিহ্নের সঙ্গে Bool-এর দুটি মান। বিকল্পগুলো পাশাপাশি বসে, একটির ভেতরে আরেকটি নয়, তাই 3 + 2 = 5: যোগ।

সূত্রগুলো শুধু তত্ত্ব নয়; নিচের block প্রতিটি type-এর সব মান সত্যিই তৈরি করে গোনে, তারপর সূত্রের সঙ্গে মেলায়।

from itertools import product

Slot = ["Morning", "Evening", "Night"]       # ডেলিভারির সময়: 3টি মান
Bool = [False, True]                          # 2টি মান
Unit = [()]                                   # 1টি মান

def prod(A, B):            # A × B: A থেকে একটি এবং B থেকে একটি
    return [(a, b) for a in A for b in B]

def sum_(A, B):            # A + B: ট্যাগ আর একটি payload
    return [("L", a) for a in A] + [("R", b) for b in B]

def funcs(A, B):           # A -> B: A-র প্রতিটি মানের জন্য একটি B
    return [dict(zip(A, outs)) for outs in product(B, repeat=len(A))]

def option(A):             # Option<A> = Unit + A
    return sum_(Unit, A)

checks = [
    ("Slot x Bool", prod(Slot, Bool), 3 * 2),
    ("Slot + Bool", sum_(Slot, Bool), 3 + 2),
    ("Bool + Bool", sum_(Bool, Bool), 2 + 2),
    ("Option<Bool>", option(Bool), 1 + 2),
    ("Option<Option<Bool>>", option(option(Bool)), 1 + (1 + 2)),
    ("Bool -> Slot", funcs(Bool, Slot), 3 ** 2),
    ("Slot x (Bool + Unit)", prod(Slot, sum_(Bool, Unit)), 3 * (2 + 1)),
    ("Slot x Bool + Slot x Unit", sum_(prod(Slot, Bool), prod(Slot, Unit)), 6 + 3),
]
for name, values, formula in checks:
    print(f"{name:26} enumerated={len(values):2} formula={formula:2}")
print("untagged set union of Bool, Bool:", len(set(Bool) | set(Bool)))
print("first 4 of Slot + Bool:", sum_(Slot, Bool)[:4])

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

Slot x Bool                enumerated= 6 formula= 6
Slot + Bool                enumerated= 5 formula= 5
Bool + Bool                enumerated= 4 formula= 4
Option<Bool>               enumerated= 3 formula= 3
Option<Option<Bool>>       enumerated= 4 formula= 4
Bool -> Slot               enumerated= 9 formula= 9
Slot x (Bool + Unit)       enumerated= 9 formula= 9
Slot x Bool + Slot x Unit  enumerated= 9 formula= 9
untagged set union of Bool, Bool: 2
first 4 of Slot + Bool: [('L', 'Morning'), ('L', 'Evening'), ('L', 'Night'), ('R', False)]

প্রতিটি সারিতে তৈরি করা মানের সংখ্যা সূত্রের সমান। Option<Bool> = 1 + 2 = 3: “কিছু নেই” আর দুটি Bool. শেষ দুই type-এর মান সমান (৯), কারণ বীজগণিতের বিভাজ্যতা খাটে: A × (B + C) আর A × B + A × C-এর মধ্যে একটি এক-এক মিল (type isomorphism) আছে। চিহ্নহীন সেট-মিলনে Bool দুবার নিলেও ২টি মানই থাকে; চিহ্নসহ sum-এ ৪টি। শেষ লাইনে দেখুন প্রতিটি মান আসলে (চিহ্ন, payload) জোড়া; অংশ ৩-এ বাস্তব ভাষার tagged union ঠিক এভাবেই মেমরিতে থাকে।

বীজগণিতের পরিচিত নিয়মগুলো type-এও খাটে, সমান চিহ্নের বদলে isomorphism ধরে। A × 1 ≅ A: একটি ঘরের পাশে সবসময় একই মানের (Unit) আরেকটি ঘর রাখলে নতুন কোনো তথ্য আসে না। Bool ≅ 1 + 1: Bool আসলে দুটি তথ্যহীন বিকল্পের sum, তাই অনেক ভাষায় enum Bool { False, True } লেখা যায়। আর “শূন্য” type-ও আছে, যার কোনো মানই নেই: TypeScript-এর never, Rust-এর !, Haskell-এর Void. A + 0 ≅ A, কারণ যে বিকল্পের কোনো মান তৈরিই করা যায় না, তা কখনো আসে না। কোনো function-এর ফেরত type শূন্য হলে বোঝায় সেটি কখনো স্বাভাবিকভাবে ফেরে না (সবসময় error ছোড়ে বা চিরকাল চলে); অংশ ৩-এ TypeScript-এর assertNever ঠিক এমন।

গণনার ব্যবহার — অবৈধ অবস্থা ধরা

অনেকে sum type ছাড়া ভাষায় পেমেন্ট এভাবে রাখেন: একটি kind ঘর, একটি card_amount, একটি bkash_number, তিনটিই সবসময়। এটি product, তাই সম্ভাব্য মানের সংখ্যা তিনটির গুণফল; অথচ বৈধ পেমেন্ট মাত্র যোগফলের সমান। বাকি সবগুলো এমন অবস্থা, যা বাস্তবে অর্থহীন: “নগদ, কিন্তু কার্ডের অঙ্ক ৫০০০”। এগুলো ঠেকাতে প্রতিটি function-এ হাতে পরীক্ষা লাগে। Sum type দিয়ে লিখলে এগুলো লেখাই যায় না; functional programming মহলে কথাটি চলে “make illegal states unrepresentable” (অবৈধ অবস্থাকে প্রকাশের অযোগ্য করুন) নামে। অনুশীলন ১-এ একটি ছোট উদাহরণে অবৈধ অবস্থাগুলো গুনে দেখবেন।

৩ · Tagged union — একই Payment পাঁচ ভাষায়

ভাষাভেদে নাম আলাদা: Rust আর Swift-এ enum, Haskell-এ data, OCaml-এ variant, Java 21-এ sealed interface আর record, TypeScript-এ discriminated union. ভেতরের ধারণা একটিই: tagged union, যেখানে ট্যাগ আর payload-এর মিল ভাষা নিজে রক্ষা করে। বাজারঘরের Payment চারটি ভাষায় (উদাহরণ, এখানে চালানো হয়নি):

-- Haskell
data Payment = Cash | Card Int | Bkash String
fee :: Payment -> Int
fee Cash      = 0
fee (Card a) | a >= 10000 = a `div` 100
             | otherwise  = 50
fee (Bkash _) = 20

// Rust
enum Payment { Cash, Card(u32), Bkash(String) }
fn fee(p: &Payment) -> u32 {
    match p {
        Payment::Cash => 0,
        Payment::Card(a) if *a >= 10000 => a / 100,
        Payment::Card(_) => 50,
        Payment::Bkash(_) => 20,
    }
}

// Java 21
sealed interface Payment permits Cash, Card, Bkash {}
record Cash() implements Payment {}
record Card(int amount) implements Payment {}
record Bkash(String number) implements Payment {}
static int fee(Payment p) {
    return switch (p) {
        case Cash c -> 0;
        case Card(int a) when a >= 10000 -> a / 100;
        case Card c -> 50;
        case Bkash b -> 20;
    };
}

লক্ষ্য করুন, চারটি ভাষাতেই payload পড়ার একমাত্র পথ হলো আগে ট্যাগ মেলানো: Card(a) লিখলে তবেই a পাওয়া যায়। পর্ব ২২-এর C-র মতো “ট্যাগ CARD বলে, কিন্তু ভেতরে bKash-এর নম্বর” অবস্থা এখানে তৈরিই করা যায় না। Java-র রূপটি Java কোর্সের পর্ব ২৬-এ, আর C++-এর std::variant C++ কোর্সের পর্ব ৩৮-এ বিস্তারে আছে।

TypeScript আর JavaScript — ট্যাগ একটি সাধারণ ঘর

TypeScript (২.০ সংস্করণ, ২০১৬ থেকে) একটু অন্য পথে যায়: প্রতিটি বিকল্প একটি সাধারণ object, যার একই নামের একটি ঘরে (এখানে kind) আলাদা আলাদা literal মান থাকে। Type checker সেই ঘরের মান দেখে বোঝে এখন কোন বিকল্প। কিন্তু TypeScript compile হয়ে সাধারণ JavaScript হয়, type মুছে যায়। নিচের block সেই মুছে যাওয়া JavaScript, যেখানে ভুল ধরার দায় আবার চলার সময়ের:

// TypeScript-এ: type Payment = {kind:"cash"} | {kind:"card", amount:number}
//                            | {kind:"bkash", number:string}
// JavaScript-এ type নেই; kind ঘরটিই ট্যাগ।
function assertNever(x) {
  throw new Error("unhandled kind: " + JSON.stringify(x));
}

function fee(p) {
  switch (p.kind) {
    case "cash":  return 0;
    case "card":  return p.amount >= 10000 ? Math.trunc(p.amount / 100) : 50;
    case "bkash": return p.number.startsWith("017") ? 20 : 25;
    default:      return assertNever(p);
  }
}

const payments = [
  { kind: "cash" },
  { kind: "card", amount: 12000 },
  { kind: "bkash", number: "01700000000" },
  { kind: "card" },                       // amount নেই: অবৈধ অবস্থা
  { kind: "nagad", number: "01800000000" } // অজানা ট্যাগ
];
for (const p of payments) {
  try { console.log(p.kind, "->", fee(p)); }
  catch (e) { console.log("error:", e.message); }
}

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

cash -> 0
card -> 120
bkash -> 20
card -> 50
error: unhandled kind: {"kind":"nagad","number":"01800000000"}

চতুর্থ লাইনটি নীরব ভুল: amount নেই, undefined >= 10000 মিথ্যা, তাই চার্জ 50, কোনো সতর্কতা ছাড়াই। অজানা ট্যাগ nagad অন্তত default-এ ধরা পড়েছে, কিন্তু শুধু চলার সময়ে। TypeScript এই দুটিই compile-এর সময়ে ধরে। সত্যিকারের run: TypeScript 5.9.2 (Apache-2.0), tsc --noEmit --strict --target es2022 pay.ts, যেখানে একই Payment type, "bkash"-এর case ইচ্ছা করে বাদ, আর const bad: Payment = { kind: "card" };:

pay.ts(14,33): error TS2345: Argument of type '{ kind: "bkash"; number: string; }'
  is not assignable to parameter of type 'never'.
pay.ts(18,7): error TS2322: Type '{ kind: "card"; }' is not assignable to type 'Payment'.
  Property 'amount' is missing in type '{ kind: "card"; }' but required in
  type '{ kind: "card"; amount: number; }'.

(লম্বা লাইন পর্দার জন্য ভাঙা হয়েছে।) প্রথম error-টি একটি সুন্দর কৌশল: প্রতিটি case পার হওয়ার পর TypeScript সম্ভাব্য বিকল্পের তালিকা ছোট করে (narrowing); সব ধরা হলে default-এ বাকি থাকে খালি type never. একটি বিকল্প বাদ পড়লে সেটি never-এ বসতে পারে না, তাই error. খালি type-এর মানের সংখ্যা ০; অংশ ২-এর বীজগণিতে এটিই “শূন্য”। TypeScript-এর মৌলিক পরিচয় আছে JavaScript কোর্সের পর্ব ৪৭-এ.

মেমরিতে একটি tagged union সাধারণত একটি ছোট ট্যাগ আর সবচেয়ে বড় payload-এর সমান জায়গা (সঙ্গে alignment-এর padding, পর্ব ২৫-এর বিষয়)। Payment-এর জন্য তিন বিকল্পের ট্যাগ ২ বিটেই ধরে, কিন্তু বাস্তবে অন্তত একটি byte নেওয়া হয়। Rust একটি কৌশল নিশ্চিত করে (std-এর documentation-এ লেখা): Option<&T> বা Option<Box<T>>-এর আকার একটি pointer-এর সমান, কারণ বৈধ reference কখনো শূন্য ঠিকানা নয়, তাই শূন্য ঠিকানাটিই None-এর ট্যাগ হিসেবে কাজ করে। একে বলে null pointer optimization; ট্যাগের জন্য আলাদা byte লাগেই না।

৪ · Pattern matching — মেলানো, খুলে নেওয়া আর guard

ডাকঘরে চিঠি বাছাইয়ের কথা ভাবুন। কর্মী প্রথমে খামের ওপরের ছাপ দেখেন: রেজিস্টার্ড, পার্সেল না সাধারণ চিঠি। ছাপ মিললে তবেই খাম খুলে ভেতরের তথ্য পড়েন, আর কিছু ক্ষেত্রে বাড়তি শর্ত দেখেন (“ওজন ২ কেজির বেশি হলে আলাদা তাক”)। নিয়মের তালিকা ওপর থেকে নিচে পড়া হয়; প্রথম যে নিয়ম খাটে, সেটিই চূড়ান্ত। Pattern matching ঠিক এই কাজ করে।

একটি match-এ কয়েকটি arm; প্রতিটি arm-এ একটি pattern, ঐচ্ছিক একটি guard (বাড়তি if শর্ত) আর একটি দেহ। Pattern-এর ধরন:

Patternউদাহরণকখন মেলে, কী বাঁধে
ConstructorCard(a)ট্যাগ Card হলে; ভেতরের মানের সঙ্গে ভেতরের pattern মেলানো হয়
Variableaসবসময়; মানটি নামে বাঁধে
Wildcard_সবসময়; কিছুই বাঁধে না
LiteralCard(5000)মান হুবহু সমান হলে
NestedSome(Card(a))বাইরের আর ভেতরের দুটিই মিললে

মেলার সময়ই ভেতরের অংশ নামে বাঁধা হয়ে যায়; একে বলে destructuring. ফলে “ট্যাগ পরীক্ষা” আর “মান বের করা” এক কাজে মিশে যায়, আলাদা করে ভুল করার সুযোগ থাকে না। নিচে Card(7500) মানটি অংশ ১-এর fee-এর arm-গুলোর মধ্য দিয়ে যাচ্ছে:

1match pay {2  Cash => { return 0; }3  Card(a) if a >= 10000 => { … }4  Card(a) => { return 50; }5  Bkash(n) => { return 20; }6}
মেলানোর অবস্থা
ট্যাগ
payload
binding
  1. Subject. pay একবারই হিসাব হয়: ট্যাগ Card, payload 7500. এরপর arm-গুলো ওপর থেকে নিচে।
  2. Arm ১, Cash. ট্যাগ আলাদা, তাই সঙ্গে সঙ্গে ব্যর্থ। কোনো binding হয়নি।
  3. Arm ২, guard-সহ। ট্যাগ মিলেছে, a = 7500 বাঁধা হলো, তারপর guard a >= 10000 হিসাব: মিথ্যা। Arm বাতিল, আর এই arm-এর binding-ও ফেলে দেওয়া হয়।
  4. Arm ৩, Card(a). ট্যাগ মিলেছে, guard নেই: মেলা সম্পূর্ণ। নতুন করে a = 7500 বাঁধা হলো।
  5. দেহ চলে। return 50;. প্রথম মেলা arm-ই চূড়ান্ত, তাই Bkash(n)-এর arm পরীক্ষাই হয় না। অংশ ৭-এর Python মডেলও Card 50 দেয়।

Type checker-এর জন্য দুটি নতুন নিয়ম লাগে। প্রথমটি constructor-এর (C একটি enum E-এর এমন বিকল্প, যার payload-এর type τ):

C(τ) ∈ cases(E)    Γ ⊢ e : τ
Γ ⊢ C(e) : E
(T-Ctor)
Γ ⊢ e : E    ∀i: Ci(τi) ∈ cases(E),  Γ, xi : τi ⊢ gi : Bool,  Γ, xi : τi ⊢ si ok    exhaustive
Γ ⊢ match e { Ci(xi) if gi => si } ok
(T-Match)

পড়ুন: T-Ctor বলে, Card(e)-এর type Payment, যদি e-এর type Int হয়। T-Match বলে, subject-এর type একটি enum E; প্রতিটি arm-এর constructor সত্যিই E-এর; arm-এর দেহ চেক হয় এমন একটি পরিবেশে, যেখানে Γ-এর সঙ্গে বাঁধা নাম xi-এর type τi যোগ হয়েছে (guard না থাকলে gi = true ধরুন); আর শেষ শর্ত “exhaustive”, যা পরের অংশের algorithm. লক্ষ্য করুন, a-এর type কেউ লেখেনি; constructor-এর ঘোষণা থেকেই তা আসে। Typing rule পড়ার পূর্ণ পদ্ধতি পর্ব ৩৪-এ (Typing rule আর type judgment).

Python 3.10 (PEP 634, ২০২১) থেকে একই ধারণা match statement হিসেবে আছে। Dataclass দিয়ে Payment বানিয়ে, সঙ্গে একটি হাতে লেখা exhaustiveness checker:

from dataclasses import dataclass

@dataclass(frozen=True)
class Cash: pass
@dataclass(frozen=True)
class Card: amount: int                 # টাকা
@dataclass(frozen=True)
class Bkash: number: str

def fee(p):                             # বাজারঘরের পেমেন্ট চার্জ (টাকা)
    match p:
        case Cash():                     return 0
        case Card(amount) if amount >= 10000: return amount // 100
        case Card(_):                    return 50
        case Bkash(number=n):            return 20 if n.startswith("017") else 25

for p in [Cash(), Card(12000), Card(7500), Bkash("01700000000"), "nagad"]:
    print(f"{p!r:28} -> fee {fee(p)}")

# হাতে লেখা exhaustiveness checker: arm = (constructor বা "_", সব payload ধরে কি না)
CTORS = ["Cash", "Card", "Bkash"]
def check(arms):
    missing, report = list(CTORS), []
    for i, (ctor, total) in enumerate(arms, 1):
        covers = CTORS if ctor == "_" else [ctor]
        if not any(c in missing for c in covers):
            report.append(f"arm {i} ({ctor}): unreachable")
        if total:                       # guard বা literal থাকলে total নয়
            missing = [c for c in missing if c not in covers]
    report.append("ok" if not missing else "missing: " + ", ".join(missing))
    return report

print(check([("Cash", True), ("Card", False), ("Card", True), ("Bkash", True)]))
print(check([("Cash", True), ("Card", False), ("Bkash", True)]))
print(check([("_", True), ("Cash", True)]))

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

Cash()                       -> fee 0
Card(amount=12000)           -> fee 120
Card(amount=7500)            -> fee 50
Bkash(number='01700000000')  -> fee 20
'nagad'                      -> fee None
['ok']
['missing: Card']
['arm 2 (Cash): unreachable', 'ok']

Card(amount)-এ অবস্থান ধরে মেলানো সম্ভব, কারণ dataclass নিজে থেকে __match_args__ = ('amount',) বানায়; Bkash(number=n) ঘরের নাম ধরে মেলায়। পঞ্চম লাইনটি গুরুত্বপূর্ণ: "nagad" কোনো arm-এ মেলেনি, আর Python কোনো error দেয়নি; match থেকে চুপচাপ বেরিয়ে function শেষে None ফেরত দিয়েছে। Python-এর match exhaustiveness যাচাই করে না। Checker-এর তিন লাইন: প্রথম match-টি সব ধরে (guard-ওয়ালা Card না গুনেও পরের Card(_) আছে); দ্বিতীয়টিতে Card(_) নেই, তাই Card বাকি; তৃতীয়টিতে _ সব নিয়ে নেওয়ার পর Cash-এর arm-এ কখনো পৌঁছানো যায় না। Python-এর match-এর পুরো বাক্যগঠন Python কোর্সের পর্ব ১১-এ.

৫ · Exhaustiveness — কোনো ক্ষেত্র বাদ পড়ল কি না

বাজারঘর কাল থেকে Nagad-এ পেমেন্ট নেবে। enum Payment-এ একটি বিকল্প যোগ হলো। এখন কোডের কোন কোন জায়গায় Nagad সামলাতে হবে? Sum type-এর সবচেয়ে বড় উপহার এখানে: compiler প্রতিটি match পরীক্ষা করে বলে দেয় কোথায় নতুন বিকল্পটি বাদ পড়েছে। একে বলে exhaustiveness check. সঙ্গে আরেকটি পরীক্ষা: কোনো arm কি কখনোই পৌঁছানো যায় না? সেটি redundant pattern (unreachable arm).

Flat enum-এর জন্য (pattern-এর ভেতরে শুধু variable বা _) algorithm সরল:

  1. missing = enum-এর সব constructor-এর সেট।
  2. প্রতিটি arm ওপর থেকে নিচে: arm যে constructor-গুলো ধরতে পারে (_ হলে সবগুলো), তার কোনোটিই যদি আর missing-এ না থাকে, তবে arm-টি unreachable.
  3. Arm-এ guard বা literal payload না থাকলে, তার constructor-গুলো missing থেকে বাদ। Guard থাকলে বাদ নয়: guard মিথ্যাও হতে পারে, আর compiler সাধারণত guard-এর ভেতরের যুক্তি বোঝে না।
  4. শেষে missing খালি না হলে error, সঙ্গে বাদ পড়া constructor-এর নাম, যাতে প্রোগ্রামার জানেন কোন উদাহরণ মেলে না।
1enum Payment { Cash, Card(Int), Bkash(Str) }2fn fee(pay: Payment) -> Int {3    match pay {4        Cash => { return 0; }5        Card(a) if a > 0 => { … }6        Bkash(_) => { return 20; }7    }
Checker-এর অবস্থা
missing
এই arm
  1. শুরু। Enum-এর ঘোষণা থেকে missing = {Cash, Card, Bkash}. এখনো কোনো arm দেখা হয়নি।
  2. Arm Cash. Cash এখনো missing-এ আছে, তাই arm-টি পৌঁছানো যায়। Guard নেই, তাই Cash বাদ: missing = {Card, Bkash}.
  3. Arm Card(a) if a > 0. Card missing-এ আছে, arm পৌঁছানো যায়। কিন্তু guard আছে: Card(0) বা Card(-5) এখানে মিলবে না। তাই Card বাদ যায় না।
  4. Arm Bkash(_). Wildcard যেকোনো নম্বর ধরে, guard নেই, তাই Bkash বাদ: missing = {Card}.
  5. শেষ। missing খালি নয়। Error-এর অবস্থান match keyword (লাইন ৩, কলাম ৫), Haat-এর বার্তার ধাঁচে: 3:5: error: non-exhaustive match: missing 'Card'. উদাহরণ মান: Card(0).

বাস্তব compiler-গুলো একই কাজ করে, বার্তা আলাদা। Rust-এ অসম্পূর্ণ match একটি compile error (E0004, “non-exhaustive patterns”, সঙ্গে বাদ পড়া pattern-এর উদাহরণ); OCaml-এ warning 8; Haskell-এর GHC-তে -Wincomplete-patterns (যা -Wall-এর অংশ) warning দেয়; Java 21-এ pattern-ওয়ালা switch সব ক্ষেত্র না ধরলে compile error. এগুলো এখানে চালানো হয়নি; বার্তার ভাষা version-ভেদে বদলায়, আর Haskell-এ ডিফল্টে কোন warning চালু থাকে তা GHC-র version-এর ওপর নির্ভর করে। Exhaustiveness, definite assignment আর unreachable code একসঙ্গে বাস্তবায়ন হবে পর্ব ৫৪-এ (অন্য semantic check).

Guard-এর ফাঁদ: Card(a) if a >= 10000 আর Card(a) if a < 10000 দুটি arm মিলে গণিতে সব Card ধরে, কিন্তু উপরের algorithm বলবে Card বাকি। এটি ইচ্ছাকৃত রক্ষণশীলতা: guard-এর যুক্তি সাধারণভাবে বিচার করা undecidable সমস্যার দিকে যায় (Rice-এর উপপাদ্য, গণনার তত্ত্ব কোর্সের পর্ব ৫৩)। সমাধান সহজ: শেষ arm guard ছাড়া লিখুন, Card(a) => ….

সত্যিকারের run — Python-এর একমাত্র static check

Python-এর match বাদ পড়া ক্ষেত্র ধরে না, কিন্তু একটি ভুল compile-এর সময়ই ধরে। CPython 3.14.4-এ এই ফাইল চালানো হলো:

match p:
    case Cash:
        fee = 0
    case Card(amount):
        fee = 50

~/haat $ python pay.py
  File "pay.py", line 2
    case Cash:
         ^^^^
SyntaxError: name capture 'Cash' makes remaining patterns unreachable

বন্ধনী ছাড়া Cash Python-এ class pattern নয়, একটি capture pattern: “যেকোনো মান নিয়ে তার নাম Cash রাখা”. তাই এটি সব মান ধরে, আর পরের সব arm অপ্রাপ্য। এটি ঠিক উপরের algorithm-এর ধাপ ২-এর redundancy check. ঠিক রূপ case Cash():. পুরো match-এ শুধু শেষ arm হলে বন্ধনীহীন নাম বৈধ, আর তখন ভুলটি নীরবে থেকে যায়: সব পেমেন্টকে নগদ ধরা হয়।

৬ · Option আর Result — null আর exception-এর বদলে type

পর্ব ০৬-এ দেখেছেন, Tony Hoare ১৯৬৫ সালে ALGOL W-এ null reference আনেন, আর পরে নিজেই একে “billion-dollar mistake” বলেন; সেখানে option type-এর নাম এসেছিল। এখন এর গঠন পরিষ্কার: Option<T> = Unit + T, অর্থাৎ None অথবা Some(t). মানের সংখ্যা 1 + |T|. সমস্যাটি null-এর নয়, null-কে type-এ না লেখার: Java-য় String type-এর মান আসলে “String অথবা null”, অথচ type বলে শুধু String. Option সেই লুকানো “+ 1”-কে প্রকাশ্যে আনে, আর Some খুলতে হলে match লাগে, যেখানে None ধরতে exhaustiveness বাধ্য করে।

Haat v1-এ generic type নেই, তাই Haat-এর বর্ধিত রূপে Option লিখতে হবে নির্দিষ্ট type ধরে। বাজারঘরে পণ্য-কোড দিয়ে দাম খোঁজা:

// Haat-এর বর্ধিত রূপ (reference-এ নেই)
enum PriceLookup { NotFound, Found(Int) }
enum PayResult { Paid(Int), Failed(Str) }

fn price_of(code: Int) -> PriceLookup {
    if code == 101 { return Found(520); }
    return NotFound;
}
fn charge(code: Int, qty: Int) -> PayResult {
    match price_of(code) {
        Found(unit) => { return Paid(unit * qty); }
        NotFound => { return Failed("unknown product"); }
    }
}

সব type-এর জন্য একটি Option<T> লিখতে parametric polymorphism লাগে (পর্ব ৩৬-এ, Polymorphism). দ্বিতীয় enum-টি Result type-এর একটি রূপ: সফল হলে মান, ব্যর্থ হলে কারণ। এটি exception-এর বিকল্প; ব্যর্থতা এখানে একটি সাধারণ ফেরত মান (error value), কিন্তু type-এ লেখা, তাই উপেক্ষা করা যায় না। Rust-এর Result<T, E> আর ? operator (ব্যর্থ হলে সঙ্গে সঙ্গে ফেরত) এই পথের সবচেয়ে পরিচিত রূপ। Exception কীভাবে stack ভেঙে উঠে যায় আর দুটির তুলনা, পর্ব ২৮-এ (Exception handling).

উপায়গঠনমানের সংখ্যাঝুঁকি
Java-র reference (null সম্ভব)লুকানো 1 + T1 + |T|type-এ দেখা যায় না; NullPointerException
Rust Option<T>, Haskell Maybe a1 + T1 + |T|নেই; match বাধ্যতামূলক
Go-র (value, err)T × (1 + E)|T| · (1 + |E|)দুটিই থাকা বা দুটিই না-থাকা অবস্থাও type-এ বৈধ
Rust Result<T, E>T + E|T| + |E|ঠিক একটি; ভুল মিশ্রণ সম্ভব নয়

শেষ দুই সারি অংশ ২-এর গণনার সরাসরি প্রয়োগ: Go-র জোড়া একটি product, তাই “মানও আছে, error-ও আছে”-এর মতো অবস্থা type-এ সম্ভব; Go-র প্রথা (আগে err দেখা) মানুষের শৃঙ্খলায় চলে, type-এ নয়। Result একটি sum, তাই অবস্থার সংখ্যা ঠিক যতটি দরকার ততটি। Java-র Optional এই ধারণা লাইব্রেরি হিসেবে আনে (Java কোর্সের পর্ব ৩৬), আর pointer-এর জগতে null-এর সমস্যা পর্ব ২৩-এ (Pointer আর reference).

৭ · Recursive ADT — list, tree আর Haat-এর AST নিজেই

একটি sum type-এর বিকল্প নিজের type-কেই ধারণ করতে পারে। বাজারঘরের অর্ডারের পণ্য-তালিকা: হয় খালি, নয় একটি পণ্য আর বাকি তালিকা। Haskell-এ data List = Nil | Cons Int List. গাছও তাই: data Tree = Leaf | Node Tree Int Tree. এদের বলে recursive data type. গণনার ভাষায় L = 1 + Int × L: দৈর্ঘ্য ০, ১, ২… এর তালিকা মিলিয়ে অসীম সেট।

Compiler-এর জন্য সবচেয়ে গুরুত্বপূর্ণ recursive ADT হলো abstract syntax tree. Haat-এর expression ঠিক একটি sum type: Expr = Num(Int) + Str(Str) + Bool(Bool) + Var(name) + Unary(op, Expr) + Binary(op, Expr, Expr) + Call(Expr, list of Expr) + Lambda(…). Reference-এর ast_nodes.py-তে প্রতিটি বিকল্প একটি dataclass, আর If-এর else_ ঘরটি নিজেই একটি ছোট sum: None, একটি Block অথবা আরেকটি If. Reference-এর interpreter isinstance-এর শিকল দিয়ে বিকল্প বাছে, যা হাতে লেখা pattern matching.

ছবি ২৪.১ — p - p / 10-এর AST, একটি recursive ADT-র মান

প্রতিটি বাক্স একটি constructor, তীর তার Expr-ঘর

AST of p - p / 10 as constructors: Binary("-", Var("p"), Binary("/", Var("p"), Num(10))), with the sum type Expr below Binary op = "-" Var "p" Binary op = "/" Var "p" Num 10 left right Expr = Num ∣ Var ∣ Unary ∣ Binary ∣ Call …
ছবি ২৪.১ — bazar.haat-এর price function-এর return p - p / 10;. প্রতিটি node একটি constructor-এর মান; Binary-এর left আর right ঘর আবার Expr, তাই গাছটি recursive. Interpreter এই গাছের ওপর একটি match চালায়: কোন constructor, সেই অনুযায়ী কাজ।

নিচের block reference-এর নাম (Num Var Binary) রেখে একটি ছোট evaluator লেখে, যেখানে প্রতিটি AST node-এর জন্য একটি case. সঙ্গে Haat-এর বর্ধিত রূপের দুটি নতুন node: Ctor (যেমন Card(12000)) আর Match. ভাগ C-র মতো শূন্যের দিকে কাটে আর গুণ ৬৪ বিটে wrap করে (reference-এর সিদ্ধান্ত ১৩); শূন্য দিয়ে ভাগের পরীক্ষা জায়গা বাঁচাতে বাদ।

from dataclasses import dataclass

@dataclass
class Num: value: int
@dataclass
class Var: name: str
@dataclass
class Binary: op: str; left: object; right: object
@dataclass
class Ctor: name: str; arg: object              # Haat-এর বর্ধিত রূপ: Card(e)
@dataclass
class Match: subject: object; arms: list        # [(ctor, var, guard, body)]
def wrap(n): return (n + 2**63) % 2**64 - 2**63
def cdiv(a, b): q = abs(a) // abs(b); return wrap(q if (a < 0) == (b < 0) else -q)
OPS = {"-": lambda a, b: wrap(a - b), "*": lambda a, b: wrap(a * b),
       "/": cdiv, ">=": lambda a, b: a >= b}
def ev(e, env):
    match e:
        case Num(v): return v
        case Var(name): return env[name]
        case Binary(op, l, r): return OPS[op](ev(l, env), ev(r, env))
        case Ctor(name, arg): return (name, None if arg is None else ev(arg, env))
        case Match(subject, arms):
            tag, payload = ev(subject, env)
            for ctor, var, guard, body in arms:
                inner = {**env, var: payload} if var else env
                if ctor == tag and (guard is None or ev(guard, inner)):
                    return ev(body, inner)
            return f"runtime error: no arm for {tag}"
print(ev(Binary("-", Var("p"), Binary("/", Var("p"), Num(10))), {"p": 1040}))
fee = lambda pay: Match(pay, [("Cash", None, None, Num(0)),
    ("Card", "a", Binary(">=", Var("a"), Num(10000)), Binary("/", Var("a"), Num(100))),
    ("Card", "a", None, Num(50))])                                 # Bkash নেই!
for pay in [Ctor("Cash", None), Ctor("Card", Num(12000)), Ctor("Card", Num(7500)), Ctor("Bkash", Num(0))]:
    print(pay.name, ev(fee(pay), {}))

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

936
Cash 0
Card 120
Card 50
Bkash runtime error: no arm for Bkash

প্রথম লাইন ছবি ২৪.১-এর গাছ, p = 1040: 1040 − 104 = 936, ঠিক bazar.haat-এর price(2, 520)-এর মান। পরের তিন লাইন অংশ ১-এর fee-এর মতো (Bkash-এর arm ইচ্ছা করে বাদ)। শেষ লাইনটিই exhaustiveness check-এর মূল্য: static check না থাকলে বাদ পড়া ক্ষেত্র ধরা পড়ে শুধু চলার সময়, তাও যদি ঠিক সেই মানটি আসে। ev নিজেও একটি match, আর Python এখানেও পাহারা দেয় না: Unary node দিলে কোনো arm মেলে না, ev চুপচাপ None ফেরত দেয়; পূর্ণ interpreter-এ শেষে একটি case _: দিয়ে error তোলা উচিত। Tree-walking interpreter-এর পূর্ণ রূপ আসবে পর্ব ৫৬-এ।

Recursive ADT-এর ওপর match-ভিত্তিক function-এর একটি সুবিধা হলো যুক্তি দেওয়া সহজ। প্রতিটি recursive ডাক ছোট একটি অংশের ওপর, তাই ফাঁকা বা মৌলিক ক্ষেত্রে দাবি দেখিয়ে আর ছোট অংশে সত্য ধরে বড়টিতে দেখালেই সব মানের জন্য প্রমাণ হয়ে যায়: structural induction. যেমন, ev যদি শুধু Num Var Binary নিয়ে চলে আর OPS-এর প্রতিটি কাজ থামে, তবে প্রতিটি সসীম গাছে ev থামে: Num আর Var-এ সরাসরি, Binary-তে দুই ছোট গাছে থামার পরে। পদ্ধতিটির বিস্তার Discrete Mathematics কোর্সের পর্ব ১২-এ.

৮ · Pattern matching compile করা — decision tree

Compiler একটি match-কে কীভাবে যন্ত্রের নির্দেশে নামায়? সহজ পথ: arm ধরে ধরে পরীক্ষা, ঠিক stepper-এর মতো। সমস্যা হলো একই প্রশ্ন বারবার করা: “ট্যাগ কি Card?” প্রশ্নটি arm ২ আর arm ৩ দুবার জিজ্ঞেস করে। সত্যিকারের run, CPython 3.14.4-এর dis, এই function-এর ওপর:

def fee(p):
    match p:
        case Card(amount) if amount >= 10000:
            return amount // 100
        case Card(_):
            return 50
        case _:
            return 0

  9           COPY                     1
              LOAD_GLOBAL              0 (Card)
              LOAD_CONST               0 (())
              MATCH_CLASS              1
              COPY                     1
              POP_JUMP_IF_NONE        20 (to L1)
              …
              COMPARE_OP             188 (bool(>=))
              POP_JUMP_IF_FALSE       12 (to L2)
              …
 11   L2:     LOAD_GLOBAL              0 (Card)
              LOAD_CONST               0 (())
              MATCH_CLASS              1
              COPY                     1
              POP_JUMP_IF_NONE         6 (to L3)

(মাঝের কয়েকটি নির্দেশ বাদ; বাঁয়ের 9 আর 11 মূল ফাইলের লাইন নম্বর, সেখানে function শুরু হয়েছিল লাইন ৭-এ।) MATCH_CLASS দুবার এসেছে: guard মিথ্যা হলে CPython আবার Card পরীক্ষা করে। Python-এ এটি যুক্তিসংগত, কারণ class pattern-এ isinstance চলে, যা subclass-এর জন্যও সত্য, আর ক্রম রক্ষা করা জরুরি। কিন্তু Rust, OCaml বা Haskell-এর মতো বন্ধ sum type-এ ট্যাগ একটি ছোট পূর্ণসংখ্যা, তাই compiler একবার ট্যাগ পড়ে সরাসরি শাখায় যেতে পারে: একটি decision tree. অংশ ১-এর fee-এর জন্য:

প্রশ্ন ১: ট্যাগ?প্রশ্ন ২কোন arm চলে
Cash (0)—arm ১: return 0
Card (1)a = payload; a >= 10000 সত্যarm ২: return a / 100
a >= 10000 মিথ্যাarm ৩: return 50
Bkash (2)—arm ৪: return 20

ট্যাগ ০, ১, ২ হলে প্রথম প্রশ্নটি একটি jump table হতে পারে: ট্যাগকে index ধরে ঠিকানার টেবিল থেকে সরাসরি লাফ। প্রতিটি পরীক্ষা একবারই হয়। বিনিময়ে একটি ঝুঁকি আছে: nested pattern-এ (যেমন (Card(a), Express)-এর মতো tuple-এর pattern) গাছ বড় হতে পারে, কারণ এক arm-এর দেহ একাধিক পাতায় কপি হয়। বিকল্প পথ backtracking automaton: কোড ছোট, কিন্তু কিছু পরীক্ষা আবার হতে পারে। Haat-এর VM-এ (পর্ব ৫৯) এর জন্য নতুন opcode লাগবে, যেমন একটি enum মান বানানো, ট্যাগ পড়ে টেবিল ধরে লাফ, আর payload বের করা; reference-এর ৩১টি opcode-এ এদের কোনোটি নেই, তাই এটিও বর্ধিত রূপের প্রস্তাব।

Algebraic data type আর pattern matching আজকের রূপে প্রথম দেখা যায় Hope ভাষায় (Rod Burstall, David MacQueen, Don Sannella; ১৯৮০ সালের দিকে Edinburgh-এ), যার আগে Burstall আর Darlington-এর NPL-এ এর বীজ ছিল; সেখান থেকে Standard ML আর পরে Haskell (১৯৯০) এটি নেয়। এরপর ধারণাটি মূলধারায় আসে ধীরে: Swift (২০১৪) আর Rust 1.0 (২০১৫)-এর enum, TypeScript ২.০ (২০১৬)-এর discriminated union, Python 3.10 (২০২১)-এর match, আর Java 21 (২০২৩)-এ sealed type-এর ওপর pattern-ওয়ালা switch.

আরও গভীরে: Pattern matching compile করার দুটি ধারা আছে। Lennart Augustsson-এর ১৯৮৫ সালের কাজ backtracking-ভিত্তিক পদ্ধতির পরিচিত সূচনা; Luc Maranget ২০০৮ সালে দেখান কীভাবে heuristic দিয়ে ছোট আর ভালো decision tree বানানো যায় (প্রথমে কোন column পরীক্ষা করা হবে, তার বাছাই)। তাঁর ২০০৭ সালের আরেকটি প্রবন্ধ exhaustiveness আর redundancy-কে একটিই প্রশ্নে নামায়: “এই pattern কি আগের সারিগুলোর পরেও কোনো মান ধরে?” (usefulness). OCaml আর Rust-এর checker-এর ভিত্তি এই ধারণা বলে উল্লেখ করা হয়; nested pattern-এ সবচেয়ে খারাপ ক্ষেত্রে এর খরচ exponential হতে পারে, যদিও বাস্তব program-এ তা দ্রুত চলে।

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

  • Sum আর product type-এর পার্থক্য? Product-এ সব ঘর একসাথে (|A|·|B| মান), sum-এ চিহ্নসহ ঠিক একটি বিকল্প (|A| + |B| মান)।
  • enum E { A, B(Bool), C(Bool, Bool) }-এর মান কত? 1 + 2 + 4 = 7.
  • Tagged union আর C union-এর পার্থক্য? Tagged union-এ ট্যাগ বলে কোন বিকল্প বৈধ, আর ভাষা ট্যাগ না মিলিয়ে payload পড়তে দেয় না; C union-এ সে তথ্য নেই।
  • Exhaustiveness check কী, guard কেন গোনা হয় না? সব constructor ধরা হয়েছে কি না যাচাই; guard মিথ্যা হতে পারে, আর তার যুক্তি সাধারণভাবে বিচার করা যায় না।
  • Option কীভাবে null-এর চেয়ে নিরাপদ? “না-থাকা” type-এ লেখা থাকে (1 + T), আর মান বের করতে None-এর ক্ষেত্র সামলাতে হয়।

৯ · AI-এর যুগে ADT আর pattern matching

Payment-এর মতো type আর তার match লিখতে AI assistant খুব দ্রুত, কিন্তু এই বিষয়ে কিছু ভুল বারবার দেখা যায়, আর সেগুলো compile হয়ে চলেও যায়:

AI-এর ভুলকীভাবে ধরবেন
“Python-এর match সব ক্ষেত্র ধরা হয়েছে কি না যাচাই করে”: এক ভাষার নিয়ম অন্য ভাষায়বাদ পড়া একটি মান দিয়ে চালিয়ে দেখা; Python-এ case _:-এ স্পষ্ট error, আর static checker
case Cash: (বন্ধনী ছাড়া) লেখা, যা capture patternCPython-এর SyntaxError পড়া; প্রতিটি class pattern-এ () আছে কি না দেখা
সাধারণ arm-কে guard-ওয়ালা arm-এর আগে বসানো, ফলে পরেরটি অপ্রাপ্যCompiler-এর unreachable warning চালু রাখা; প্রতিটি arm-এর জন্য একটি test
শেষে _ => … বসিয়ে exhaustiveness-এর পাহারা নিভিয়ে দেওয়ানতুন বিকল্প যোগ করে দেখা compiler কোথায় সতর্ক করে; wildcard এড়িয়ে প্রতিটি constructor লেখা
Sum type-এর বদলে “kind + সব ঘর ঐচ্ছিক” ধরনের record, অবৈধ অবস্থাসহমানের সংখ্যা গোনা; বৈধ অবস্থার সংখ্যার সঙ্গে মেলানো
কোন ভাষার কোন version-এ কোন সুবিধা আছে, তা ভুল বলা (যেমন “Java 17-এ record pattern”)ভাষার release note বা JEP পড়া; সেই version-এর compiler-এ চালানো

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

আমি TypeScript 5.9 আর Python 3.14-এ একটি দোকানের Payment type লিখছি: Cash, Card(amount), Bkash(number). ১. দুই ভাষায় type আর একটি fee function লেখো, যেখানে সব বিকল্প ধরা হয়েছে। কোনো wildcard বা default দিয়ে বাকি ক্ষেত্র ঢাকবে না। ২. নতুন বিকল্প Nagad যোগ করলে কোন ভাষা compile-এর সময়ে আর কোনটি শুধু চলার সময়ে ভুল ধরবে, ঠিক কোন বার্তায়? বার্তা অনুমান করে লিখবে না; কোনটি আমাকে চালিয়ে দেখতে হবে বলো। ৩. প্রতিটি match arm-এর জন্য একটি test case দাও, guard-এর সীমার দুই পাশের মানসহ। ৪. নিশ্চিত না হলে "নিশ্চিত নই" বলো, আর কোন documentation বা PEP-এ নিয়মটি আছে তা উল্লেখ করো।

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

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

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

প্র ০১ADT আর pattern matching চল্লিশ বছরের পুরোনো ধারণা। মূলধারার ভাষায় আসতে এত সময় লাগল কেন?

Hope (১৯৮০ সালের দিকে), Standard ML আর Haskell (১৯৯০)-এ ADT শুরু থেকেই ভাষার কেন্দ্রে। কিন্তু ১৯৮০ থেকে ২০১০ পর্যন্ত শিল্পের মূলধারা ছিল C, C++ আর Java, যাদের ডেটা-নকশার মূল হাতিয়ার struct আর class. Object-oriented চিন্তায় “অথবা” প্রকাশের স্বীকৃত উপায় ছিল inheritance: একটি abstract Payment class, তার তিনটি subclass, আর প্রতিটি কাজ একটি virtual method. এতে sum type-এর অনেক সুবিধা পাওয়া যায়, শুধু একটি বাদে: যেকোনো কেউ যেকোনো সময় নতুন subclass যোগ করতে পারে, তাই compiler কখনো বলতে পারে না “সব ক্ষেত্র ধরা হয়েছে”।

দ্বিতীয় বাধা ছিল সংস্কৃতির। Pattern matching দেখতে “functional”, আর বহু বছর functional ভাষাকে গবেষণার বিষয় ভাবা হতো। পরিবর্তন আসে কয়েকটি দিক থেকে। Scala (২০০৪) JVM-এ case class আর pattern matching আনে, আর দেখায় যে OOP আর ADT একসাথে চলে। Swift (২০১৪) আর Rust (২০১৫) নতুন systems আর app ভাষা হিসেবে enum-কে মূল হাতিয়ার বানায়, কারণ তাদের লক্ষ্য ছিল null আর অসম্পূর্ণ শাখার ভুল compile-এর সময়ে ধরা। TypeScript (২০১৬) JavaScript-এর বিদ্যমান ধাঁচ, অর্থাৎ kind ঘরওয়ালা object, কেই type দিল, নতুন বাক্যগঠন ছাড়াই।

পুরোনো ভাষাগুলো পিছিয়ে থেকেও এগোল সতর্কভাবে, কারণ backward compatibility রক্ষা করতে হয়। Java ধাপে ধাপে এগোয়: record (Java 16), sealed class (Java 17), তারপর Java 21-এ record pattern আর switch-এ pattern matching স্থায়ী। Sealed class হলো inheritance-এর সেই খোলা দরজা বন্ধ করার উপায়: permits-এ তালিকার বাইরে কেউ subclass বানাতে পারে না, তাই exhaustiveness সম্ভব। Python 3.10 (২০২১) match আনে, কিন্তু dynamic ভাষা বলে exhaustiveness যাচাইয়ের দায় static checker-কে দেয়।

আরেকটি কারণ ব্যবহারিক: আধুনিক program-এর বড় অংশ JSON, message আর event নিয়ে কাজ, যার প্রায় প্রতিটি একটি sum type (“এই message হয় order, নয় refund, নয় cancel”). এই কাজে ADT-এর সুবিধা হাতে-কলমে চোখে পড়ে।

মূল উপলব্ধি: ধারণাটি পুরোনো, কিন্তু মূলধারায় এসেছে তখন, যখন ভাষাগুলো “বন্ধ” type-পরিবার (sealed, enum) প্রকাশের উপায় পেয়েছে; বন্ধ না হলে exhaustiveness-এর নিশ্চয়তা দেওয়া যায় না।

প্র ০২Expression problem কী? ADT আর class hierarchy-র মধ্যে বাছাই এর সঙ্গে কীভাবে জড়িত?

Philip Wadler ১৯৯৮ সালের একটি email-এ সমস্যাটির নাম দেন expression problem, যদিও প্রশ্নটি আগেই আলোচিত হচ্ছিল। ধরুন একটি ছোট ভাষার AST: কয়েকটি বিকল্প (Num, Binary…) আর কয়েকটি কাজ (evaluate, pretty-print, type-check). একটি টেবিল কল্পনা করুন, সারিতে বিকল্প, কলামে কাজ। প্রশ্ন: নতুন সারি (বিকল্প) আর নতুন কলাম (কাজ), দুটিই কি পুরোনো কোড না বদলে আর type-নিরাপত্তা না হারিয়ে যোগ করা যায়?

ADT-এর নকশায় প্রতিটি কাজ একটি function, যার ভেতরে একটি match. নতুন কাজ যোগ সহজ: আরেকটি function লিখুন, পুরোনো কিছু ছুঁতে হয় না। কিন্তু নতুন বিকল্প যোগ কঠিন: প্রতিটি function-এর match-এ একটি arm যোগ করতে হয়। সুখবর হলো exhaustiveness check ঠিক এই জায়গাগুলো দেখিয়ে দেয়।

Class hierarchy-তে (পর্ব ০৮-এর dynamic dispatch) উল্টো। প্রতিটি বিকল্প একটি class, প্রতিটি কাজ একটি method. নতুন বিকল্প যোগ সহজ: আরেকটি subclass, তার নিজের method-সহ। নতুন কাজ যোগ কঠিন: প্রতিটি class-এ নতুন method লাগে। Visitor pattern এই অসুবিধা কাটাতে OOP-তে “match”-এর অনুকরণ করে, আর ফলে ADT-এর মতোই নতুন বিকল্প যোগ কঠিন হয়ে পড়ে।

Compiler-এর কাজে কোনটি বেশি ঘটে? একটি ভাষার AST-র বিকল্প তুলনামূলক স্থির, কিন্তু নতুন pass (নতুন কাজ) প্রায়ই আসে: optimization, lint, formatter. তাই ML-পরিবারের ভাষা compiler লেখায় এত জনপ্রিয়, আর অনেক compiler (OCaml, Rust-এর নিজের compiler) ADT-তে লেখা। অন্যদিকে GUI widget-এর মতো ক্ষেত্রে নতুন বিকল্প (নতুন widget) বেশি আসে, তাই সেখানে class hierarchy স্বাভাবিক। গবেষণায় দুটিই সহজ করার কয়েকটি সমাধান আছে (Scala-র trait-ভিত্তিক কৌশল, Haskell-এর type class-ভিত্তিক “finally tagless” ধাঁচ), প্রতিটির নিজের জটিলতা।

মূল উপলব্ধি: ADT আর class একই টেবিলের দুটি দিক কেটে সাজায়; কোন দিকে বেশি পরিবর্তন আসবে, সেটিই নকশা বাছাইয়ের প্রশ্ন।

প্র ০৩Kotlin-এর String? আর Rust-এর Option<String> দুটিই null এড়ায়। পার্থক্য কোথায়, আর গণনা কী বলে?

দুটিই “হয়তো একটি String” কথাটি type-এ লেখে, আর দুটিতেই ব্যবহারের আগে না-থাকা ক্ষেত্রটি সামলাতে type checker বাধ্য করে। পার্থক্য গঠনে। Kotlin আর Swift-এর nullable type একটি বিশেষ নিয়ম: T-এর সঙ্গে null যোগ করা। Rust আর Haskell-এর Option একটি সাধারণ ADT, ভাষার অন্য সব enum-এর মতো।

গণনায় পার্থক্যটি ধরা পড়ে nesting-এ। Option<Option<T>>-এর মান 1 + (1 + |T|): বাইরের None, ভেতরের None (Some(None)) আর Some(Some(t)), তিনটি আলাদা। অংশ ২-এর block-এ Option<Option<Bool>>-এ ৪টি মান এসেছিল। কিন্তু Kotlin-এ String?? লিখলে তা String?-ই, কারণ null-এ আবার null যোগ করলে নতুন কিছু হয় না: মান 1 + |T|. একটি বাস্তব প্রশ্নে তফাতটা জরুরি হয়ে ওঠে। বাজারঘরের cache-এ পণ্যের ছাড়ের হার খুঁজছেন, যেখানে “ছাড় নেই” বৈধ উত্তর। Cache থেকে পাওয়া মান তিন রকম হতে পারে: cache-এ নেই, cache-এ আছে কিন্তু ছাড় নেই, আর ছাড় আছে। Option-এর nesting এই তিনটি আলাদা রাখে; nullable type-এ প্রথম দুটি এক null-এ মিশে যায়, তাই আলাদা একটি flag লাগে।

অন্যদিকে nullable type-এর সুবিধাও আছে। পুরোনো Java লাইব্রেরির সঙ্গে কাজ সহজ, কারণ Java-র reference ইতিমধ্যে “হয়তো null”; আর String থেকে String?-তে নেওয়া স্বয়ংক্রিয় (subtyping), Some দিয়ে মোড়াতে হয় না। খরচের দিক থেকে দুটি প্রায় সমান: Rust-এর null pointer optimization-এ Option<&T> একটি সাধারণ pointer-এর আকারের, শূন্য ঠিকানাই None; Kotlin-এর nullable reference-ও JVM-এ একটি সাধারণ reference. এখানে ভাষা নকশার একটি পুরোনো শিক্ষা আবার দেখা যায়: বিশেষ নিয়মের চেয়ে সাধারণ, orthogonal গঠন (পর্ব ০৬) প্রায়ই বেশি প্রকাশক্ষম, আর বিশেষ নিয়ম প্রায়ই বেশি সুবিধাজনক।

মূল উপলব্ধি: Option একটি সাধারণ sum type বলে nesting-এ তথ্য হারায় না; nullable type সুবিধাজনক কিন্তু “না-থাকার ভেতরে না-থাকা” প্রকাশ করতে পারে না।

প্র ০৪ব্যর্থতা জানাতে Result type ভালো, না exception? Rust, Go আর Java কে কোন পথ নিল?

Exception-এ ব্যর্থতা একটি আলাদা নিয়ন্ত্রণ-পথ: function সাধারণভাবে ফেরে না, বরং stack ভেঙে ওপরে এমন কাউকে খোঁজে যে ধরতে চায় (বিস্তার পর্ব ২৮-এ)। সুবিধা: মাঝের function-গুলোকে কিছুই লিখতে হয় না, আর সাধারণ পথের কোড পরিষ্কার থাকে। অসুবিধা: function-এর type দেখে বোঝা যায় না সে কী কী ব্যর্থতা ছুড়তে পারে, আর কোথাও না ধরলে program থেমে যায়।

Java এই অসুবিধা কমাতে checked exception আনে: method-এর ঘোষণায় throws IOException লিখতে হয়, আর ডাকার কোডকে ধরতে বা আবার ঘোষণা করতে হয়। কাগজে এটি Result-এর মতোই নিশ্চয়তা দেয়, কিন্তু বাস্তবে lambda আর stream-এর সঙ্গে খাপ খায় না, আর অনেকে বিরক্ত হয়ে ধরে চুপ করিয়ে দেন। পরের অনেক JVM ভাষা (Kotlin, Scala) checked exception রাখেনি।

Go আলাদা পথ নেয়: প্রতিটি function ফেরত দেয় (value, err). ব্যর্থতা দৃশ্যমান, কিন্তু অংশ ৬-এর টেবিলে দেখেছেন, এটি একটি product: type checker জোর করে না যে err দেখার আগে value ব্যবহার করা যাবে না। Rust-এর Result<T, E> একটি sum: হয় Ok(t), নয় Err(e); মান পেতে match করতেই হয়। এতে কোড লম্বা হওয়ার ভয় ছিল, যা ? operator কমিয়েছে: let x = parse(s)?; মানে “Err হলে এখনই সেটিই ফেরত দাও, Ok হলে ভেতরের মান নাও”। এটি একটি ছোট desugaring (পর্ব ৫৫-এর বিষয়), কিন্তু এর ফলে exception-এর মতো সংক্ষিপ্ত লেখার সঙ্গে Result-এর দৃশ্যমানতা একসাথে পাওয়া যায়। তবে Rust-এও “ফিরে আসা যায় না” এমন ভুলের জন্য আলাদা পথ, panic, রাখা আছে।

Haat v1-এ এখন দুটিই নেই: runtime error (যেমন division by zero) program থামায়। Haat-এর বর্ধিত রূপে অংশ ৬-এর PayResult দেখায় যে ADT থাকলেই Result লেখা যায়, নতুন কোনো control-flow নিয়ম ছাড়াই।

মূল উপলব্ধি: Result ব্যর্থতাকে type-এ এনে compiler-কে পাহারাদার বানায়; exception কম লেখায় কাজ সারে কিন্তু পাহারা দুর্বল। আধুনিক ভাষা প্রায়ই দুটিই রাখে, প্রত্যাশিত ব্যর্থতার জন্য Result আর অপ্রত্যাশিত বিপর্যয়ের জন্য exception বা panic.

প্র ০৫Python 3.10-এর match exhaustiveness যাচাই করে না কেন? “খোলা” আর “বন্ধ” sum type-এর পার্থক্য কী?

Exhaustiveness check-এর পূর্বশর্ত হলো compile-এর সময় জানা থাকা যে একটি type-এর ঠিক কোন কোন বিকল্প আছে। Rust-এর enum, Haskell-এর data, Java-র sealed interface “বন্ধ”: ঘোষণাতেই তালিকা শেষ। Python-এর class “খোলা”: যেকোনো module যেকোনো সময় নতুন subclass বানাতে পারে, এমনকি চলার সময়ে। তার ওপর Python-এর match-এর subject-এর type compile-এর সময় জানাই নেই; fee("nagad") লিখতে কেউ বাধা দেয় না। CPython-এর compiler তাই শুধু সেই ভুল ধরে যা pattern-এর গঠন দেখেই বোঝা যায়, যেমন অংশ ৫-এর capture pattern-এর পরে অপ্রাপ্য arm.

PEP 634–636 (২০২০ সালে প্রস্তাব, Python 3.10-এ ২০২১ সালে যুক্ত) এই সিদ্ধান্ত সচেতনভাবেই নেয়: match কোনো arm না মিললে চুপচাপ কিছু না করে এগিয়ে যায়, ঠিক if/elif-এর মতো। কোনো exception ছোড়ে না, যা অনেকে প্রথমে আশা করেন। পাহারা চাইলে দুটি পথ। চলার সময়ের পথ: শেষে case _: raise .... Static পথ: type hint দিয়ে Payment = Cash | Card | Bkash লিখে mypy বা pyright-এর মতো checker চালানো, আর শেষ arm-এ typing.assert_never(p) (Python 3.11 থেকে) বসানো; তখন checker TypeScript-এর never-এর মতোই বাদ পড়া বিকল্প ধরতে পারে। এখানে union-টি টাইপ-hint-এর স্তরে বন্ধ, যদিও class-গুলো নিজে খোলা।

খোলা আর বন্ধের এই টানাপোড়েন ভাষা নকশার একটি গভীর বাছাই। বন্ধ type নিরাপত্তা দেয় কিন্তু লাইব্রেরির ব্যবহারকারী নতুন বিকল্প যোগ করতে পারেন না; খোলা type বাড়ানো যায় কিন্তু নিশ্চয়তা হারায়। Rust এর মাঝামাঝি একটি পথ দিয়েছে: লাইব্রেরি enum-কে #[non_exhaustive] চিহ্ন দিলে, বাইরের কোডকে সবসময় একটি wildcard arm রাখতে হয়, যাতে পরে নতুন বিকল্প এলে তাদের কোড না ভাঙে। Java-র sealed type-এ non-sealed subclass একটি নির্দিষ্ট শাখা খোলা রাখতে দেয়।

মূল উপলব্ধি: Exhaustiveness শুধু বন্ধ type-এ সম্ভব; dynamic ভাষা তাই পাহারা দেয় static checker-কে, আর নকশাকারকে ঠিক করতে হয় কোন type বন্ধ থাকবে আর কোনটি বাড়তে পারবে।

অনুশীলন

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

  1. মান গুনুন: enum Slot { Morning, Evening, Night } ধরে (Haat-এর বর্ধিত রূপ) নিচের প্রতিটির মানের সংখ্যা বের করুন। (ক) record Order { express: Bool, slot: Slot } (খ) enum Delivery { Pickup, Home(Slot), Courier(Bool, Slot) } (গ) Result<Slot, Bool> (ঘ) (Bool) -> Bool আর (Slot) -> Bool (ঙ) কেউ Delivery-কে C-তে লিখলেন struct { int kind; /* 0..2 */ Slot slot; bool express; }, তিনটি ঘর সবসময়। kind-কে ০–২-এ সীমিত ধরলে কতগুলো মান, আর তার কতগুলো অবৈধ?

    (ক) 2 × 3 = 6. (খ) 1 + 3 + (2 × 3) = 10. (গ) 3 + 2 = 5. (ঘ) 22 = 4 (identity, not, সবসময় true, সবসময় false) আর 23 = 8. (ঙ) 3 × 3 × 2 = 18টি মান, কিন্তু বৈধ Delivery মাত্র ১০টি, তাই ৮টি অবৈধ। kind = Pickup-এ slot আর express-এর ছয়টি জোড়া, অথচ Pickup একটিই মান: ৫টি বাড়তি। kind = Home-এ ছয়টি জোড়া, কিন্তু express অর্থহীন বলে বৈধ মাত্র ৩টি: আরও ৩টি বাড়তি। Courier-এর ছয়টিই বৈধ। মোট 5 + 3 = 8. যাচাই (CPython 3.14.4, itertools.product দিয়ে সব মান তৈরি করে গোনা): 6 10 5 4 8 18 8.

  2. ভুল খুঁজুন: একজন সহকর্মী Python 3.14-এ লিখলেন, আর বললেন “Cash আগে ধরা হলো, বাকি পরে”। কী ঘটবে, কেন? দুটি আলাদা সংস্করণে উত্তর দিন: (ক) নিচের মতো, (খ) যদি case Cash: শেষ arm হতো।
    def fee(p):
        match p:
            case Cash:
                return 0
            case Card(amount):
                return 50

    (ক) ফাইলটি চলবেই না। বন্ধনী ছাড়া Cash একটি capture pattern: যেকোনো মান নিয়ে নাম দেয় Cash. তাই এটি সব ধরে, আর পরের arm অপ্রাপ্য। CPython 3.14.4-এর সত্যিকারের বার্তা: SyntaxError: name capture 'Cash' makes remaining patterns unreachable. (খ) শেষ arm হলে কোনো error নেই, কিন্তু অর্থ ভুল: যা আগের arm-এ মেলেনি, তার সবকিছু (Bkash, এমনকি "nagad" string) নগদ ধরে 0 চার্জ। বাড়তি বিপদ: arm-এর ভেতরে Cash নামটি এখন সেই মানে বাঁধা, তাই একই function-এ পরে Cash() ডাকলে class নয়, ওই মানকেই ডাকা হবে। ঠিক রূপ: case Cash():. সাধারণ নিয়ম: Python-এ বন্ধনীহীন নাম capture, বিন্দুযুক্ত নাম (Color.RED) মান, বন্ধনীযুক্ত নাম class pattern.

  3. নকশা ও বাস্তবায়ন — Haat-এর বর্ধিত রূপের checker: Haat-এর type checker-এ match-এর জন্য একটি function লিখুন, যা Haat-এর বার্তার ধাঁচে (line:col: error: …) তিন রকম ভুল ধরে: enum-এ নেই এমন constructor, payload-এর ভুল সংখ্যা, আর অপ্রাপ্য arm; শেষে বাদ পড়া constructor-এর তালিকা। প্রতিটি arm দেওয়া হবে (line, col, ctor, nvars, guarded) হিসেবে।
    # Haat-এর বর্ধিত রূপ (নকশার খসড়া, reference-এ নেই)
    ENUMS = {"Payment": {"Cash": [], "Card": ["Int"], "Bkash": ["Str"]}}
    
    def check_match(enum, pos, arms):
        ctors, errs = ENUMS[enum], []
        missing = list(ctors)
        for line, col, ctor, nvars, guarded in arms:
            if ctor == "_":
                covers = list(ctors)
            elif ctor not in ctors:
                errs.append(f"{line}:{col}: error: '{ctor}' is not a case of enum '{enum}'")
                continue
            else:
                covers = [ctor]
                if nvars != len(ctors[ctor]):
                    errs.append(f"{line}:{col}: error: case '{ctor}' takes "
                                f"{len(ctors[ctor])} value(s), found {nvars}")
                    continue
            if not any(c in missing for c in covers):
                errs.append(f"{line}:{col}: error: unreachable match arm")
            if not guarded:
                missing = [c for c in missing if c not in covers]
        if missing:
            errs.append(f"{pos}: error: non-exhaustive match: missing "
                        + ", ".join(f"'{c}'" for c in missing))
        return errs or ["ok"]

    লেখকের CPython 3.14.4-এ তিনটি উদাহরণ চালানো হলো, match-এর অবস্থান 2:5. (১) Cash, guard-সহ Card, Bkash: 2:5: error: non-exhaustive match: missing 'Card'. (২) Cash, Card(a, b), _, Bkash: 4:9: error: case 'Card' takes 1 value(s), found 2 আর 6:9: error: unreachable match arm (Card-এর ভুল arm বাতিল হলেও _ সব ধরে, তাই Bkash অপ্রাপ্য)। (৩) সব ঠিক, সঙ্গে Nagad(x): 6:9: error: 'Nagad' is not a case of enum 'Payment'. Reference-এর মতো সব error একসাথে জানানো হয় (সিদ্ধান্ত ২)। Nested pattern-এ এই সরল checker যথেষ্ট নয়; তখন Maranget-এর usefulness algorithm লাগে।

  4. আউটপুট অনুমান করুন: Python 3.14-এ নিচের function ছয়টি input-এ কী ছাপবে? চালানোর আগে লিখুন। Input: (১) {"items": []} (২) {"items": [{"name": "chal", "qty": 10}]} (৩) {"items": [{"name": "dim", "qty": 2}]} (৪) তিনটি পণ্য tel, dal, lobon, প্রতিটির qty 1 (৫) {"id": 7} (৬) {"items": [], "id": 9}
    def label(order):
        match order:
            case {"items": []}:
                return "empty"
            case {"items": [x]} if x["qty"] > 5:
                return "bulk " + x["name"]
            case {"items": [x]}:
                return "single " + x["name"]
            case {"items": [x, *rest]}:
                return f"{x['name']} +{len(rest)}"
            case _:
                return "bad"

    সত্যিকারের run (CPython 3.14.4): empty, bulk chal, single dim, tel +2, bad, empty. (২)-এ guard সত্য (10 > 5); (৩)-এ guard মিথ্যা, তাই পরের arm-এ একই pattern আবার মিলে single. (৪)-এ *rest বাকি দুটি নেয়। (৫)-এ "items" চাবিই নেই, তাই শুধু _. (৬) অনেককে চমকে দেয়: mapping pattern শুধু উল্লেখ করা চাবি দেখে, বাড়তি চাবি ("id") উপেক্ষা করে, তাই empty. Sequence pattern-এ উল্টো: [x] শুধু ঠিক এক উপাদানের তালিকায় মেলে। এক ঘর ভুল হলে নিজের মডেলটি দেখুন: কোন pattern “অন্তত এটুকু” চায়, আর কোনটি “ঠিক এটুকু”।

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

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

ক্রমStatic typing-ওয়ালা একটি ভাষার compiler একটি match নিয়ে যে কাজগুলো করে, সঠিক ক্রমে সাজান (▲▼ চেপে সরান)

  1. Parser pattern আর arm-গুলো পড়ে AST-তে Match node বানায়
  2. Name resolution: pattern-এর constructor নাম কোন enum-এর, তা খোঁজা
  3. Type checking: subject-এর type আর প্রতিটি বাঁধা নামের type বের করা
  4. Exhaustiveness আর unreachable arm-এর পরীক্ষা
  5. Code generation: ট্যাগ ধরে decision tree বা jump table

enum Slot { Morning, Evening, Night } হলে record { express: Bool, slot: Slot }-এর কতগুলো আলাদা মান সম্ভব?

  • 5
  • 6
  • 8
  • 9

Option<Bool> (হয় None, নয় Some(b)) type-এর কতগুলো মান?

  • 2
  • 4
  • 3
  • 1

enum Payment { Cash, Card(Int), Bkash(Str) }-এর ওপর একটি match-এর arm: Cash => …, Card(a) if a > 0 => …, Bkash(_) => …. একটি সাধারণ exhaustiveness checker কী বলবে?

  • সব ঠিক, কারণ তিনটি constructor-ই উল্লেখ আছে
  • Bkash-এর arm অপ্রাপ্য
  • Cash বাদ পড়েছে
  • Card বাদ পড়েছে (non-exhaustive)

Python 3.10+-এ match p:-এর প্রথম arm case Cash: (বন্ধনী ছাড়া), আর তার পরে আরও arm আছে। কী ঘটে?

  • SyntaxError, কারণ এটি সব মান ধরে আর পরের arm অপ্রাপ্য
  • শুধু Cash class-এর object মেলে
  • চলার সময়ে TypeError
  • কোনো সমস্যা নেই, arm-গুলো ক্রমে চলে

Go-র (value, err) জোড়া আর Rust-এর Result<T, E>-এর মূল গাঠনিক পার্থক্য কী?

  • Go-রটি exception, Rust-এরটি ফেরত মান
  • Go-রটি product, তাই অর্থহীন মিশ্রণ সম্ভব; Result একটি sum, ঠিক একটি থাকে
  • Result-এ মান আর error দুটিই একসাথে থাকে
  • শুধু মেমরিতে আকারের পার্থক্য

বন্ধ sum type-এর ওপর match-কে compiler সাধারণত decision tree-তে কেন নামায়?

  • যাতে arm-গুলো যেকোনো ক্রমে চলতে পারে
  • Exhaustiveness check করার একমাত্র উপায় বলে
  • যাতে প্রতিটি ট্যাগ-পরীক্ষা একবারই হয়
  • যাতে কোড সবসময় ছোট হয়

শব্দকোষ

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

মনে রাখুন

  1. Product = “এবং” (|A|·|B| মান), sum = চিহ্নসহ “অথবা” (|A| + |B| মান); গুনে দেখলে অবৈধ অবস্থা ধরা পড়ে।
  2. Tagged union-এ ট্যাগ আর payload-এর মিল ভাষা রক্ষা করে; payload পড়ার একমাত্র পথ pattern matching.
  3. Pattern matching: ওপর থেকে নিচে, প্রথম মেলা arm; মেলার সময় binding; guard মিথ্যা হলে পরের arm.
  4. Exhaustiveness শুধু বন্ধ type-এ সম্ভব; guard-ওয়ালা arm গোনা হয় না; Python-এর match যাচাই করে না, আর case Cash: একটি capture.
  5. Option = 1 + T, Result = T + E; AST নিজেই একটি recursive ADT, আর match-কে compiler decision tree-তে নামায়।

পরের পর্বে: পর্ব ২৫ (Memory layout — alignment, padding আর object-এর আকার)। একটি record বা tagged union মেমরিতে আসলে কত byte নেয়, ঘরের ক্রম বদলালে আকার কেন বদলায়, আর compiler কোন algorithm-এ offset হিসাব করে।

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

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