Bagaimanakah Kita Boleh Melaksanakan Sama ada Jenis Generik dalam Go untuk Mengendalikan Sama ada/Atau Nilai Pulangan?

Melaksanakan Sama ada Jenis Generik dalam Go

Pengenalan

Dengan kemunculan generik dalam Go 1.18, pembangun telah memikirkan kemungkinan mencipta generik Sama ada jenis [A, B]. Jenis ini akan menyatakan bahawa nilai boleh sama ada daripada jenis A atau B. Situasi di mana jenis sedemikian berguna termasuk fungsi yang mengembalikan satu daripada dua nilai yang mungkin (cth., hasil normal atau ralat).

Walaupun pendekatan idiomatik dalam Go untuk pengendalian ralat adalah untuk mengembalikan kedua-dua nilai "normal" dan nilai ralat, sesetengah berpendapat bahawa ini secara semantik tidak betul kerana ia membayangkan bahawa fungsi mengembalikan kedua-dua A dan B apabila niat adalah untuk mengembalikan sama ada A atau B.

Cabaran

Mencipta Mana-mana jenis dalam Go memberikan cabaran kerana antara mukanya mesti termasuk kaedah yang menerima dua fungsi sebagai hujah, satu untuk jenis A dan satu untuk jenis B. Walau bagaimanapun, Go tidak membenarkan kaedah antara muka mempunyai parameter jenis.

Penyelesaian yang Diilhamkan oleh Fungsian Pengaturcaraan

Untuk memintas sekatan ini, satu pendekatan ialah meminjam penyelesaian daripada bahasa pengaturcaraan berfungsi seperti OCaml. Dalam penyelesaian ini, kami mentakrifkan jenis Pilihan yang boleh mewakili sama ada nilai atau tiada (iaitu, Tiada). Kami kemudiannya mentakrifkan Sama ada jenis yang membalut dua jenis Pilihan, satu untuk jenis A dan satu untuk jenis B.

type Optional[T any] interface {
    get() (T, error)
}

type Either[A, B any] interface {
    is_left() bool
    is_right() bool
    find_left() Optional[A]
    find_right() Optional[B]
}

type Left[A, B any] struct {
    data A
}

type Right[A, B any] struct {
    data B
}

Antara muka Sama ada mentakrifkan kaedah untuk menentukan sama ada nilai itu Kiri (jenis A) atau a Kanan (jenis B) dan dapatkan semula jenis Pilihan yang dibalut. Struktur Kiri dan Kanan melaksanakan kaedah ini untuk mewakili kes yang berbeza.

Contoh

Berikut ialah contoh cara menggunakan Mana-mana jenis:

import (
    "fmt"
    "os"
)

func main() {
    var e1 Either[int, string] = left[int, string](4143)
    var e2 Either[int, string] = right[int, string]("G4143")
    fmt.Println(e1)
    fmt.Println(e2)
    if e1.is_left() {
        if l, err := e1.find_left().get(); err == nil {
            fmt.Printf("The int is: %d\n", l)
        } else {
            fmt.Fprintln(os.Stderr, err)
        }
    }
    if e2.is_right() {
        if r, err := e2.find_right().get(); err == nil {
            fmt.Printf("The string is: %s\n", r)
        } else {
            fmt.Fprintln(os.Stderr, err)
        }
    }
}

Dalam contoh ini, kita mencipta dua nilai Sama ada: e1 iaitu Kiri yang mengandungi integer dan e2 iaitu Kanan yang mengandungi rentetan. Kami menunjukkan cara untuk memadankan corak pada nilai Sama ada menggunakan kaedah is_left() dan is_right() untuk mengakses nilai asas dan mengendalikannya dengan sewajarnya.

Atas ialah kandungan terperinci Bagaimanakah Kita Boleh Melaksanakan Sama ada Jenis Generik dalam Go untuk Mengendalikan Sama ada/Atau Nilai Pulangan?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!