Was ist Do-Notation?

Do-Notation ist ein syntaktischer Zucker, der hauptsächlich in funktionalen Programmiersprachen wie Haskell und Scala verwendet wird. Es vereinfacht die Verkettung monadischer Operationen und macht den Code lesbarer und wartbarer. Indem wir diese Funktion in Go integrieren, können wir jetzt saubereren, ausdrucksstärkeren Code schreiben, wenn wir mit Monaden arbeiten.

Warum Notation?

Beim Umgang mit Monaden, insbesondere in komplexer Geschäftslogik, kann die Verkettung von Vorgängen umständlich werden. Die Fehlerbehandlung und die Verwaltung unterschiedlicher Zustände führen oft zu tief verschachtelten Strukturen, denen man nur schwer folgen kann. Die Do-Notation behebt dieses Problem, indem sie es uns ermöglicht, monadische Operationen in einem sequentiellen Stil zu schreiben, ähnlich der imperativen Programmierung, aber mit allen Vorteilen der funktionalen Programmierung.

Wie funktioniert es im Mo-Paket?

In Go war die Implementierung der Do-Notation nicht einfach, aber ich habe es mithilfe der Do-Funktion geschafft. Hier ist ein kurzer Blick darauf, wie Sie es anhand eines Beispiels verwenden können:

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 diesem Beispiel verwendet bookRoom die Do-Funktion, um nacheinander mehrere Vorgänge auszuführen: Buchungsparameter validieren, eine Buchung erstellen und einen Raum zuweisen. Jeder Schritt gibt ein Ergebnis zurück, das mithilfe der Do-Funktion nahtlos verkettet werden kann, um eine saubere und lesbare Fehlerbehandlung zu gewährleisten.

Vergleich der bookRoom-Funktion

Ohne Do-Notation

Sie haben zwei Möglichkeiten:

1. Mit bind (falls implementiert):
Die „Bind“-Operation in Monaden kann aufgrund der verschachtelten und sequentiellen Natur dieser Operationen der Callback-Hölle ähneln, wenn es viele monadische Operationen gibt. Wenn viele solcher Vorgänge miteinander verkettet werden, kann der Code tief verschachtelt und schwerer lesbar werden, ähnlich wie Rückrufe in der asynchronen Programmierung tief verschachtelt sein können. Wenn bind im Mo-Paket implementiert wäre, würde die Verwendung in diesem Beispiel etwa so aussehen:

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

Dieser Ansatz wird schnell schwer zu lesen und zu pflegen.

2. Verwenden von .Get():
Eine andere Möglichkeit besteht darin, .Get() für die Monade zu verwenden, um die Monade zu entpacken und den zugrunde liegenden Wert und Fehler abzurufen. Das sieht aus wie typischer Go-Code, aber die Fehlerbehandlung kann ausführlich sein:

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

Dieser Ansatz ist besser lesbar als die Verwendung von bind, erfordert jedoch immer noch eine Menge Standardfehlerbehandlung.

Mit Do-Notation

Mit der Do-Notation können Sie .MustGet() für die Monade aufrufen, um den zugrunde liegenden Wert direkt und ohne Fehler abzurufen. Diese Funktion (MustGet()) gerät in Panik, wenn die Monade einen Fehler hat; Die Do-Notation kümmert sich jedoch darum und unterbricht die Ausführung, wenn ein Fehler auftritt, oder gibt den entpackten Wert zurück:

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

Dieser Ansatz ist sauber, prägnant und leicht zu lesen, wodurch der Standardcode für die Fehlerbehandlung erheblich reduziert wird.

Letzte Gedanken

Einer der großen Vorteile der Verwendung der Do-Notation besteht darin, dass Sie nicht nach jeder monadischen Operation auf Fehler prüfen müssen. Auch wenn eine Monade einen Fehlertyp haben kann, verarbeitet die Do-Notation automatisch die Fehlerausbreitung und unterbricht die Ausführung, wenn ein Fehler auftritt. Dies führt zu saubererem und besser wartbarem Code, was besonders in komplexen Arbeitsabläufen wertvoll ist.