Memperkenalkan Notasi Do dalam Pakej Mo untuk Golang

Apakah Notasi Do?

Notasi Do ialah gula sintaksis yang digunakan terutamanya dalam bahasa pengaturcaraan berfungsi seperti Haskell dan Scala. Ia memudahkan rantaian operasi monadik, menjadikan kod lebih mudah dibaca dan diselenggara. Dengan membawa ciri ini ke Go, kami kini boleh menulis kod yang lebih bersih dan lebih ekspresif apabila bekerja dengan monad.

Mengapa Buat Notasi?

Apabila berurusan dengan monad, terutamanya dalam logik perniagaan yang kompleks, operasi rantaian boleh menjadi menyusahkan. Ralat mengendalikan dan mengurus keadaan yang berbeza selalunya membawa kepada struktur bersarang dalam yang sukar untuk diikuti. Lakukan tatatanda menangani perkara ini dengan membenarkan kami menulis operasi monadik dalam gaya berurutan, serupa dengan pengaturcaraan imperatif, tetapi dengan semua faedah pengaturcaraan berfungsi.

Bagaimana Ia Berfungsi dalam Pakej Mo?

Dalam Go, melaksanakan tatatanda do tidaklah mudah, tetapi saya berjaya mencapainya menggunakan fungsi Do. Berikut ialah pandangan ringkas tentang cara anda boleh menggunakannya dengan contoh:

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

Dalam contoh ini, bookRoom menggunakan fungsi Do untuk melaksanakan beberapa operasi secara berurutan: mengesahkan parameter tempahan, membuat tempahan dan menetapkan bilik. Setiap langkah mengembalikan Hasil yang boleh dirantai dengan lancar menggunakan fungsi Do, memastikan pengendalian ralat yang bersih dan boleh dibaca.

Perbandingan Fungsi Bilik buku

Tanpa Notasi Do

Anda boleh mempunyai dua pilihan:

1. Menggunakan bind (jika dilaksanakan):
Operasi "mengikat" dalam monad boleh menyerupai neraka panggil balik apabila terdapat banyak operasi monad kerana sifat operasi ini bersarang dan berurutan. Apabila banyak operasi sedemikian dirantai bersama, kod itu boleh menjadi sangat bersarang dan lebih sukar untuk dibaca, sama seperti bagaimana panggilan balik bersarang dalam boleh berada dalam pengaturcaraan tak segerak. Jika bind dilaksanakan dalam pakej Mo, menggunakannya dalam contoh ini akan kelihatan seperti ini:

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

Pendekatan ini menjadi sukar dibaca dan dikekalkan dengan cepat.

2. Menggunakan .Get():
Pilihan lain ialah menggunakan .Get() pada monad untuk membuka bungkus monad dan mendapatkan nilai dan ralat asas. Ini kelihatan seperti kod Go yang biasa, tetapi pengendalian ralat boleh dilakukan secara bertele-tele:

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

Pendekatan ini lebih mudah dibaca daripada menggunakan bind, tetapi masih melibatkan banyak pengendalian ralat boilerplate.

Dengan Do-Notation

Dengan notasi do, anda boleh memanggil .MustGet() pada monad untuk mendapatkan nilai asas secara langsung tanpa ralat. Fungsi ini (MustGet()) akan panik jika monad mempunyai ralat; walau bagaimanapun, notasi do akan mengendalikannya dan litar pintas pelaksanaan jika terdapat ralat atau mengembalikan semula nilai yang tidak dibalut:

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

Pendekatan ini bersih, ringkas dan mudah dibaca, dengan ketara mengurangkan kod pengendalian ralat boilerplate.

---

Fikiran Akhir

Salah satu kelebihan hebat menggunakan notasi do ialah anda tidak perlu menyemak ralat selepas setiap operasi monadik. Walaupun monad boleh mempunyai jenis ralat, notasi do akan secara automatik mengendalikan penyebaran ralat dan litar pintas pelaksanaan jika ralat berlaku. Ini membawa kepada kod yang lebih bersih dan lebih boleh diselenggara, yang amat berharga dalam aliran kerja yang kompleks.

Atas ialah kandungan terperinci Memperkenalkan Notasi Do dalam Pakej Mo untuk Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!