Fungsi Generik

Termasuk bagian Pemrograman Berorientasi Objek dalam perjalanan Rust di Coddy. Pelajaran 27 dari 61.

Generics tidak terbatas pada struct. Kamu juga bisa menulis fungsi mandiri yang bekerja dengan tipe apa pun. Ini berguna saat kamu membutuhkan fungsi utilitas yang tidak termasuk dalam struct tertentu, tetapi tetap harus fleksibel.

Sintaksnya mirip dengan yang sudah kamu lihat pada struct. Deklarasikan parameter generik di dalam tanda kurung sudut setelah nama fungsi, lalu gunakan parameter itu pada parameter fungsi dan tipe kembalian:

fn identity<T>(value: T) -> T {
    value
}

Fungsi identity ini menerima nilai dengan tipe apa pun dan mengembalikannya tanpa perubahan. <T> mendeklarasikan tipe generik, value: T menerimanya sebagai parameter, dan -> T menentukan tipe nilai yang dikembalikan. Saat kamu memanggil fungsi ini, Rust menyimpulkan tipe konkretnya:

let num = identity(42);        // T adalah i32
let text = identity("hello");  // T adalah &str

Kamu juga bisa menggunakan beberapa parameter generik dalam fungsi, sama seperti pada struct:

fn make_pair<T, U>(first: T, second: U) -> (T, U) {
    (first, second)
}

let pair = make_pair(10, "ten");  // mengembalikan (i32, &str)

Fungsi generik memungkinkanmu menulis logika yang dapat digunakan kembali satu kali dan menerapkannya pada banyak tipe, sehingga mengurangi duplikasi kode sekaligus menjaga keamanan tipe.

Tantangan

Mudah

Mari buat module utilitas dengan fungsi generik yang dapat bekerja dengan tipe apa pun! Kamu akan membuat fungsi mandiri yang menunjukkan bagaimana generik membuat kodemu fleksibel dan dapat digunakan kembali tanpa terikat pada struct tertentu.

Kamu akan mengatur kodemu dalam dua file:

utils.rs: Buat kumpulan fungsi utilitas generik publik:
- wrap_in_pair<T>: menerima satu nilai dan mengembalikan tuple yang berisi nilai tersebut dua kali: (value, value). Tipe ini harus memenuhi syarat Clone, jadi gunakan <T: Clone>
- swap<T, U>: menerima dua nilai yang mungkin berbeda tipe dan mengembalikannya dalam urutan terbalik sebagai tuple (U, T)
main.rs: Impor module utilitasmu dan tunjukkan fungsi-fungsi generik ini bekerja dengan berbagai tipe. Tunjukkan bagaimana definisi fungsi yang sama dapat menangani bilangan bulat, bilangan desimal, dan string dengan mudah.

Di file utamamu, tunjukkan fungsi-fungsi utilitasmu dengan cara:

Menggunakan wrap_in_pair dengan bilangan bulat (input pertama, diuraikan sebagai i32) dan mencetak kedua elemennya
Menggunakan wrap_in_pair dengan string (input kedua) dan mencetak kedua elemennya
Menggunakan swap dengan bilangan bulat (input ketiga, diuraikan sebagai i32) dan string (input keempat), lalu mencetak hasil pertukarannya

Output-mu harus mengikuti format ini:

Pair of ints: ({value}, {value})
Pair of strings: ({value}, {value})
Swapped: ({string}, {int})

Contohnya, dengan input 5, hello, 42, dan world:

Pair of ints: (5, 5)
Pair of strings: (hello, hello)
Swapped: (world, 42)

Perhatikan bagaimana wrap_in_pair bekerja dengan cara yang sama untuk bilangan bulat dan string, dan swap menangani dua tipe yang sepenuhnya berbeda: itulah fleksibilitas fungsi generik!

Kamu akan menerima empat input: bilangan bulat, string, bilangan bulat lain, dan string lain.

Coba sendiri

mod utils;

use std::io;

fn main() {
    // Baca keempat input
    let mut input1 = String::new();
    io::stdin().read_line(&mut input1).expect("Failed to read line");
    let num1: i32 = input1.trim().parse().expect("Invalid integer");

    let mut input2 = String::new();
    io::stdin().read_line(&mut input2).expect("Failed to read line");
    let str1 = input2.trim().to_string();

    let mut input3 = String::new();
    io::stdin().read_line(&mut input3).expect("Failed to read line");
    let num2: i32 = input3.trim().parse().expect("Invalid integer");

    let mut input4 = String::new();
    io::stdin().read_line(&mut input4).expect("Failed to read line");
    let str2 = input4.trim().to_string();

    // TODO: Gunakan wrap_in_pair dengan num1, lalu cetak hasilnya
    // Format: Pair of ints: ({value}, {value})

    // TODO: Gunakan wrap_in_pair dengan str1, lalu cetak hasilnya
    // Format: Pair of strings: ({value}, {value})

    // TODO: Gunakan swap dengan num2 dan str2, lalu cetak hasil setelah ditukar
    // Format: Swapped: ({string}, {int})
}