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

Go में कार्यात्मक प्रोग्रामिंग: अनिवार्य से घोषणात्मक की ओर

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

Go के संदर्भ में FP के मूल सिद्धांत

Go में कार्यात्मक प्रोग्रामिंग का अर्थ परिवर्तनीय स्थिति का पूर्ण त्याग नहीं है। इसके बजाय, हम निम्नलिखित अवधारणाओं का उपयोग करते हैं:

• शुद्ध फलन — ऐसे फलन जिनका परिणाम केवल तर्कों पर निर्भर करता है, बिना किसी दुष्प्रभाव के।
• अपरिवर्तनीयता (Immutability) — मौजूदा संरचनाओं को बदलने के बजाय नई डेटा संरचनाएँ बनाने की प्राथमिकता।
• उच्च-क्रम फलन — ऐसे फलन जो अन्य फलनों को तर्क के रूप में लेते हैं या उन्हें लौटाते हैं।
• क्लोजर (Closures) — ऐसे फलन जो बाहरी दायरे से चरों को कैप्चर करते हैं।

उच्च-क्रम फलन: map, filter, reduce

Go में (संस्करण 1.18 से पहले) अंतर्निहित जेनेरिक नहीं हैं, इसलिए क्लासिक map, filter, reduce को इंटरफेस या स्पष्ट प्रतिलिपि के माध्यम से कार्यान्वित किया जाता है। पूर्णांकों के साथ एक उदाहरण देखें:

package main

import "fmt"

// Map — फलन को स्लाइस के प्रत्येक तत्व पर लागू करता हैfunc Map(s []int, fn func(int) int) []int {    result := make([]int, len(s))    for i, v := range s {        result[i] = fn(v)    }    return result}

// Filter — केवल उन तत्वों को रखता है जो शर्त को पूरा करते हैंfunc Filter(s []int, fn func(int) bool) []int {    var result []int    for _, v := range s {        if fn(v) {            result = append(result, v)        }    }    return result}

// Reduce — स्लाइस को एक मान में समेटता हैfunc Reduce(s []int, init int, fn func(int, int) int) int {    acc := init    for _, v := range s {        acc = fn(acc, v)    }    return acc}

func main() {    nums := []int{1, 2, 3, 4, 5}

    // प्रत्येक तत्व को दोगुना करें    doubled := Map(nums, func(x int) int { return x * 2 })    fmt.Println("Map:", doubled) // [2 4 6 8 10]

    // केवल सम संख्याएँ रखें    evens := Filter(nums, func(x int) bool { return x%2 == 0 })    fmt.Println("Filter:", evens) // [2 4]

    // सभी तत्वों का योग करें    sum := Reduce(nums, 0, func(acc, x int) int { return acc + x })    fmt.Println("Reduce:", sum) // 15}

महत्वपूर्ण: Go 1.8+ में जेनेरिक के साथ, सार्वभौमिक संस्करण बनाए जा सकते हैं:

// Generic Mapfunc MapGeneric[T, U any](s []T, fn func(T) U) []U {    result := make([]U, len(s))    for i, v := range s {        result[i] = fn(v)    }    return result}

Go में क्लोजर और करीइंग

Go में क्लोजर स्थिति बनाए रखने वाले फलन बनाने के लिए एक शक्तिशाली उपकरण है। अनुक्रम जनरेटर का एक उदाहरण देखें:

package main

import "fmt"

// फिबोनाची अनुक्रम जनरेटरfunc fibonacci() func() int {    a, b := 0, 1    return func() int {        a, b = b, a+b        return a    }}

// करीइंग: एक फलन जो तर्कों को चरणबद्ध रूप से लेता हैfunc add(a int) func(int) int {    return func(b int) int {        return a + b    }}

func main() {    fib := fibonacci()    fmt.Println(fib()) // 1    fmt.Println(fib()) // 1    fmt.Println(fib()) // 2

    // करीइंग    add5 := add(5)    fmt.Println(add5(10)) // 15    fmt.Println(add5(20)) // 25}

क्लोजर विशेष रूप से इसके लिए उपयोगी हैं:

• कॉन्फ़िगरेबल फलन (मिडलवेयर) बनाना
• "फलन फैक्ट्री" पैटर्न को लागू करना
• कॉलबैक तंत्र को व्यवस्थित करना

अपरिवर्तनीयता