什麼是 Do 表示法？

Do 表示法是一種語法糖，主要用於 Haskell 和 Scala 等函數式程式語言。它簡化了單子操作的鏈接，使程式碼更具可讀性和可維護性。透過將此功能引入 Go，我們現在可以在使用 monad 時編寫更清晰、更具表現力的程式碼。

為什麼要做記號？

在處理 monad 時，尤其是在複雜的業務邏輯中，連結操作可能會變得很麻煩。錯誤處理和管理不同的狀態通常會導致難以理解的深層嵌套結構。 Do 表示法透過允許我們以順序風格編寫一元操作來解決這個問題，類似於命令式編程，但具有函數式編程的所有優點。

它在 Mo 包中如何運作？

在 Go 中，實作 do 表示法並不簡單，但我設法使用 Do 函數來實現它。以下是如何使用它的範例：

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

在此範例中，bookRoom 使用 Do 函數順序執行多個操作：驗證預訂參數、建立預訂和分配房間。每個步驟都會傳回一個結果，可以使用 Do 函數無縫連結該結果，確保乾淨且可讀的錯誤處理。

書房功能比較

沒有 Do 符號

您可以有兩個選擇：

1。使用綁定（如果實現）：
當存在許多單子操作時，由於這些操作的巢狀和順序性質，單子中的「綁定」操作可能類似於回調地獄。當許多此類操作連結在一起時，程式碼可能會變得深度嵌套且難以閱讀，類似於非同步程式設計中回調的深度嵌套。如果綁定是在 Mo 套件中實現的，則在本例中使用它看起來像這樣：

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():
另一個選擇是在 monad 上使用 .Get() 來開啟 monad 並取得底層值和錯誤。這看起來像是典型的 Go 程式碼，但錯誤處理可能很冗長：

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

這種方法比使用綁定更具可讀性，但仍涉及大量樣板錯誤處理。

帶有 Do 符號

使用 do 表示法，您可以在 monad 上呼叫 .MustGet() 來直接取得底層值，不會出現錯誤。如果 monad 出現錯誤，則函數（MustGet()）將會出現錯誤；但是，如果發生錯誤， do 表示法將處理該問題並短路執行或傳回未包裝的值：

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

這種方法乾淨、簡潔且易於閱讀，顯著減少了樣板錯誤處理程式碼。

最後的想法

使用 do 表示法的一大優點是您不必在每次單子操作後檢查錯誤。即使 monad 可以有錯誤類型，如果發生錯誤，do 表示法將自動處理錯誤傳播並短路執行。這會帶來更乾淨、更易於維護的程式碼，這在複雜的工作流程中特別有價值。