functional programming — pure function, currying আর composition

১ · Functional programming কী — state বদলানো নয়, function জোড়া

একটি অনলাইন দোকানের checkout পাতা ভাবুন। কার্টের দাম থেকে ছাড় বাদ যাবে, তারপর VAT যোগ হবে, তারপর পয়সা পর্যন্ত গোল করা হবে, শেষে বাংলায় টাকার ফরম্যাটে দেখানো হবে। এই কাজ দুইভাবে লেখা যায়।

প্রথম ধরন: একটি let price variable নিন, তারপর একটির পর একটি লাইনে সেটিকে বদলান — price = price * 0.9, তারপর price = price * 1.15, তারপর গোল করা। প্রতিটি লাইন আগের লাইনের রেখে যাওয়া অবস্থার ওপর নির্ভর করে। মাঝখানে অন্য কোনো কোড price ছুঁলে পুরো হিসাব ভুল। একে বলে imperative ধরন — কম্পিউটারকে ধাপে ধাপে নির্দেশ দেওয়া।

দ্বিতীয় ধরন: প্রতিটি ধাপকে একটি ছোট function বানান — applyDiscount, addVat, roundToPaisa. প্রত্যেকটি একটি সংখ্যা নেয়, নতুন একটি সংখ্যা ফেরত দেয়, আর কিছুই বদলায় না। তারপর তিনটিকে জুড়ে একটি নতুন function বানান: finalPrice. কোনো variable বদলায় না; ডেটা এক function থেকে আরেক function-এ বয়ে যায়। এটিই functional programming-এর মূল চিন্তা।

JavaScript কোনো “pure” functional ভাষা নয় — তবু কেন কাজে লাগে

Haskell-এর মতো কিছু ভাষায় সব function pure হতে বাধ্য, আর variable একবার বসালে আর বদলানো যায় না। JavaScript তেমন নয়: object বদলানো যায়, let আছে, লুপ আছে, class আছে (পর্ব ২৬)। কিন্তু JavaScript-এ একটি জিনিস প্রথম দিন থেকেই আছে, যা functional ধারণাগুলোকে বাস্তবে সহজ করে: first-class function. পর্ব ১৩-এ দেখেছেন, function একটি মান — variable-এ রাখা যায়, argument হিসেবে পাঠানো যায়, function থেকে ফেরত দেওয়া যায়। পর্ব ১৬-এর map, filter, reduce এরই ফল, আর পর্ব ২২-এর closure function-কে নিজের সাথে ডেটা বয়ে নিতে দেয়।

তাই JavaScript-এ functional programming মানে “সব কিছু function দিয়ে লিখতেই হবে” নয়। মানে হলো কয়েকটি শক্তিশালী অভ্যাস বেছে নেওয়া — যেখানে সেগুলো কোডকে সহজ করে:

২ · Pure function আর referential transparency

একটি function-কে pure function বলা হয়, যদি দুটি শর্ত মানে:

1. একই input-এ সবসময় একই output. ফল শুধু argument-এর ওপর নির্ভর করে — বাইরের variable, সময়, এলোমেলো সংখ্যা বা নেটওয়ার্কের ওপর নয়।
2. কোনো side effect নেই। মান ফেরত দেওয়া ছাড়া আর কিছু করে না: global variable বদলায় না, পাওয়া object বদলায় না, পাতায় কিছু লেখে না, সার্ভারে পাঠায় না।

(a, b) => a + b pure. Math.max pure. কিন্তু Math.random() pure নয় (প্রতিবার ভিন্ন ফল), Date.now() pure নয় (সময়ের ওপর নির্ভর), arr.push(x) pure নয় (মূল array বদলায়), আর console.log-ও কঠোর অর্থে pure নয় — এটি বাইরের জগতে (console-এ) কিছু লেখে। নিচের ডায়াগ্রামে একটি impure আর একটি pure function দুবার করে একই input দিয়ে ডেকে দেখুন:

1let total = 0;2const addImpure = (x) => (total += x);3const addPure = (sum, x) => sum + x;4addImpure(5);5addImpure(5);6addPure(0, 5);7addPure(0, 5);

