Mengapa Saya Tidak Boleh Menetapkan Jenis Generik Go dengan Argumen Berbeza?

Menetapkan Jenis Generik dengan Argumen Berbeza

Dalam Go, antara muka dan pelaksanaan generik tidak membenarkan penugasan langsung merentas jenis argumen yang berbeza.

Mari kita pertimbangkan contoh ringkas:

// Abstract
type Generic interface {
    ID() string
}

type Props[G Generic] struct{}

// Example
type Example struct {
    id string
}

func (example Example) ID() string {
    return example.id
}

var ExampleProps = Props[Example]{}

// Problem
func Problem() Props[Generic] {
    return ExampleProps
}

Kod ini menimbulkan ralat kompilasi menyatakan bahawa Props[Contoh] tidak boleh diberikan kepada Props[Generik] dalam penyata pulangan. Ini kerana apabila membuat instantiat jenis generik dengan argumen jenis yang berbeza, Go mencipta jenis nama yang berbeza.

Pertimbangkan fungsi berikut:

func Problem() Props[Generic] {
    return ExampleProps
}

Ia menjadikan Props dengan Generik sebagai argumen jenis. Akibatnya, Props[Contoh] dan Props[Generik] menjadi dua jenis yang berbeza, walaupun Contoh melaksanakan Generik. Oleh itu, memberikan Props[Contoh] kepada Props[Generic] adalah tidak sah, tanpa mengira jenis parameternya.

Untuk menyelesaikan isu ini, satu pilihan ialah untuk menjadikan Props dengan parameter jenis yang memenuhi kekangan Generik:

// adding a field to make this a bit less contrived
type Props[G Generic] struct{ Value G }

// Props instantiated with T, adequately constrained
func Problem[T Generic](v T) Props[T] {
    return Props[T]{ Value: v }
}

func main() {
    a := Problem(Example{})
    fmt.Println(a)
}

Dalam contoh ini, Props diwujudkan dengan parameter jenis T yang mematuhi antara muka Generik. Ini membolehkan nilai jenis Props[Contoh] diberikan kepada Props[Generik] dan memastikan keselamatan jenis.

Atas ialah kandungan terperinci Mengapa Saya Tidak Boleh Menetapkan Jenis Generik Go dengan Argumen Berbeza?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!