Swift में कार्यात्मक प्रोग्रामिंग: A से Z तक — पूर्ण गाइड

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

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

Swift में कार्यात्मक दृष्टिकोण के मूल सिद्धांत

कार्यात्मक प्रोग्रामिंग के मूल में कई प्रमुख सिद्धांत हैं:

\n
• शुद्ध फलन — परिणाम केवल इनपुट आर्गुमेंट पर निर्भर करता है, बिना किसी दुष्प्रभाव के।
\n
• डेटा की अपरिवर्तनीयता — var के बजाय let का उपयोग।
\n
• प्रथम श्रेणी की वस्तु के रूप में फलन — इन्हें पास, रिटर्न और स्टोर किया जा सकता है।
\n

आइए एक शुद्ध फलन का सरल उदाहरण देखें:

// शुद्ध फलन: कोई दुष्प्रभाव नहीं\nfunc add(_ a: Int, _ b: Int) -> Int {\n    return a + b\n}\n\n// उपयोग\nlet result = add(3, 5) // 8\nprint(result)\n

क्लोज़र और उच्च-क्रम फलन

क्लोज़र (closures) स्व-निहित कार्यक्षमता के ब्लॉक हैं जिन्हें कोड में पास और उपयोग किया जा सकता है। ये उच्च-क्रम फलनों के साथ काम करने का आधार हैं।

// सरल क्लोज़र\nlet multiply = { (x: Int, y: Int) -> Int in\n    return x * y\n}\n\nlet product = multiply(4, 7) // 28\nprint(product)\n

Swift कलेक्शन के साथ काम करने के लिए शक्तिशाली उच्च-क्रम फलन प्रदान करता है:

map

map ऐरे के प्रत्येक तत्व पर एक रूपांतरण लागू करता है:

let numbers = [1, 2, 3, 4, 5]\nlet squared = numbers.map { $0 * $0 }\nprint(squared) // [1, 4, 9, 16, 25]\n

filter

filter शर्त को पूरा करने वाले तत्वों का चयन करता है:

let evenNumbers = numbers.filter { $0 % 2 == 0 }\nprint(evenNumbers) // [2, 4]\n

reduce

reduce सभी तत्वों को एक मान में जोड़ता है:

let sum = numbers.reduce(0, +)\nprint(sum) // 15\n

फलन संरचना और करीइंग

फलन संरचना सरल फलनों को अधिक जटिल फलनों में संयोजित करने की अनुमति देती है। Swift में कोई अंतर्निहित संरचना ऑपरेटर नहीं है, लेकिन इसे आसानी से लागू किया जा सकता है:

// संरचना ऑपरेटर\nprecedencegroup CompositionPrecedence {\n    associativity: left\n    higherThan: AssignmentPrecedence\n}\n\ninfix operator >>>: CompositionPrecedence\n\nfunc >>> <A, B, C>(left: @escaping (A) -> B, right: @escaping (B) -> C) -> (A) -> C {\n    return { right(left($0)) }\n}\n\n// उपयोग\nfunc double(_ x: Int) -> Int { x * 2 }\nfunc toString(_ x: Int) -> String { "\\(x)" }\n\nlet doubleThenString = double >>> toString\nprint(doubleThenString(5)) // "10"\n

करीइंग एक फलन का रूपांतरण है जो कई आर्गुमेंट लेता है, फलनों के अनुक्रम में, जिनमें से प्रत्येक एक आर्गुमेंट लेता है:

// सामान्य फलन\nfunc add(_ a: Int, _ b: Int) -> Int { a + b }\n\n// करीड संस्करण\nfunc curriedAdd(_ a: Int) -> (Int) -> Int {\n    return { b in a + b }\n}\n\nlet addFive = curriedAdd(5)\nprint(addFive(3)) // 8\n

Swift में मोनाड और फंक्टर

कार्यात्मक प्रोग्रामिंग में फंक्टर एक प्रकार है जिसे मैप (map) किया जा सकता है। मोनाड एक फंक्टर है जिसमें अतिरिक्त ऑपरेशन flatMap (या >>=) होता है। Swift में सबसे प्रसिद्ध उदाहरण Optional और Array हैं।

Optional एक मोनाड के रूप में

let optionalValue: Int? = 5\n\n// map — फलन लागू करता है यदि मान nil नहीं है\nlet doubled = optionalValue.map { $0 * 2 }\nprint(doubled) // Optional(10)\n\n// flatMap