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 terkait dengan struct tertentu, tetapi tetap fleksibel.

Sintaksnya mirip dengan yang pernah kamu lihat pada struct. Deklarasikan parameter generik di dalam tanda kurung sudut setelah nama fungsi, lalu gunakan parameter itu pada parameter 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 pengembalian. 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, 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 memungkinkan kamu menulis logika yang dapat digunakan kembali satu kali dan menerapkannya pada banyak tipe, sehingga mengurangi duplikasi kode sambil 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). Ini mengharuskan tipenya memiliki Clone, jadi gunakan <T: Clone>
- swap<T, U>: menerima dua nilai yang tipenya bisa berbeda dan mengembalikannya dalam urutan terbalik sebagai tuple (U, T)
main.rs: Impor module utilitasmu dan tunjukkan fungsi generik ini bekerja dengan tipe yang berbeda. Tunjukkan bagaimana definisi fungsi yang sama dapat menangani integer, float, dan string dengan mudah.

Dalam file utama, tunjukkan fungsi utilitasmu dengan cara:

Menggunakan wrap_in_pair dengan integer (input pertama, diurai sebagai i32) dan mencetak kedua elemen
Menggunakan wrap_in_pair dengan string (input kedua) dan mencetak kedua elemen
Menggunakan swap dengan integer (input ketiga, diurai sebagai i32) dan string (input keempat), lalu mencetak hasil yang ditukar

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 bahwa wrap_in_pair bekerja dengan cara yang sama untuk integer maupun string, dan swap menangani dua tipe yang sepenuhnya berbeda. Inilah fleksibilitas fungsi generik!

Kamu akan menerima empat input: sebuah integer, sebuah string, integer 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})
}