Generics | Faisal Affan

Versi Bahasa Indonesia. Baca dalam Bahasa Inggris

Generics di Rust memungkinkan kamu menulis kode yang fleksibel dan dapat digunakan kembali yang bekerja dengan tipe data yang berbeda sambil memastikan type safety.
Kita menggunakan generics untuk membuat definisi untuk item seperti function signature atau struct, yang kemudian dapat kita gunakan dengan banyak tipe data konkret yang berbeda.
Direpresentasikan dengan angle brackets (<>) dan sering dilambangkan dengan T, U, atau nama deskriptif lainnya.
Rust menghasilkan kode yang dioptimalkan untuk setiap tipe konkret yang digunakan dengan generic pada saat compile, menghindari runtime overhead.
Referensi:
- Generic Data Types
- Bounds

generics1.rs

// `Vec<T>` is generic over the type `T`. In most cases, the compiler is able to
// infer `T`, for example after pushing a value with a concrete type to the vector.
// But in this exercise, the compiler needs some help through a type annotation.

fn main() {
    // Fix the compiler error by annotating the type of the vector
    // `Vec<T>`. Choose `T` as some integer type that can be created from
    // `u8` and `i8`.
    let mut numbers: Vec<i32> = Vec::new();

    // Don't change the lines below.
    let n1: u8 = 42;
    numbers.push(n1.into());
    let n2: i8 = -1;
    numbers.push(n2.into());

    println!("{numbers:?}");
}

Di latihan ini kita hanya perlu mendefinisikan tipe vector.
Kita dapat menggunakan i32 yang memenuhi kedua tipe u8 dan i8 yang di-push di fungsi main.

generics2.rs

// This powerful wrapper provides the ability to store a positive integer value.
// Rewrite it using a generic so that it supports wrapping ANY type.
struct Wrapper<T> {
    value: T,
}

// Adapt the struct's implementation to be generic over the wrapped value.
impl<T> Wrapper<T> {
    fn new(value: T) -> Self {
        Wrapper { value }
    }
}

fn main() {
    // You can optionally experiment here.
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn store_u32_in_wrapper() {
        assert_eq!(Wrapper::new(42).value, 42);
    }

    #[test]
    fn store_str_in_wrapper() {
        assert_eq!(Wrapper::new("Foo").value, "Foo");
    }
}

Di latihan ini kita ditugaskan untuk membangun Wrapper yang menerima generics.
Jadi kita perlu menambahkan <T> di definisi struct dan implementasinya untuk menjadikannya generics.