শেষ ধাপের বৈশিষ্ট্যটির নাম referential transparency: একটি expression-কে তার ফল দিয়ে বদলে দিলে প্রোগ্রামের অর্থ বদলায় না। গণিতে এটি স্বাভাবিক — 2 + 3 যেখানে আছে সেখানে 5 লিখলে কিছুই বদলায় না। প্রোগ্রামে এটি একটি উপহার, কারণ তখন কোড পড়তে গিয়ে একটি function কল দেখে আপনি “এর ফল কী” ভাবলেই চলে, “এটি আর কী কী করে” ভাবতে হয় না।

Pure function কেন এত কাজের — তিনটি সুবিধা

Side effect ছাড়া প্রোগ্রাম হয় না — তাই রাখুন কিনারায়

একটি সত্য স্বীকার করা দরকার: শুধু pure function দিয়ে কোনো কাজের প্রোগ্রাম হয় না। পাতায় দেখানো, সার্ভারে অর্ডার পাঠানো, localStorage-এ রাখা — এগুলোই তো প্রোগ্রামের উদ্দেশ্য, আর সবই side effect. Functional চিন্তা side effect নিষেধ করে না; বলে side effect-কে আলাদা করে কিনারায় রাখুন.

পর্ব ২১-এর খরচের খাতায় ঠিক এটাই করেছিলেন: হিসাবের সব নিয়ম ছিল pure function-এ, আর DOM ছোঁয়ার কাজ ছিল একটি পাতলা স্তরে। এই নকশার নাম functional core, imperative shell. ভেতরের core সিদ্ধান্ত নেয় (“কার্টে নতুন মোট কত?”), বাইরের shell কাজ করে (“পাতায় সংখ্যাটা বসাও, সার্ভারে পাঠাও”)। ফল: বেশিরভাগ যুক্তি টেস্ট করা যায় কোনো ব্রাউজার ছাড়াই।

৩ · Immutability বাস্তবে — const, freeze, spread আর to-পরিবার

Pure function-এর দ্বিতীয় শর্ত (কিছু বদলাবে না) মানতে হলে ডেটার সাথে আচরণ বদলাতে হয়: পুরোনো object বদলানোর বদলে বদলানো অংশসহ নতুন object বানাতে হয়। এই অভ্যাসের নাম immutability. JavaScript-এ এর চারটি স্তর আছে, আর প্রতিটির সীমা জানা জরুরি।

স্তর ১ — const immutability নয়

পর্ব ০৭-এ দেখেছেন: const শুধু নামটিকে একটি মানের সাথে বেঁধে রাখে, মানটিকে নয়। const cart = []; cart.push("চাল"); দিব্যি চলে — cart এখনো একই array-কে দেখাচ্ছে, শুধু array-টির ভেতরটা বদলেছে। একে বলে mutation. const আটকায় শুধু cart = […] লিখে নতুন মান বসানো।

স্তর ২ — Object.freeze, কিন্তু shallow

Object.freeze একটি object-এর property যোগ, মোছা বা বদলানো বন্ধ করে দেয়। দুটি জিনিস মনে রাখুন। এক, সাধারণ (sloppy) mode-এ বদলানোর চেষ্টা চুপচাপ উপেক্ষিত হয় — কোনো error নেই; শুধু strict mode-এ (module আর class-এর ভেতরে ডিফল্ট) TypeError আসে। দুই, freeze shallow: শুধু ওপরের তলার property আটকায়। ভেতরে আরেকটি object থাকলে সেটি দিব্যি বদলানো যায়, যদি না আপনি সেটিকেও আলাদা করে freeze করেন (একটি recursive “deep freeze” function দিয়ে)। অংশ ৫-এর কোডে দুটোই নিজে চালিয়ে দেখবেন।

স্তর ৩ — spread দিয়ে নতুন কপি

