डू नोटेशन क्या है?

डू नोटेशन एक वाक्यात्मक चीनी है जिसका उपयोग मुख्य रूप से हास्केल और स्काला जैसी कार्यात्मक प्रोग्रामिंग भाषाओं में किया जाता है। यह मोनैडिक संचालन की श्रृंखला को सरल बनाता है, जिससे कोड अधिक पठनीय और रखरखाव योग्य हो जाता है। इस सुविधा को गो में लाकर, अब हम भिक्षुओं के साथ काम करते समय अधिक स्पष्ट, अधिक अभिव्यंजक कोड लिख सकते हैं।

नोटेशन क्यों करते हैं?

संन्यासियों के साथ व्यवहार करते समय, विशेष रूप से जटिल व्यावसायिक तर्क में, चेनिंग ऑपरेशन बोझिल हो सकते हैं। विभिन्न स्थितियों को संभालने और प्रबंधित करने में त्रुटि अक्सर गहरी अंतर्निहित संरचनाओं का कारण बनती है जिनका पालन करना कठिन होता है। नोटेशन हमें अनिवार्य प्रोग्रामिंग के समान, लेकिन कार्यात्मक प्रोग्रामिंग के सभी लाभों के साथ, अनुक्रमिक शैली में मोनैडिक संचालन लिखने की अनुमति देकर इसका समाधान करता है।

यह मो पैकेज में कैसे काम करता है?

गो में, डू नोटेशन को लागू करना सीधा नहीं था, लेकिन मैं डू फ़ंक्शन का उपयोग करके इसे हासिल करने में कामयाब रहा। यहां एक उदाहरण के साथ इस पर एक त्वरित नज़र डाली गई है कि आप इसका उपयोग कैसे कर सकते हैं:

package main

import (
    "errors"
    "fmt"
    "github.com/samber/mo"
)

func validateBooking(params map[string]string) mo.Result[map[string]string] {
    if params["guest"] != "" && params["roomType"] != "" {
        return mo.Ok(params)
    }
    return mo.Err[map[string]string](errors.New("validation failed"))
}

func createBooking(guest string) mo.Result[string] {
    if guest != "" {
        return mo.Ok("Booking Created for: "   guest)
    }
    return mo.Err[string](errors.New("booking creation failed"))
}

func assignRoom(booking string, roomType string) mo.Result[string] {
    if roomType != "" {
        return mo.Ok("Room Assigned: "   roomType   " for "   booking)
    }
    return mo.Err[string](errors.New("room assignment failed"))
}

// This could be a service package that performs the entire process
func bookRoom(params map[string]string) mo.Result[[]string] {
    return mo.Do(func() []string {
        // Validate booking parameters
        values := validateBooking(params).MustGet()

        // Create booking
        booking := createBooking(values["guest"]).MustGet()

        // Assign room
        room := assignRoom(booking, values["roomType"]).MustGet()

        // Return success with booking and room details
        return []string{booking, room}
    })
}

func main() {
    params := map[string]string{
        "guest":   "Foo",
        "roomType": "Suite",
    }

    result := bookRoom(params)
    if result.IsError() {
        fmt.Println("Error:", result.Error())
    } else {
        fmt.Println("Success:", result.MustGet())
    }
}

इस उदाहरण में, बुकरूम क्रमिक रूप से कई ऑपरेशन करने के लिए डू फ़ंक्शन का उपयोग करता है: बुकिंग मापदंडों को मान्य करना, बुकिंग बनाना और एक कमरा आवंटित करना। प्रत्येक चरण एक परिणाम देता है जिसे डू फ़ंक्शन का उपयोग करके निर्बाध रूप से श्रृंखलाबद्ध किया जा सकता है, जिससे स्वच्छ और पठनीय त्रुटि प्रबंधन सुनिश्चित होता है।

बुकरूम फ़ंक्शन की तुलना

बिना नोटेशन के

आपके पास दो विकल्प हो सकते हैं:

