Rumah > pembangunan bahagian belakang > Golang > Bagaimanakah Saya Boleh Mencapai Kekangan Jenis Rekursif dalam Go Generics?

Bagaimanakah Saya Boleh Mencapai Kekangan Jenis Rekursif dalam Go Generics?

Susan Sarandon
Lepaskan: 2024-12-22 06:57:44
asal
557 orang telah melayarinya

How Can I Achieve Recursive Type Constraints in Go Generics?

Kekangan Jenis Rekursif dengan Jenis Pratakrif

Dalam Go generik, adalah mungkin untuk menentukan kekangan jenis pada jenis generik menggunakan antara muka. Walau bagaimanapun, ia boleh mencabar untuk menentukan kekangan yang memerlukan pelaksanaan kaedah dengan hujah jenis generik itu sendiri.

Penghadan Draf Semasa

Draf generik Go semasa tidak membenarkan kekangan jenis rekursif, menjadikannya mustahil untuk mencapai tingkah laku yang diingini. Sebagai contoh, pertimbangkan antara muka berikut:

type Lesser interface {
    Less(rhs Lesser) bool
}
Salin selepas log masuk

Kami boleh melaksanakan antara muka ini untuk jenis tersuai, seperti Int:

type Int int

func (lhs Int) Less(rhs Int) bool {
    return lhs < rhs
}
Salin selepas log masuk

Walau bagaimanapun, kod berikut akan gagal untuk disusun kerana Int tidak memenuhi antara muka Lesser:

func IsLess[T Lesser](lhs, rhs T) bool {
    return lhs.Less(rhs)
}

func main() {
    IsLess[Int](Int(10), Int(20))
}
Salin selepas log masuk

Penyelesaian Menggunakan Pratakrif Antara muka

Penyelesaian untuk pengehadan ini ialah dengan mentakrifkan antara muka generik yang merujuk dirinya sebagai parameter jenis:

type Lesser[T any] interface {
    Less(T) bool
}
Salin selepas log masuk

Antara muka ini menentukan bahawa mana-mana jenis yang melaksanakan antara muka Lesser mesti mempunyai Kurang kaedah yang mengambil hujah daripada jenis yang sama.

Kita kemudian boleh mentakrifkan fungsi IsLess menggunakan generik ini antara muka:

func IsLess[T Lesser[T]](x, y T) bool {
    return x.Less(y)
}
Salin selepas log masuk

Sekarang, kami boleh melaksanakan jenis tersuai yang memenuhi kekangan Lebih Kecil:

type Apple int

func (a Apple) Less(other Apple) bool {
    return a < other
}

type Orange int

func (o Orange) Less(other Orange) bool {
    return o < other
}
Salin selepas log masuk

Menggunakan fungsi IsLess dengan jenis tersuai ini akan menghasilkan tingkah laku yang betul:

func main() {
    fmt.Println(IsLess(Apple(10), Apple(20)))   // true
    fmt.Println(IsLess(Orange(30), Orange(15))) // false
}
Salin selepas log masuk

Penyelesaian ini berkesan menguatkuasakan kekangan jenis rekursif dengan memerlukan pelaksanaan kaedah dengan hujah generik taip.

Atas ialah kandungan terperinci Bagaimanakah Saya Boleh Mencapai Kekangan Jenis Rekursif dalam Go Generics?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!

sumber:php.cn
Kenyataan Laman Web ini
Kandungan artikel ini disumbangkan secara sukarela oleh netizen, dan hak cipta adalah milik pengarang asal. Laman web ini tidak memikul tanggungjawab undang-undang yang sepadan. Jika anda menemui sebarang kandungan yang disyaki plagiarisme atau pelanggaran, sila hubungi admin@php.cn
Artikel terbaru oleh pengarang
Tutorial Popular
Lagi>
Muat turun terkini
Lagi>
kesan web
Kod sumber laman web
Bahan laman web
Templat hujung hadapan