প্রতিদিনের সবচেয়ে কাজের কৌশল পর্ব ১৭-এর spread: { ...user, city: "রাজশাহী" } একটি নতুন object দেয় যার শুধু city বদলানো; [...cart, newItem] নতুন array দেয় যার শেষে নতুন পণ্য। এটিই immutable update. মনে রাখুন spread একটি shallow copy — ভেতরের object-গুলো পুরোনোটার সাথে ভাগাভাগি থাকে। এটি আসলে সুবিধা: না-বদলানো অংশ কপি না করে ভাগ করে নেওয়া (structural sharing) বড় ডেটাতেও আপডেট সস্তা রাখে। শুধু ভেতরের কিছু বদলাতে হলে সেই স্তরটিও spread করতে হয়:

const next = {
  ...state,
  user: { ...state.user, address: { ...state.user.address, city: "রাজশাহী" } },
};

স্তর ৪ — ES2023-এর “to-পরিবার” আর লাইব্রেরি

Array-এর পুরোনো method sort, reverse, splice আর arr[i] = v সবই mutation. ES2023 এদের non-mutating জোড়া দিয়েছে: toSorted, toReversed, toSpliced আর with(index, value). যেমন scores.with(2, 95) একটি নতুন array দেয় যার তৃতীয় ঘরে ৯৫, মূলটি অক্ষত। Functional কোডে এগুলোই প্রথম পছন্দ।

গভীর nested ডেটায় দুটি জনপ্রিয় লাইব্রেরি আছে। Immer আপনাকে একটি “খসড়া” (draft) বদলানোর মতো স্বাভাবিক কোড লিখতে দেয়, আর ভেতরে ভেতরে structural sharing দিয়ে একটি নতুন immutable object বানায় — Redux Toolkit এটিই ব্যবহার করে। Immutable.js (Facebook, ২০১৪) নিজস্ব persistent data structure (List, Map) দেয়। এগুলো npm package লাগে, তাই এখানে চালানো যায় না — শুধু চেহারা দেখুন:

import { produce } from "immer";   // npm install immer

const next = produce(state, (draft) => {
  draft.user.address.city = "রাজশাহী";   // দেখতে mutation, আসলে draft-এ
});
// প্রত্যাশিত আচরণ: state অক্ষত, next নতুন; পথের বাইরের অংশ ভাগাভাগি

৪ · নিজের higher-order function আর partial application

পর্ব ১৬-এ higher-order function ব্যবহার করেছেন — map-কে একটি callback দিয়েছেন। এবার নিজে বানানোর পালা। নিয়ম একটাই: function নিন, আর/অথবা function ফেরত দিন। সবচেয়ে কাজের নকশা হলো wrapper — একটি function নিয়ে তার চারপাশে বাড়তি আচরণ জুড়ে একটি নতুন function ফেরত দেওয়া, মূলটিকে না ছুঁয়ে।

const withLogging = (fn, label) => (...args) => {
  const result = fn(...args);
  console.log(`${label}(${args.join(", ")}) → ${result}`);
  return result;
};
const addVat = (p) => p * 1.15;
const loggedVat = withLogging(addVat, "addVat");
loggedVat(200);   // ছাপে: addVat(200) → 229.99999999999997  (floating-point, পর্ব ১০)

একই নকশায় আরও অনেক কিছু বানানো যায়: once(fn) (একবারই চলবে), memoize(fn) (পর্ব ২২), debounce(fn, ms) (পর্ব ৩৬)। আর একটি খুব বাস্তব উদাহরণ — ব্যর্থ হলে আবার চেষ্টা করা retry wrapper. নিচে এর synchronous রূপ; নেটওয়ার্কের জন্য async রূপ আর অপেক্ষার কৌশল (exponential backoff) পর্ব ৩৬-এ:

const withRetry = (fn, times) => (...args) => {
  for (let i = 1; ; i++) {
    try { return fn(...args); }
    catch (e) { if (i >= times) throw e; }   // শেষ চেষ্টাতেও ব্যর্থ হলে error ছাড়ো
  }
};
const safeParse = withRetry(readSensor, 3);   // readSensor মাঝে মাঝে error ছোড়ে

Partial application — কিছু argument আগেই বসিয়ে রাখা

ধরুন একটি সাধারণ function আছে: const vat = (rate, price) => price * (1 + rate);. বাংলাদেশে বেশিরভাগ পণ্যে ১৫% VAT, তাই প্রতিবার vat(0.15, price) লেখা বিরক্তিকর। এর সমাধান partial application: কিছু argument আগেই বসিয়ে একটি নতুন, ছোট function বানানো। দুই উপায়:

