Do notation

[taman9333]

Description

This PR introduces do-notation to simplify error handling and improve the readability of monadic operations.

Example:

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())
    }
}

Benefits:

• Readability: The code is more concise easier to understand and less verbose.
• Maintainability: Centralized error handling reduces repetitive boilerplate code.
• Consistency: Ensures a consistent error handling mechanism throughout the codebase.

Without the do-notation the code becomes much more verbose and less maintainable due to the explicit error handling after each step. By using do-notation, we centralize the error handling logic, resulting in cleaner and more concise code.

Comparison of createService Function:

without do-notation

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})
}

With do-notation

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

[taman9333]

@samber

[samber]

hi @taman9333

I like the idea.

Can you explain why you named it "Do" instead of "Try" or other? Do does not seem meaningful to me. But I might be wrong.

[taman9333]

@samber I am just following the same naming convention introduced in Haskell Do you prefer a different name?

[taman9333]

~~@samber I've fixed those Testable Examples. Let me know if you have any other comments. You can merge the PR if you don't have any concerns~~ I have reverted fixing Testable Examples as I have found you fixed that

[samber]

Yes, I made a fix, while merging another contrib recently.

Thanks for your work