Introducing Do Notation in the Mo Package for Golang

What is Do Notation?

Do notation is a syntactic sugar primarily used in functional programming languages like Haskell and Scala. It simplifies the chaining of monadic operations, making the code more readable and maintainable. By bringing this feature to Go, we can now write cleaner, more expressive code when working with monads.

Why Do Notation?

When dealing with monads, especially in complex business logic, chaining operations can become cumbersome. Error handling and managing different states often lead to deeply nested structures that are hard to follow. Do notation addresses this by allowing us to write monadic operations in a sequential style, akin to imperative programming, but with all the benefits of functional programming.

How Does It Work in the Mo Package?

In Go, implementing do notation wasn't straightforward, but I managed to achieve it using the Do function. Here's a quick look at how you can use it with an 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())
    }
}

In this example, bookRoom uses the Do function to sequentially perform several operations: validating booking parameters, creating a booking, and assigning a room. Each step returns a Result which can be seamlessly chained using the Do function, ensuring clean and readable error handling.

Comparison of bookRoom Function

Without Do-Notation

You can have two options:

1. Using bind (if implemented):
The "bind" operation in monads can resemble callback hell when there are many monadic operations because of the nested and sequential nature of these operations. When many such operations are chained together, the code can become deeply nested and harder to read, similar to how deeply nested callbacks can be in asynchronous programming. If bind were implemented in the Mo package, using it in this example would look something like this:

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

This approach quickly becomes hard to read and maintain.

2. Using .Get():
Another option is to use .Get() on the monad to unwrap the monad and get the underlying value and error. This looks like typical Go code, but error handling can be verbose:

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

This approach is more readable than using bind, but still involves a lot of boilerplate error handling.

With Do-Notation

With do notation, you can call .MustGet() on the monad to get the underlying value directly without error. This function (MustGet()) will panic if the monad has an error; however, do notation will handle that and short circuit the execution if there is an error or return the unwrapped value back:

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

This approach is clean, concise, and easy to read, significantly reducing boilerplate error handling code.

Final Thoughts

One of the great advantages of using do notation is that you don't have to check for errors after every monadic operation. Even though a monad can have an error type, do notation will automatically handle error propagation and short-circuit the execution if an error occurs. This leads to cleaner and more maintainable code, which is particularly valuable in complex workflows.