const vat15 = (price) => vat(0.15, price);   // arrow wrapper — সবচেয়ে পরিষ্কার
const vat15b = vat.bind(null, 0.15);         // bind — প্রথম argument আটকে দেয়
vat15(200);  vat15b(200);                    // দুটোই প্রায় 230

৫ · Currying — এক এক করে argument

Partial application-এর একটি নিয়মতান্ত্রিক রূপ হলো currying: কয়েকটি argument নেওয়া একটি function-কে এমন একটি function-এর শিকলে বদলানো, যার প্রতিটি একটি করে argument নেয়। add(1, 2, 3)-এর curried রূপ add(1)(2)(3). Arrow function-এ এটি লেখা খুবই সহজ — প্রতিটি => একটি স্তর:

const formatTaka = (locale) => (amount) =>
  new Intl.NumberFormat(locale, { style: "currency", currency: "BDT" }).format(amount);

const bnTaka = formatTaka("bn-BD");   // locale একবার ঠিক করা
bnTaka(1035);                         // "১,০৩৫.০০৳"
["en-US", "bn-BD"].map((loc) => formatTaka(loc)(500));

একটি সাধারণ curry(fn) — fn.length দিয়ে

প্রতিটি function হাতে curried লেখার বদলে একটি সাধারণ সাহায্যকারী বানানো যায়, যা যেকোনো function-কে curried করে দেয়। কৌশল: function-এর length property বলে সে কয়টি parameter ঘোষণা করেছে — একে বলে তার arity. যতক্ষণ যথেষ্ট argument জমা হয়নি, ততক্ষণ argument জমিয়ে নতুন function ফেরত দাও; যথেষ্ট হলে আসল function ডাকো। ধাপে ধাপে দেখুন:

1const curry = (fn) => function curried(...args) {2  return args.length >= fn.length3    ? fn(...args)4    : (...more) => curried(...args, ...more);5};6const add3 = (a, b, c) => a + b + c;7curry(add3)(1)(2)(3);

এবার নিজে চালিয়ে দেখুন — অংশ ২-এর pure/impure তুলনা, অংশ ৩-এর shallow freeze, আর এই অংশের curry ও length:

let total = 0;
const addImpure = (x) => (total += x);
const addPure = (sum, x) => sum + x;
console.log(addImpure(5), addImpure(5), addPure(0, 5), addPure(0, 5));

const cfg = Object.freeze({ vat: 0.15, shop: { name: "দোকান" } });
cfg.vat = 0.5;                    // চুপচাপ উপেক্ষিত (strict mode নয়)
cfg.shop.name = "নতুন দোকান";      // ভেতরের object freeze হয়নি
console.log(cfg.vat, cfg.shop.name, Object.isFrozen(cfg));

const curry = (fn) => function curried(...args) {
  return args.length >= fn.length
    ? fn(...args)
    : (...more) => curried(...args, ...more);
};
const add3 = (a, b, c) => a + b + c;
const c3 = curry(add3);
console.log(c3(1)(2)(3), c3(1, 2)(3), c3(1)(2, 3));
console.log(add3.length, ((a, b = 2) => a).length, ((...xs) => xs).length);

৬ · Composition — compose আর pipe

গণিতে দুটি function-এর composition লেখা হয় (f ∘ g)(x) = f(g(x)) — আগে g, তারপর তার ফলে f. প্রোগ্রামে function composition মানে ঠিক এটাই: কয়েকটি ছোট function জুড়ে একটি নতুন function, যেখানে প্রতিটির output পরেরটির input. হাতে লিখলে roundToPaisa(addVat(applyDiscount(1000))) — কাজ করে, কিন্তু পড়তে হয় ভেতর থেকে বাইরে, ডান থেকে বাঁয়ে; আর পাঁচটি ধাপ হলে বন্ধনীর জঙ্গল।

সমাধান দুটি ছোট সাহায্যকারী, দুটোই পর্ব ১৬-এর reduce দিয়ে এক লাইনে:

