Kurangi jejak kode Rust Anda dan tingkatkan ketahanannya dengan tipe generik.

Selalu ada tingkat ketidakpastian saat mengembangkan aplikasi, yang dapat menyebabkan kesalahan, terutama jika fungsi Anda menerima jenis argumen tertentu. Untuk mengurangi error akibat ketidakpastian, Anda bisa menggunakan Generics. Generik menyediakan fungsionalitas untuk membuat kelas, fungsi, dan struktur data untuk bekerja dengan tipe yang berbeda.

Dengan menggunakan obat generik, Anda dapat membuat dan menentukan algoritme dan struktur data yang dapat beroperasi pada berbagai jenis tanpa menulis kode yang rumit dan memisahkan implementasi untuk setiap jenis. Generik meningkatkan penggunaan kembali kode dan efisiensi sambil mempertahankan keamanan dan kinerja jenis.

Menggunakan Jenis Generik di Rust

Jenis generik Rust dapat beroperasi dengan tipe data Rust lainnya. Anda akan menentukan tipe generik dengan kurung siku (<>), diikuti oleh dua atau lebih parameter.

Ini generik definisi struktur yang mengambil dua parameter tipe generik:

instagram viewer
structTitik {
// T dan U adalah parameter tipe generik yang akan diisi oleh kolom x dan y
// asumsikan pada instantiasi
x: T,
y: kamu,
}

Dalam Titik struktur, T, Dan AS adalah parameter tipe generik.

Anda dapat mengganti parameter tipe generik dengan tipe data apa pun pada instantiasi:

fnutama() {
membiarkan my_point = Titik {x: Rangkaian::dari("Halo"), y: Rangkaian::dari("dunia") };

cetak!(
"Nilai x dari my_point adalah {} dan nilai y adalah {}.",
my_point.x,
my_point.y
);
}

Itu my_point variabel adalah turunan dari Titik struct diinisialisasi dengan tipe string. Kompiler Rust menyimpulkan jenis konkret dari T Dan AS berdasarkan nilai-nilai pada instantiation.

Batas Sifat untuk Tipe Generik

Jenis generik karat dapat menggunakan batas sifat untuk memastikan keamanan jenis. Ciri-ciri adalah kumpulan metode yang dapat diterapkan tipe untuk menunjukkan perilaku tertentu yang ditentukan untuk sifat tersebut.

Batasan sifat menentukan bahwa tipe generik harus mengimplementasikan satu atau beberapa sifat.

Berikut adalah contoh fungsi generik yang mengembalikan nilai yang lebih besar dari dua nilai dengan sifat terikat yang memastikan bahwa tipe yang dibandingkan mengimplementasikan sifat tersebut:

// Maksimum adalah sifat yang menentukan metode untuk mengevaluasi maksimum dua
// jenis
sifatMaksimum {
fnmaks(diri sendiri, lainnya: Diri sendiri) -> Diri sendiri;
}

// Mengimplementasikan sifat `Maximum` untuk semua tipe yang mengimplementasikan
// sifat `PartialOrd`.
implPartialOrd> Maksimum untuk T {
fnmaks(diri sendiri, lainnya: Diri sendiri) -> Diri sendiri {
// mengembalikan `self` jika lebih besar dari `other`; jika tidak, kembali
// `lainnya.`
jikadiri sendiri > lainnya {
diri sendiri
} kalau tidak {
lainnya
}
}
}

fnutama() {
membiarkan a = 5;
membiarkan b = 10;
membiarkan terbesar = Maksimum:: maks (a, b);
cetak!("Nilai terbesar adalah {}", terbesar);
}

Itu Maksimum sifat memiliki a maks metode yang mengembalikan yang lebih besar dari dua nilai dari jenis yang sama. Jenis apa pun yang mengimplementasikan PartialOrd sifat mengimplementasikan Maksimum sifat.

Itu maks metode mengambil dua nilai dari Diri sendiri type—mengacu pada tipe yang mengimplementasikan the Maksimum sifat-dan membandingkan nilai-nilai.

Itu utama fungsi membandingkan dua variabel menggunakan maks metode dan mencetak yang terbesar.

Batasan untuk Tipe Generik

Batasan mirip dengan batas sifat, tetapi batasan memungkinkan Anda untuk menentukan persyaratan tambahan pada tipe yang Anda gunakan sebagai parameter tipe.

Jika Anda ingin membuat fungsi generik yang menerima tipe untuk konversi string, Anda bisa menggunakan batasan untuk memastikan bahwa parameter tipe mengimplementasikan suatu sifat.

// ToString adalah sifat dengan metode konversi string
sifatToString {
fnto_string(&diri sendiri) -> Rangkaian;
}

// to_string adalah fungsi generik yang mengambil nilai dari tipe apa pun itu
// mengimplementasikan sifat ToString
fnto_stringToString>(nilai: T) --> Rangkaian {
nilai.to_string()
}

Itu to_string nilai parameter harus menerapkan ToString sifat, yang memastikan bahwa Anda dapat mengonversi nilai tipe T untuk string dengan to_string metode.

Tipe Generik Berguna untuk Bekerja Dengan Sifat

Jenis generik karat sangat kuat, dan ada area untuk perbaikan. Area fokus kritis adalah meningkatkan kinerja kode generik. Saat ini, sistem tipe Rust dapat membebani kode umum, memperlambat kinerja.

Jenis generik bermanfaat untuk bekerja dengan sifat. Dengan menggunakan tipe generik, Anda dapat membuat objek sifat yang bekerja dengan tipe apa pun yang mengimplementasikan suatu sifat untuk membuat metode Anda lebih fleksibel.