Trait dengan Parameter

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

Sejauh ini, method trait kita hanya menerima &self sebagai parameter. Namun, method trait dapat menerima parameter tambahan, sama seperti method biasa. Hal ini membuatnya jauh lebih berguna untuk operasi di dunia nyata.

Saat mendefinisikan trait, kamu dapat menyertakan parameter apa pun yang kamu perlukan dalam signature method:

trait Calculator {
    fn add(&self, a: i32, b: i32) -> i32;
    fn multiply(&self, a: i32, b: i32) -> i32;
}

trait Calculator ini memerlukan dua method, masing-masing menerima dua bilangan bulat selain &self. Setiap tipe yang mengimplementasikan trait ini harus menyediakan kedua operasi dengan signature yang persis sama.

Berikut cara sebuah struct dapat mengimplementasikannya:

struct BasicCalc;

impl Calculator for BasicCalc {
    fn add(&self, a: i32, b: i32) -> i32 {
        a + b
    }
    
    fn multiply(&self, a: i32, b: i32) -> i32 {
        a * b
    }
}

Sekarang kamu dapat menggunakan method ini dengan argumen:

let calc = BasicCalc;
println!("{}", calc.add(5, 3));       // 8
println!("{}", calc.multiply(4, 7));  // 28

Trait menentukan parameter apa yang diterima setiap method, sedangkan implementasi menentukan bagaimana parameter tersebut digunakan. Dengan begitu, berbagai tipe dapat melakukan operasi yang sama dengan caranya sendiri: mungkin LoggingCalc dapat mencetak setiap operasi sebelum mengembalikan hasilnya.

Tantangan

Mudah

Mari buat toolkit manipulasi string yang memungkinkan berbagai processor mengubah teks dengan caranya masing-masing! Kamu akan membuat trait TextProcessor dengan method yang menerima parameter, lalu mengimplementasikannya untuk dua tipe processor yang berbeda.

Kamu akan mengatur kodemu dalam tiga file:

processor.rs: Definisikan trait publik TextProcessor dengan dua method yang menerima parameter:
- repeat(&self, text: &str, times: u32) -> String: mengulang teks yang diberikan sebanyak jumlah tertentu
- truncate(&self, text: &str, max_len: usize) -> String: mempersingkat teks hingga panjang maksimum yang ditentukan
processors.rs: Buat dua struct publik yang mengimplementasikan trait-mu:
- SimpleProcessor: struct unit yang mengulang teks dengan spasi di antara setiap pengulangan (misalnya, "Hi" yang diulang 3 kali menjadi "Hi Hi Hi") dan memotong teks tepat pada panjang maksimum
- FancyProcessor: struct unit yang mengulang teks dengan " * " di antara pengulangan (misalnya, "Hi" yang diulang 3 kali menjadi "Hi * Hi * Hi") dan menambahkan "..." saat teks dipersingkat (hanya jika teks aslinya lebih panjang daripada max_len)
main.rs: Satukan module-mu dan tunjukkan bagaimana method trait yang sama menghasilkan keluaran berbeda, bergantung pada processor yang kamu gunakan.

Di file utama, buat kedua processor dan gunakan input untuk mengujinya. Kamu akan menerima tiga input: string teks, jumlah pengulangan, dan panjang maksimum.

Cetak empat baris yang menunjukkan perilaku setiap processor:

Simple repeat: {result}
Simple truncate: {result}
Fancy repeat: {result}
Fancy truncate: {result}

Sebagai contoh, dengan input Hello, 3, dan 4:

Simple repeat: Hello Hello Hello
Simple truncate: Hell
Fancy repeat: Hello * Hello * Hello
Fancy truncate: Hell...

Perhatikan bagaimana kedua processor memenuhi kontrak TextProcessor yang sama, tetapi masing-masing mengubah teks dengan caranya sendiri. Trait menentukan parameter apa yang diterima method, sedangkan setiap implementasi menentukan cara menggunakannya!

Kamu akan menerima tiga input: teks yang akan diproses, jumlah pengulangan (parse sebagai u32), dan panjang maksimum untuk pemotongan (parse sebagai usize).

Coba sendiri

mod processor;
mod processors;

use processor::TextProcessor;
use processors::{SimpleProcessor, FancyProcessor};

fn main() {
    // Baca input
    let mut text = String::new();
    std::io::stdin().read_line(&mut text).expect("Failed to read line");
    let text = text.trim();
    
    let mut times_input = String::new();
    std::io::stdin().read_line(&mut times_input).expect("Failed to read line");
    let times: u32 = times_input.trim().parse().expect("Failed to parse times");
    
    let mut max_len_input = String::new();
    std::io::stdin().read_line(&mut max_len_input).expect("Failed to read line");
    let max_len: usize = max_len_input.trim().parse().expect("Failed to parse max_len");
    
    // Buat pemroses
    let simple = SimpleProcessor;
    let fancy = FancyProcessor;
    
    // TODO: Gunakan pemroses untuk mengubah teks dan mencetak hasilnya
    // Cetak empat baris:
    // Simple repeat: {result}
    // Simple truncate: {result}
    // Fancy repeat: {result}
    // Fancy truncate: {result}
}