const pipe    = (...fns) => (x) => fns.reduce((v, f) => f(v), x);       // বাঁ থেকে ডানে
const compose = (...fns) => (x) => fns.reduceRight((v, f) => f(v), x);  // ডান থেকে বাঁয়ে

1const pipe = (...fns) => (x) =>2  fns.reduce((v, f) => f(v), x);3const finalPrice = pipe(applyDiscount, addVat, roundToPaisa);4finalPrice(120);

এবার পুরো ছবিটি চালিয়ে দেখুন — দামের পাইপলাইন, curried টাকা-ফরম্যাটার, আর একটি sign-up ফর্মের validation পাইপলাইন, যেখানে প্রতিটি নিয়ম একটি ছোট function:

const pipe = (...fns) => (x) => fns.reduce((v, f) => f(v), x);
const applyDiscount = (p) => p * 0.9;
const addVat = (p) => p * 1.15;
const roundToPaisa = (p) => Math.round(p * 100) / 100;
const finalPrice = pipe(applyDiscount, addVat, roundToPaisa);
console.log(finalPrice(1000), finalPrice(120), addVat(applyDiscount(120)));

const formatTaka = (locale) => (amount) =>
  new Intl.NumberFormat(locale, { style: "currency", currency: "BDT" }).format(amount);
console.log(formatTaka("bn-BD")(finalPrice(1000)));

const required = (field) => (form) => (form[field] ? null : `${field} দরকার`);
const minLen = (field, n) => (form) =>
  (form[field] ?? "").length >= n ? null : `${field} কমপক্ষে ${n} অক্ষর`;
const validate = (rules) => (form) => rules.map((rule) => rule(form)).filter(Boolean);
const checkSignup = validate([required("email"), minLen("password", 8)]);
console.log(checkSignup({ email: "", password: "abc" }));
console.log(checkSignup({ email: "a@b.com", password: "12345678" }));

Point-free style — কখন সুন্দর, কখন ধাঁধা

উপরে pipe(applyDiscount, addVat, roundToPaisa)-এ কোথাও price নামটি লেখা নেই — ডেটার নাম না বলে শুধু function জুড়ে function বানানো হয়েছে। এই লেখার ধরনকে বলে point-free style (“point” মানে এখানে argument). ছোট, ভালো নামওয়ালা ধাপে এটি দারুণ পাঠযোগ্য। কিন্তু বাড়াবাড়ি করলে ধাঁধা হয়ে যায়:

// ধাঁধা: কী করে বোঝা কঠিন
const f = pipe(filter(prop("active")), map(pipe(prop("price"), multiply(1.15))), sum);
// পরিষ্কার: নাম আছে, ধাপ আছে
const activeTotalWithVat = (items) => items
  .filter((i) => i.active)
  .map((i) => addVat(i.price))
  .reduce((s, p) => s + p, 0);

ভবিষ্যতের |> — TC39-এর pipeline operator প্রস্তাব

বহু বছর ধরে JavaScript-এ একটি pipeline operator আনার আলোচনা চলছে, যাতে pipe helper ছাড়াই বাঁ থেকে ডানে লেখা যায়। কয়েকটি প্রতিদ্বন্দ্বী নকশার মধ্যে ২০২১ সালে “Hack-style” নকশাটি Stage 2-এ ওঠে, আর আমাদের জানা মতে এই লেখার সময়ও সেখানেই আছে — অর্থাৎ এখনো মানদণ্ডের অংশ নয়, কোনো ব্রাউজার বা Node.js-এ সরাসরি চলে না, আর চেহারা বদলাতে পারে। এই নকশায় একটি বিশেষ “topic” চিহ্ন আগের ধাপের মানকে বোঝায়; চিহ্নটি কী হবে, তা নিয়ে আলোচনা এখনো চলছে। উদাহরণে % ধরে নিচ্ছি:

// প্রস্তাবিত ব্যাকরণ — এখন কোথাও চলে না (Stage 2)
const label = 1000
  |> applyDiscount(%)
  |> addVat(%)
  |> roundToPaisa(%)
  |> formatTaka("bn-BD")(%);

৭ · Pure reducer আর declarative ডেটা রূপান্তর

