Add examples for generics

Author: tshemsedinov

Classification/9-generics.ts

@@ -0,0 +1,85 @@
+// Parametric polymorphism with Generics
+
+interface Account {
+  id: string;
+  balance: number;
+}
+
+interface SavingsAccount extends Account {
+  kind: 'savings';
+  rate: number;
+}
+
+interface CreditAccount extends Account {
+  kind: 'credit';
+  limit: number;
+}
+
+type AnyAccount = SavingsAccount | CreditAccount;
+
+type TransactionKind = 'deposit' | 'withdraw';
+
+interface Transaction<T extends Account> {
+  kind: TransactionKind;
+  amount: number;
+}
+
+function applyTransaction<T extends Account>(account: T, tx: Transaction<T>): T {
+  if (tx.amount < 0) throw new Error('Amount must be non-negative');
+  if (tx.kind === 'withdraw' && account.balance < tx.amount) {
+    throw new Error('Insufficient funds');
+  }
+  const balance = tx.kind === 'deposit'
+    ? account.balance + tx.amount
+    : account.balance - tx.amount;
+  return { ...account, balance };
+}
+
+class Ledger<T extends Account> {
+  private entries: Array<{ accountId: string; kind: TransactionKind; amount: number }>;
+
+  constructor() {
+    this.entries = [];
+  }
+
+  record(account: T, tx: Transaction<T>): T {
+    const updated = applyTransaction(account, tx);
+    const { kind, amount } = tx;
+    const record = { accountId: account.id, kind, amount };
+    this.entries.push(record);
+    return updated;
+  }
+
+  getAll() {
+    return this.entries.slice();
+  }
+}
+
+// Usage
+
+const savings: SavingsAccount = {
+  id: 'S-1',
+  balance: 1000,
+  kind: 'savings',
+  rate: 0.02,
+};
+
+const credit: CreditAccount = {
+  id: 'C-1',
+  balance: 0,
+  kind: 'credit',
+  limit: 2000,
+};
+
+const ledgerSavings = new Ledger<SavingsAccount>();
+const ledgerCredit = new Ledger<CreditAccount>();
+
+const s1 = ledgerSavings.record(savings, { kind: 'deposit', amount: 200 });
+const s2 = ledgerSavings.record(s1, { kind: 'withdraw', amount: 50 });
+
+const c1 = ledgerCredit.record(credit, { kind: 'deposit', amount: 500 });
+const c2 = ledgerCredit.record(c1, { kind: 'withdraw', amount: 150 });
+
+console.dir({ s2, c2 });
+console.log('Savings entries:', ledgerSavings.getAll());
+console.log('Credit entries:', ledgerCredit.getAll());

Classification/a-generics.js

@@ -0,0 +1,45 @@
+'use strict';
+
+// Parametric polymorphism with Generics
+
+const applyTransaction = (account, amount, kind) => {
+  if (amount < 0) throw new Error('Amount must be non-negative');
+  if (kind === 'withdraw' && account.balance < amount) {
+    throw new Error('Insufficient funds');
+  }
+  const balance =
+    kind === 'deposit' ? account.balance + amount : account.balance - amount;
+  return { ...account, balance };
+};
+
+class Ledger {
+  constructor() {
+    // Array of
+    // { accountId: string, kind: 'deposit'|'withdraw', amount: number }
+    this.entries = [];
+  }
+
+  record(account, kind, amount) {
+    const updated = applyTransaction(account, amount, kind);
+    this.entries.push({ accountId: account.id, kind, amount });
+    return updated;
+  }
+}
+
+// Usage
+
+const savings = { id: 'S-1', balance: 1000, kind: 'savings', rate: 0.02 };
+const credit = { id: 'C-1', balance: 0, kind: 'credit', limit: 2000 };
+
+const ledgerSavings = new Ledger();
+const ledgerCredit = new Ledger();
+
+const s1 = ledgerSavings.record(savings, 'deposit', 200);
+const s2 = ledgerSavings.record(s1, 'withdraw', 50);
+
+const c1 = ledgerCredit.record(credit, 'deposit', 500);
+const c2 = ledgerCredit.record(c1, 'withdraw', 150);
+
+console.dir({ s2, c2 });
+console.log('Savings entries:', ledgerSavings.entries);
+console.log('Credit entries:', ledgerCredit.entries);

README.md

@@ -13,9 +13,9 @@
   - Class inheritance - IS-A relationship via base classes: [`5-abstract.ts`](Classification/5-abstract.ts)
   - Interface / protocol polymorphism - Contracts that types must implement: [`6-protocol.js`](Classification/6-protocol.js)
   - Structural (duck typing) polymorphism - Compatibility based on structure, not explicit inheritance: [`6-protocol.js`](Classification/6-protocol.js)
-3. Parametric polymorphism - Code written generically to work with any type (examples will be added ASAP)
-  - Generic functions - Functions parameterized by types
-  - Generic data structures - Data structures parameterized by types
+3. Parametric polymorphism - Code written generically to work with any type
+  - Generic functions - Functions parameterized by types: JS [`9-generics.ts`](Classification/9-generics.ts)
+  - Generic data structures - Data structures parameterized by types: JS TS [`a-generics.js`](Classification/a-generics.js)
 4. Dispatch mechanisms - How the runtime selects which method to call
   - Dynamic dispatch - Method chosen at runtime based on object type: [`7-dynamic.js`](Classification/7-dynamic.js)
   - Virtual functions and methods - Base class methods overridable by derived classes: [`8-virtual.cpp`](Classification/8-virtual.cpp)