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

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

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

1. शुद्ध फ़ंक्शन और अपरिवर्तनीयता

शुद्ध फ़ंक्शन वह फ़ंक्शन है जो:

\n
• समान तर्कों के लिए हमेशा समान परिणाम लौटाता है (नियतिवाद)।
\n
• इसका कोई दुष्प्रभाव नहीं होता (बाहरी स्थिति नहीं बदलता, फ़ाइलों/नेटवर्क में नहीं लिखता)।
\n

Go में, डेटा की प्रतियां पास करके और स्थिरांक का उपयोग करके अपरिवर्तनीयता प्राप्त की जाती है। शुद्ध फ़ंक्शन का उदाहरण:

package main\n\nimport "fmt"\n\n// शुद्ध फ़ंक्शन: मूल स्लाइस को नहीं बदलता, नया लौटाता है\nfunc DoubleSlice(s []int) []int {\n    result := make([]int, len(s))\n    for i, v := range s {\n        result[i] = v * 2\n    }\n    return result\n}\n\nfunc main() {\n    original := []int{1, 2, 3}\n    doubled := DoubleSlice(original)\n    fmt.Println(original) // [1 2 3] — कोई बदलाव नहीं\n    fmt.Println(doubled)  // [2 4 6]\n}

शुद्ध फ़ंक्शन का उपयोग रीफैक्टरिंग और परीक्षण को सरल बनाता है, क्योंकि छिपी हुई स्थिति पर विचार करने की आवश्यकता नहीं होती।

2. उच्च-क्रम फ़ंक्शन और क्लोजर

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

उच्च-क्रम फ़ंक्शन का उदाहरण — Filter:

package main\n\nimport "fmt"\n\n// Filter एक नया स्लाइस लौटाता है जिसमें वे तत्व होते हैं जो विधेय को संतुष्ट करते हैं\nfunc Filter[T any](s []T, predicate func(T) bool) []T {\n    var result []T\n    for _, v := range s {\n        if predicate(v) {\n            result = append(result, v)\n        }\n    }\n    return result\n}\n\nfunc main() {\n    numbers := []int{1, 2, 3, 4, 5, 6}\n    even := Filter(numbers, func(n int) bool { return n%2 == 0 })\n    fmt.Println(even) // [2 4 6]\n}

क्लोजर का उपयोग अक्सर फ़ंक्शन फ़ैक्टरी बनाने या स्थिति को एनकैप्सुलेट करने के लिए किया जाता है:

package main\n\nimport "fmt"\n\n// Counter एक क्लोजर बनाता है जो आंतरिक स्थिति संग्रहीत करता है\nfunc Counter() func() int {\n    count := 0\n    return func() int {\n        count++\n        return count\n    }\n}\n\nfunc main() {\n    c1 := Counter()\n    fmt.Println(c1()) // 1\n    fmt.Println(c1()) // 2\n\n    c2 := Counter()\n    fmt.Println(c2()) // 1 — स्वतंत्र स्थिति\n}

3. फ़ंक्शन संयोजन और आंशिक अनुप्रयोग (करीइंग)

संयोजन कई फ़ंक्शनों को एक नए फ़ंक्शन में जोड़ना है। Go में, संयोजन मध्यवर्ती फ़ंक्शनों के माध्यम से कार्यान्वित किया जाता है। आंशिक अनुप्रयोग (करीइंग) तर्कों के एक भाग को स्थिर करने और शेष की प्रतीक्षा करने वाला फ़ंक्शन लौटाने की अनुमति देता है।

संयोजन का उदाहरण:

package main\n\nimport "fmt"\n\n// Compose दो फ़ंक्शनों को जोड़ता है: f(g(x))\nfunc Compose[A, B, C any](f func(B) C, g func(A) B) func(A) C {\n    return func(x A) C {\n        return f(g(x))\n    }\n}\n\nfunc addOne(x int) int { return x + 1 }\nfunc double(x int) int { return x * 2 }\n\nfunc main() {\n    addThenDouble := Compose(double, addOne)\n    fmt.Println(addThenDouble(3)) // (3+1)*2 = 8\n}

योग फ़ंक्शन के उदाहरण पर करीइंग:

package main\n\nimport "fmt"\n\n// Add — करीड संस्करण जोड़ का\nfunc Add(a int) func(int) int {\n    return func(b int) int {\n        return a + b\n    }\n}\n\nfunc main() {\n    addFive := Add(5)\n    fmt.