Functional চিন্তার সবচেয়ে প্রভাবশালী বাস্তব প্রয়োগ সম্ভবত reducer: একটি pure function, যে বর্তমান state আর একটি “action” (কী ঘটল তার বর্ণনা) নিয়ে নতুন state ফেরত দেয় — (state, action) => newState. নামটি এসেছে reduce থেকে, কারণ action-এর একটি তালিকাকে actions.reduce(reducer, initialState) দিয়ে চালালে শেষ state পাওয়া যায়। Redux আর React-এর useReducer এই চিন্তার ওপর দাঁড়িয়ে। একটি শপিং কার্টের reducer:

const cartReducer = (state, action) => {
  switch (action.type) {
    case "add":    return [...state, action.item];
    case "remove": return state.filter((i) => i.id !== action.id);
    case "qty":    return state.map((i) => i.id === action.id ? { ...i, qty: action.qty } : i);
    default:       return state;                  // অজানা action — state হুবহু
  }
};

1const s0 = [];2const s1 = cartReducer(s0, { type: "add", item: চাল });3const s2 = cartReducer(s1, { type: "add", item: ডাল });4const s3 = cartReducer(s2, { type: "remove", id: 1 });5// = [a1, a2, a3].reduce(cartReducer, [])

Declarative ডেটা রূপান্তর — নামওয়ালা ছোট ধাপ

পর্ব ১৬-এ chaining দিয়ে পাইপলাইন বানিয়েছেন। Functional চিন্তা এক ধাপ এগোয়: প্রতিটি ধাপকে নাম দিন, যাতে পাইপলাইন একটি বাক্যের মতো পড়া যায়, আর প্রতিটি নিয়ম আলাদাভাবে টেস্ট ও পুনর্ব্যবহার করা যায়:

const isDelivered = (o) => o.status === "delivered";
const inDistrict  = (d) => (o) => o.district === d;     // curried predicate
const lineTotal   = (o) => o.price * o.qty;
const sum         = (a, b) => a + b;

const dhakaRevenue = orders
  .filter(isDelivered)
  .filter(inDistrict("ঢাকা"))
  .map(lineTotal)
  .reduce(sum, 0);

৮ · Recursion, memoization, null সামলানো আর বাস্তবের FP

Recursion বনাম iteration — আর tail call-এর গল্প

Pure functional ভাষায় লুপ নেই, কারণ লুপ মানে একটি counter বদলানো। সেখানে পুনরাবৃত্তি হয় recursion দিয়ে — function নিজেকে ছোট সমস্যা দিয়ে ডাকে। যেমন const sumList = (xs) => xs.length === 0 ? 0 : xs[0] + sumList(xs.slice(1));. গাছের মতো nested ডেটা (folder-এর ভেতরে folder, মন্তব্যের ভেতরে উত্তর) ঘোরার জন্য recursion সত্যিই স্বাভাবিক আর সুন্দর।

কিন্তু JavaScript-এ একটি বাস্তব সীমা আছে। প্রতিটি কল call stack-এ একটি নতুন frame যোগ করে (পর্ব ০৫), আর stack-এর আকার সীমিত। কয়েক হাজার থেকে কয়েক দশ হাজার স্তর গভীরে (engine আর frame-এর আকারভেদে) Chrome, Edge আর Node.js দেয় RangeError: Maximum call stack size exceeded. Functional ভাষাগুলো এ সমস্যা এড়ায় tail call optimization দিয়ে: function-এর একেবারে শেষ কাজ যদি আরেকটি কল হয়, তবে পুরোনো frame ফেলে দিয়ে নতুন কল সেই জায়গা নেয় — stack বাড়ে না।

ES2015 মানদণ্ডে strict mode-এর জন্য এই “proper tail calls” বাধ্যতামূলক করা হয়েছিল। কিন্তু বাস্তবে শুধু Safari-র engine (JavaScriptCore) এটি চালু করেছে; V8 (Chrome, Edge, Node.js) আর Firefox করেনি — কারণ ভাবনার প্রশ্ন ৫-এ। তাই ব্যবহারিক নিয়ম: অল্প গভীরতার গাছ-ধাঁচের ডেটায় recursion; লম্বা তালিকায় reduce, for…of বা নিজের stack দিয়ে iteration. ১০ লাখ উপাদানের array-এ উপরের sumList ভেঙে যাবে (আর slice প্রতিবার কপি করে বলে ধীরও); reduce যাবে না।