1. बाइंड का उपयोग करना (यदि लागू किया गया हो):
जब इन ऑपरेशनों की नेस्टेड और अनुक्रमिक प्रकृति के कारण कई मोनोडिक ऑपरेशन होते हैं, तो मोनैड्स में "बाइंड" ऑपरेशन कॉलबैक हेल के समान हो सकता है। जब ऐसे कई ऑपरेशनों को एक साथ श्रृंखलाबद्ध किया जाता है, तो कोड गहराई से नेस्टेड हो सकता है और पढ़ने में कठिन हो सकता है, उसी तरह जैसे एसिंक्रोनस प्रोग्रामिंग में कॉलबैक गहराई से नेस्टेड हो सकते हैं। यदि बाइंड को मो पैकेज में लागू किया गया था, तो इस उदाहरण में इसका उपयोग कुछ इस तरह दिखेगा:

func bookRoom(params map[string]string) mo.Result[[]string] {
    return bind(validateBooking(params), func(values map[string]string) mo.Result[[]string] {
        return bind(createBooking(values["guest"]), func(booking string) mo.Result[[]string] {
            return bind(assignRoom(booking, values["roomType"]), func(room string) mo.Result[[]string] {
                return mo.Ok([]string{booking, room})
            })
        })
    })
}

इस दृष्टिकोण को जल्दी ही पढ़ना और बनाए रखना कठिन हो जाता है।

2. .Get() का उपयोग करना:
एक अन्य विकल्प मोनाड को खोलने और अंतर्निहित मूल्य और त्रुटि प्राप्त करने के लिए मोनाड पर .Get() का उपयोग करना है। यह विशिष्ट गो कोड जैसा दिखता है, लेकिन त्रुटि प्रबंधन क्रियात्मक हो सकता है:

func bookRoom(params map[string]string) mo.Result[[]string] {
    values, err := validateBooking(params).Get()
    if err != nil {
        return mo.Err[[]string](err)
    }

    booking, err := createBooking(values["guest"]).Get()
    if err != nil {
        return mo.Err[[]string](err)
    }

    room, err := assignRoom(booking, values["roomType"]).Get()
    if err != nil {
        return mo.Err[[]string](err)
    }

    return mo.Ok([]string{booking, room})
}

यह दृष्टिकोण बाइंड का उपयोग करने से अधिक पठनीय है, लेकिन इसमें अभी भी बहुत सारी बॉयलरप्लेट त्रुटि प्रबंधन शामिल है।

डू-नोटेशन के साथ

नोटेशन के साथ, आप बिना किसी त्रुटि के सीधे अंतर्निहित मूल्य प्राप्त करने के लिए मोनैड पर .MustGet() को कॉल कर सकते हैं। यदि सन्यासी में कोई त्रुटि है तो यह फ़ंक्शन (MustGet()) घबरा जाएगा; हालाँकि, नोटेशन उसे संभाल लेगा और यदि कोई त्रुटि है तो निष्पादन को शॉर्ट सर्किट कर देगा या अलिखित मान को वापस लौटा देगा:

func bookRoom(params map[string]string) mo.Result[[]string] {
    return mo.Do(func() []string {
        values := validateBooking(params).MustGet()
        booking := createBooking(values["guest"]).MustGet()
        room := assignRoom(booking, values["roomType"]).MustGet()
        return []string{booking, room}
    })
}

यह दृष्टिकोण साफ, संक्षिप्त और पढ़ने में आसान है, जो बॉयलरप्लेट त्रुटि प्रबंधन कोड को काफी कम करता है।

अंतिम विचार

डू नोटेशन का उपयोग करने का एक बड़ा लाभ यह है कि आपको प्रत्येक मोनैडिक ऑपरेशन के बाद त्रुटियों की जांच नहीं करनी पड़ती है। भले ही एक मोनैड में त्रुटि प्रकार हो सकता है, लेकिन यदि कोई त्रुटि होती है तो डू नोटेशन स्वचालित रूप से त्रुटि प्रसार को संभाल लेगा और निष्पादन को शॉर्ट-सर्किट कर देगा। इससे स्वच्छ और अधिक रखरखाव योग्य कोड प्राप्त होता है, जो जटिल वर्कफ़्लो में विशेष रूप से मूल्यवान है।