Parametreli Traitler

Coddy'nin Rust Journey'sinin Object Oriented Programming bölümünün bir parçası — ders 33 / 61.

Şu ana kadar trait metotlarımız parametre olarak sadece &self aldı. Ancak trait metotları, tıpkı normal metotlar gibi ek parametreler de kabul edebilir; bu da onları gerçek dünya operasyonları için çok daha kullanışlı hale getirir.

Bir trait tanımlarken, metot imzalarına ihtiyacınız olan herhangi bir parametreyi dahil edebilirsiniz:

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

Bu Calculator trait'i, &self'e ek olarak her biri iki tam sayı kabul eden iki metot gerektirir. Bu trait'i uygulayan herhangi bir tür, her iki işlemi de tam olarak bu imzalarla sağlamalıdır.

Bir struct bunu şu şekilde uygulayabilir:

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
    }
}

Artık bu metotları argümanlarla kullanabilirsiniz:

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

Trait, her bir metodun hangi parametreleri kabul ettiğini tanımlarken, uygulama (implementation) bu parametrelerin nasıl kullanıldığını tanımlar. Bu, farklı türlerin aynı işlemleri kendi yöntemleriyle gerçekleştirmesine olanak tanır; örneğin bir LoggingCalc, sonucu döndürmeden önce her işlemi yazdırabilir.

Görev

Kolay

Farklı işlemcilerin metni kendi yöntemleriyle dönüştürebildiği bir dize işleme araç kiti oluşturalım! Parametreleri kabul eden yöntemlere sahip bir TextProcessor trait'i oluşturacak ve ardından bunu iki farklı işlemci türü için uygulayacaksınız.

Kodunuzu üç dosya halinde düzenleyeceksiniz:

processor.rs: Parametreleri kabul eden iki yönteme sahip genel bir TextProcessor trait'i tanımlayın:
- repeat(&self, text: &str, times: u32) -> String — verilen metni belirtilen sayıda tekrarlar
- truncate(&self, text: &str, max_len: usize) -> String — metni belirtilen maksimum uzunluğa kısaltır
processors.rs: Trait'inizi uygulayan iki genel struct oluşturun:
- SimpleProcessor — her tekrar arasında boşluk bırakarak metni tekrarlayan (örneğin, 3 kez tekrarlanan "Hi", "Hi Hi Hi" olur) ve sadece maksimum uzunlukta keserek kısaltan bir unit struct
- FancyProcessor — tekrarlar arasına " * " koyarak metni tekrarlayan (örneğin, 3 kez tekrarlanan "Hi", "Hi * Hi * Hi" olur) ve metin kısaltılmışsa (yalnızca orijinal metin max_len'den uzunsa) sonuna "..." ekleyerek kısaltan bir unit struct
main.rs: Modüllerinizi bir araya getirin ve hangi işlemciyi kullandığınıza bağlı olarak aynı trait yöntemlerinin nasıl farklı sonuçlar ürettiğini gösterin.

Ana dosyanızda her iki işlemciyi de oluşturun ve bunları test etmek için girdileri kullanın. Üç girdi alacaksınız: bir metin dizesi, bir tekrar sayısı ve bir maksimum uzunluk.

Her işlemcinin davranışını gösteren dört satır yazdırın:

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

Örneğin, Hello, 3 ve 4 girdileriyle:

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

Her iki işlemcinin de aynı TextProcessor sözleşmesini nasıl yerine getirdiğine, ancak her birinin metni kendine özgü bir şekilde nasıl dönüştürdüğüne dikkat edin. Trait, yöntemlerin hangi parametreleri kabul edeceğini tanımlarken, her uygulama bunları nasıl kullanacağına karar verir!

Üç girdi alacaksınız: işlenecek metin, tekrar sayısı (u32 olarak ayrıştırın) ve kısaltma için maksimum uzunluk (usize olarak ayrıştırın).

Kopya kağıdı

Trait metotları &self dışında ek parametreler kabul edebilir:

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

Parametreli bir trait'in uygulanması:

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
    }
}

Argümanlarla trait metotlarının kullanımı:

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

Trait, her metodun hangi parametreleri kabul edeceğini tanımlarken, uygulama (implementation) bu parametrelerin nasıl kullanılacağını tanımlar.

Kendin dene

mod processor;
mod processors;

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

fn main() {
    // Girdileri oku
    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");
    
    // İşleyicileri oluştur
    let simple = SimpleProcessor;
    let fancy = FancyProcessor;
    
    // TODO: Metni dönüştürmek ve sonuçları yazdırmak için işleyicileri kullanın
    // Dört satır yazdır:
    // Simple repeat: {result}
    // Simple truncate: {result}
    // Fancy repeat: {result}
    // Fancy truncate: {result}
}