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

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

कार्यात्मक प्रोग्रामिंग (FP) एक प्रतिमान है जो गणनाओं को गणितीय फलनों के मूल्यांकन के रूप में मानता है और स्थिति में परिवर्तन और परिवर्तनीय डेटा से बचता है। Swift में, जो एक बहु-प्रतिमान भाषा है, कार्यात्मक क्षमताएँ केवल समर्थित नहीं हैं, बल्कि भाषा और मानक पुस्तकालय में गहराई से एकीकृत हैं। यदि आप पहले से ही map, filter और reduce जैसी बुनियादी अवधारणाओं में महारत हासिल कर चुके हैं, तो अब उन्नत तकनीकों में गहराई से उतरने का समय है जो iOS और macOS अनुप्रयोगों के लिए अधिक सुरक्षित, पूर्वानुमानित और परीक्षण योग्य कोड लिखने में मदद करेंगी। इस लेख में, हम व्यावहारिक उदाहरणों के साथ फंक्टर, मोनैड, आलसी गणना और फ़ंक्शन संयोजन पर चर्चा करेंगे।

1. फंक्टर: परिवर्तन की क्षमता वाले कंटेनर

फंक्टर एक डेटा प्रकार है जो fmap फ़ंक्शन को लागू करता है (Swift में — map). फंक्टर का सार यह है कि यह एक कंटेनर का प्रतिनिधित्व करता है, जिसकी सामग्री को कंटेनर की सीमा से बाहर निकले बिना पारित फ़ंक्शन का उपयोग करके रूपांतरित किया जा सकता है। इसका एक उत्कृष्ट उदाहरण Optional है।

देखते हैं कि Optional के उदाहरण पर फंक्टर कैसे काम करता है:

let maybeNumber: Int? = 5\nlet result = maybeNumber.map { $0 * 2 }\nprint(result) // Optional(10)\n\nlet nilValue: Int? = nil\nlet nilResult = nilValue.map { $0 * 2 }\nprint(nilResult) // nil

यहाँ Optional एक फंक्टर है। यदि अंदर कोई मान है, तो map क्लोज़र को लागू करता है और एक नया Optional लौटाता है। यदि कोई मान नहीं है — तो ऑपरेशन निष्पादित नहीं होता है, और हमें nil मिलता है। यह भारी if let निर्माणों से बचाता है।

Swift में एक और महत्वपूर्ण फंक्टर Array है। सरणी पर map प्रत्येक तत्व पर फ़ंक्शन लागू करता है और एक नई सरणी लौटाता है:

let numbers = [1, 2, 3, 4]\nlet doubled = numbers.map { $0 * 2 }\nprint(doubled) // [2, 4, 6, 8]

अपना स्वयं का फंक्टर बनाना. आप map विधि को परिभाषित करके किसी भी कस्टम प्रकार के लिए फंक्टर लागू कर सकते हैं। उदाहरण के लिए, लॉगिंग के लिए एक सरल रैपर:

struct Logged<T> {\n    let value: T\n    let log: [String]\n    \n    func map<U>(_ transform: (T) -> U) -> Logged<U> {\n        let newValue = transform(value)\n        return Logged<U>(value: newValue, log: log + ["Transformed \\(value) to \\(newValue)"])\n    }\n}\n\nlet logged = Logged(value: 10, log: ["Initial value"])\nlet transformed = logged.map { $0 + 5 }\nprint(transformed.log) // ["Initial value", "Transformed 10 to 15"]

2. मोनैड: संदर्भ के साथ गणनाओं की श्रृंखला

मोनैड एक फंक्टर है जो अतिरिक्त रूप से flatMap (या bind) विधि लागू करता है। यदि map एक सामान्य मान लौटाने वाले फ़ंक्शन को लागू करने की अनुमति देता है, तो flatMap एक ऐसे फ़ंक्शन को लागू करने की अनुमति देता है जो स्वयं उसी संदर्भ में एक मान लौटाता है (उदाहरण के लिए, एक और Optional). यह संदर्भ को बनाए रखते हुए संचालन की श्रृंखला बनाने के लिए एक महत्वपूर्ण उपकरण है।

सबसे स्पष्ट उदाहरण वैकल्पिक मानों के साथ काम करना है। मान लीजिए, हमारे पास एक फ़ंक्शन है जो एक स्ट्रिंग से एक संख्या निकालता है, और एक फ़ंक्शन है जो एक संख्या को दूसरी संख्या से विभाजित करता है, लेकिन दोनों nil लौटा सकते हैं:

func parseNumber(_ string: String) -> Int? {\n    return Int(string)\n}\n\nfunc divideSafely(_ a: Int, by b: Int) -> Int? {\n    guard b != 0 else { return nil }\n    return a / b\n}\n\n// flatMap के बिना नेस्टेड if let का उपयोग करना पड़ता है\nif let num1 = parseNumber("10") {\n    if let result = divideSafely(num1, by: 2) {\n        print(result) // 5\n    }\n}\n\n// flatMap के साथ सब कुछ अधिक सुरुचिपूर्ण हो जाता है\nlet result = parseNumber("10").flatMap { divideSafely($0, by: 2) }\nprint(result) // Optional(5)\n\nlet failed = parseNumber("abc").flatM