TypeScript में कार्यात्मक प्रोग्रामिंग: उन्नत स्तर

TypeScript में कार्यात्मक प्रोग्रामिंग: उन्नत स्तर

कार्यात्मक प्रोग्रामिंग (FP) एक प्रतिमान है जो गणना को गणितीय कार्यों के मूल्यांकन के रूप में मानता है और स्थिति में परिवर्तन और परिवर्तनीय डेटा से बचता है। TypeScript, JavaScript के ऊपर एक परत होने के नाते, एक शक्तिशाली टाइप सिस्टम प्रदान करता है जो सुरक्षा और अभिव्यक्ति के एक नए स्तर पर FP की कई अवधारणाओं को लागू करने की अनुमति देता है। इस लेख में, हम उन्नत तकनीकों पर चर्चा करेंगे: सख्त इम्यूटेबिलिटी से लेकर मोनाड और फंक्टर के साथ काम करने तक।

इम्यूटेबिलिटी और अपरिवर्तनीय संरचनाओं के साथ कार्य

इम्यूटेबिलिटी (अपरिवर्तनीयता) FP की आधारशिला है। TypeScript में, हम readonly मॉडिफायर और यूटिलिटी टाइप का उपयोग करके टाइप स्तर पर इसकी गारंटी दे सकते हैं।

// ReadonlyDeep के माध्यम से गहरी अपरिवर्तनीयता\ntype DeepReadonly<T> = {\n  readonly [P in keyof T]: DeepReadonly<T[P]>;\n};\n\ninterface User {\n  name: string;\n  address: { city: string; zip: number };\n}\n\nconst user: DeepReadonly<User> = {\n  name: "Alice",\n  address: { city: "Moscow", zip: 101000 }\n};\n\n// user.address.city = "SPb"; // त्रुटि! गुण केवल पढ़ने योग्य है

डेटा को सुरक्षित रूप से अपडेट करने के लिए शुद्ध कार्यों का उपयोग करें जो नई वस्तुएँ लौटाते हैं:

function updateZip(user: DeepReadonly<User>, newZip: number): DeepReadonly<User> {\n  return { ...user, address: { ...user.address, zip: newZip } };\n}\n\nconst updatedUser = updateZip(user, 190000);

फंक्शन कंपोज़िशन और करीइंग

कंपोज़िशन सरल कार्यों से जटिल रूपांतरण बनाने की अनुमति देता है। TypeScript में, जेनेरिक की मदद से हम टाइप-सुरक्षित कॉम्बिनेटर बना सकते हैं।

// दो कार्यों के कंपोज़िशन के लिए प्रकार\ntype Compose<A, B, C> = (f: (b: B) => C, g: (a: A) => B) => (a: A) => C;\n\nconst compose: Compose<any, any, any> = (f, g) => (x) => f(g(x));\n\n// उदाहरण: स्ट्रिंग को संख्या में बदलना और 1 से बढ़ाना\nconst toNumber = (s: string): number => parseInt(s, 10);\nconst increment = (n: number): number => n + 1;\n\nconst parseAndIncrement = compose(increment, toNumber);\nconsole.log(parseAndIncrement("5")); // 6

करीइंग एक बहु-तर्क कार्य को एक-तर्क कार्यों के अनुक्रम में बदल देता है। यह कंपोज़िशन को अधिक लचीला बनाता है:

// प्रकारों के साथ सार्वभौमिक करीइंग फंक्शन\nfunction curry<T1, T2, R>(fn: (a: T1, b: T2) => R): (a: T1) => (b: T2) => R {\n  return (a: T1) => (b: T2) => fn(a, b);\n}\n\nconst add = (a: number, b: number): number => a + b;\nconst curriedAdd = curry(add);\nconst add5 = curriedAdd(5);\nconsole.log(add5(3)); // 8

फंक्टर और मोनाड: संदर्भों के साथ कार्य

फंक्टर एक डेटा संरचना है जो map ऑपरेशन का समर्थन करती है। TypeScript में, एक ऐरे, Promise या उपयोगकर्ता-परिभाषित प्रकार फंक्टर हो सकता है।

// null/undefined के साथ सुरक्षित कार्य के लिए फंक्टर Option (Maybe)\ninterface Option<T> {\n  map<U>(fn: (value: T) => U): Option<U>;\n  getOrElse(defaultValue: T): T;\n}\n\nclass Some<T> implements Option<T> {\n  constructor(private value: T) {}\n  map<U>(fn: (value: T) => U): Option<U> {\n    return new Some(fn(this.value));\n  }\n  getOrElse(_: T): T {\n    return this.value;\n  }\n}\n\nclass None<T> implements Option<T> {\n  map<U>(_: (value: T) => U): Option<U> {\n    return new None<U>();\n  }\n  getOrElse(defaultValue: T): T {\n    return defaultValue;\n  }\n}\n\n// उपयोग\nconst maybeNumber: Option<number> = new Some(42);\nconst result = maybeNumber.map(x => x * 2).getOrElse(0); // 84

मोनाड फंक्टर को flatMap (या bind) विधि से विस्तारित करता है