Memoization — pure function-এর পুরস্কার

পর্ব ২২-এ closure দিয়ে memoize(fn) বানিয়েছেন: একটি Map-এ আগের input-এর ফল রেখে, আবার একই input এলে হিসাব না করে রাখা ফল ফেরত দেওয়া। এখানে শুধু মনে রাখুন কেন এটি নিরাপদ: memoization শুধু pure function-এ সঠিক. Impure function (যেমন অংশ ২-এর addImpure, বা সময়-নির্ভর কিছু) memoize করলে পুরোনো, ভুল ফল ফেরত আসবে। আর cache-এর key সাধারণত argument দিয়ে বানানো হয়, তাই object argument-এ reference বদলালেই cache কাজ করবে না — immutable update-এর সাথে এটি খুব ভালো মেলে, কারণ “নতুন reference মানেই নতুন ডেটা”।

null সামলানো — ছোট “হয়তো আছে” ধাপ

পাইপলাইনের মাঝে কোনো ধাপ null বা undefined দিলে পরের ধাপ ভেঙে যায়: TypeError: Cannot read properties of undefined. আধুনিক JavaScript-এ সবচেয়ে সহজ উত্তর পর্ব ০৮-এর ?. আর ??: user?.address?.city ?? "অজানা" — যেকোনো স্তরে মান না থাকলে পুরো expression নিরাপদে undefined হয়, আর শেষে একটি ডিফল্ট বসে। Functional ধাঁচে আরেকটি পরিচিত কৌশল হলো মানটিকে একটি ছোট array-তে রাখা — খালি array মানে “নেই”: [user].filter((u) => u != null).map(getCity). মান না থাকলে map কিছুই করে না, কোনো error নেই।

এই চিন্তা — একটি “বাক্স” যার ভেতরে মান থাকতেও পারে, না-ও পারে, আর বাক্স না খুলেই তার ওপর function চালানো — functional ভাষায় Maybe বা Option নামে পরিচিত। যে বাক্সে map চালানো যায় তাকে তত্ত্বে Functor বলে, আর যেখানে ধাপগুলো নিজেরাই বাক্স ফেরত দেয় সেগুলো জোড়ার নিয়মকে Monad. এই নামগুলো আরও পড়ার জন্য রেখে দিন; দৈনন্দিন JavaScript-এ ?., ?? আর Promise (পর্ব ৩৩) একই চিন্তার ব্যবহারিক রূপ।

বাস্তবের FP — যেখানে আপনি ইতিমধ্যেই এটি ব্যবহার করছেন

৯ · AI-এর যুগে — AI-এর লেখা “functional” কোড যাচাই করা

“এই কোডটা functional style-এ লিখে দাও” — AI-কে বললে প্রায়ই খুব চতুর দেখতে কোড আসে। চতুর আর সঠিক এক জিনিস নয়। এই বিষয়ে AI-এর কয়েকটি নির্দিষ্ট অভ্যাস:

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

• “Pure” বলা প্রতিটি function-এ argument বদলানো, global variable, Date.now(), Math.random(), নেটওয়ার্ক বা DOM নেই
• Reducer-এর প্রতিটি শাখা নতুন object/array দেয়, আর অজানা action-এ একই state ফেরত দেয়
• শুরুর ডেটা deep freeze করে strict mode-এ চালিয়ে দেখেছি — কোনো TypeError আসেনি
• Point-free অংশগুলো একজন সহকর্মী এক নজরে বুঝতে পারেন; না পারলে নাম আর argument যোগ করেছি
• Generic curry-তে পাঠানো function-এ default বা rest parameter নেই (fn.length ঠিক আছে)
• লম্বা তালিকায় recursion নেই; reduce শুধু অনেক থেকে একটি মান বানাতে
• Memoize করা প্রতিটি function সত্যিই pure