Go में कार्यात्मक प्रोग्रामिंग: संभावनाएँ और उदाहरण

Go में कार्यात्मक प्रोग्रामिंग: सिद्धांत से व्यवहार तक

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

1. प्रथम श्रेणी के फंक्शन और उच्च कोटि के फंक्शन

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

उदाहरण: तर्क के रूप में फंक्शन पास करना

package main

import "fmt"

// उच्च कोटि का फंक्शन: एक फंक्शन स्वीकार करता है और इसे संख्या पर लागू करता हैfunc applyOperation(x int, op func(int) int) int {    return op(x)}

func double(x int) int {    return x * 2}

func square(x int) int {    return x * x}

func main() {    result1 := applyOperation(5, double)    result2 := applyOperation(5, square)

    fmt.Println("Double:", result1) // 10    fmt.Println("Square:", result2) // 25}

उदाहरण: फंक्शन से फंक्शन लौटाना (फंक्शन फैक्ट्री)

package main

import "fmt"

// एक फंक्शन लौटाता है जो दिए गए मान को जोड़ता हैfunc createAdder(x int) func(int) int {    return func(y int) int {        return x + y    }}

func main() {    addFive := createAdder(5)    addTen := createAdder(10)

    fmt.Println(addFive(3))  // 8    fmt.Println(addTen(3))   // 13}

2. Go में क्लोजर

क्लोजर एक फंक्शन है जो बाहरी स्कोप से वेरिएबल्स को "याद" रखता है, भले ही वह स्कोप निष्पादित हो चुका हो। क्लोजर एनकैप्सुलेटेड स्टेट और फंक्शन फैक्ट्री बनाने के लिए एक शक्तिशाली उपकरण हैं।

उदाहरण: अनुक्रम जनरेटर

package main

import "fmt"

func sequenceGenerator() func() int {    i := 0    return func() int {        i++        return i    }}

func main() {    next := sequenceGenerator()

    fmt.Println(next()) // 1    fmt.Println(next()) // 2    fmt.Println(next()) // 3

    // नया जनरेटर 1 से शुरू होता है    next2 := sequenceGenerator()    fmt.Println(next2()) // 1}

महत्वपूर्ण: लूप में क्लोजर से सावधान रहें। Go के पुराने संस्करणों (1.22 से पहले) में, लूप में वेरिएबल i का पुन: उपयोग किया जाता था, जिससे त्रुटियाँ होती थीं। Go 1.22 से शुरू करके, लूप वेरिएबल वैल्यू द्वारा कैप्चर किए जाते हैं।

3. शुद्ध फंक्शन और इम्यूटेबिलिटी

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

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

Go में इम्यूटेबिलिटी के लिए कोई अंतर्निहित समर्थन नहीं है, लेकिन हम स्वयं इस सिद्धांत का पालन कर सकते हैं।

उदाहरण: शुद्ध बनाम अशुद्ध फंक्शन

package main

import "fmt"

// अशुद्ध फंक्शन: बाहरी स्लाइस को बदलता हैvar counter int

func impureAddToSlice(s []int, val int) []int {    counter++ // साइड इफेक्ट    return append(s, val)}

// शुद्ध फंक्शन: एक नया स्लाइस बनाता हैfunc pureAddToSlice(s []int, val int) []int {    newSlice := make([]int, len(s)+1)    copy(newSlice, s)    newSlice[len(s)] = val    return newSlice}

func main() {    original := []int{1, 2, 3}

    // शुद्ध दृष्टिकोण    result := pureAddToSlice(original, 4)    fmt.Println("Original:", original) // [1 2 3] - नहीं बदला    fmt.Println("Result:", result)     // [1 2 3 4]}

सुझाव: इम्यूटेबल स्ट्रक्चर के साथ काम करने के लिए