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

शुरुआती लोगों के लिए ऑनलाइन Python प्रशिक्षक

Python आसानी से सीखें बिना सिद्धांत के बोझ के। स्वचालित जांच के साथ व्यावहारिक कार्य हल करें और ब्राउज़र में सीधे कोड लिखें।

पाठ्यक्रम शुरू करें

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

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

1. करीइंग और फलनों का आंशिक अनुप्रयोग

करीइंग एक ऐसा रूपांतरण है जो कई तर्क लेने वाले फलन को फलनों के अनुक्रम में बदल देता है, जिनमें से प्रत्येक एक तर्क लेता है। Go में, जहाँ करीइंग के लिए कोई अंतर्निहित समर्थन नहीं है, हम इसे क्लोज़र के माध्यम से कार्यान्वित करते हैं।

उदाहरण: कॉन्फ़िगरेबल लॉगर के लिए करीइंग

package main

import "fmt"

// करीड फलन: प्रीफिक्स -> संदेश -> आउटपुटfunc createLogger(prefix string) func(string) {    return func(message string) {        fmt.Printf("[%s] %s", prefix, message)    }}

func main() {    infoLogger := createLogger("INFO")    errorLogger := createLogger("ERROR")

    infoLogger("सिस्टम शुरू हुआ")    errorLogger("कनेक्शन त्रुटि")    // आउटपुट:    // [INFO] सिस्टम शुरू हुआ    // [ERROR] कनेक्शन त्रुटि}

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

// आंशिक अनुप्रयोग: गुणांक को स्थिर करनाfunc multiply(a, b int) int {    return a * b}

func partialMultiply(a int) func(int) int {    return func(b int) int {        return multiply(a, b)    }}

func main() {    double := partialMultiply(2)    triple := partialMultiply(3)

    fmt.Println(double(5)) // 10    fmt.Println(triple(5)) // 15}

2. फलन संयोजन और पाइपलाइन

संयोजन सरल फलनों को अधिक जटिल फलनों में संयोजित करना है। Go में, हम एक फलन के परिणाम को दूसरे फलन के इनपुट में पास करके रूपांतरणों की श्रृंखला बना सकते हैं। यह इंटरफ़ेस और जेनेरिक (Go 1.18+) के संयोजन में विशेष रूप से शक्तिशाली रूप से काम करता है।

उदाहरण: स्ट्रिंग प्रसंस्करण के लिए संयोजन

package main

import (    "fmt"    "strings"    "unicode")

type StringTransform func(string) string

// Compose दो फलनों का संयोजन बनाता हैfunc Compose(f, g StringTransform) StringTransform {    return func(s string) string {        return f(g(s))    }}

// Pipeline कई फलनों को जोड़ता हैfunc Pipeline(transforms ...StringTransform) StringTransform {    return func(s string) string {        for _, t := range transforms {            s = t(s)        }        return s    }}

func removeSpaces(s string) string {    return strings.ReplaceAll(s, " ", "")}

func toUpper(s string) string {    return strings.ToUpper(s)}

func removeDigits(s string) string {    var result strings.Builder    for _, r := range s {        if !unicode.IsDigit(r) {            result.WriteRune(r)        }    }    return result.String()}

func main() {    // दो फलनों का संयोजन    cleanAndUpper := Compose(removeSpaces, toUpper)    result1 := cleanAndUpper("go 1.18 rocks")    fmt.Println(result1) // "GO1.18ROCKS"

    // तीन फलनों की पाइपलाइन    pipeline := Pipeline(removeSpaces, removeDigits, toUpper)    result2 := pipeline("go 1.18 rocks")    fmt.Println(result2) // "GOROCKS"}

यह दृष्टिकोण सरल, परीक्षण योग्य ब्लॉकों से जटिल रूपांतरण बनाने की अनुमति देता है। पाइपलाइन के प्रत्येक फलन का अलग-अलग परीक्षण किया जा सकता है।