Generic Fonksiyonlar

Coddy'nin Rust Journey'sinin Nesne Yönelimli Programlama bölümünün bir parçası. Ders 27 / 61.

Jenerikler yapılarla sınırlı değildir. Herhangi bir türle çalışan bağımsız işlevler de yazabilirsin. Bu, belirli bir yapıya ait olmayan ancak yine de esnek olması gereken bir yardımcı işlev gerektiğinde kullanışlıdır.

Söz dizimi, yapılarla gördüğünüz söz dizimine benzer. Genel parametreyi işlev adından sonra açılı ayraçlar içinde tanımlayın, ardından parametrelerde ve dönüş türünde kullanın:

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

Bu identity işlevi, herhangi bir türdeki bir değeri alır ve değiştirmeden döndürür. <T> genel türü bildirir, value: T bunu parametre olarak kabul eder ve -> T dönüş türünü belirtir. İşlevi çağırdığında Rust somut türü çıkarır:

let num = identity(42);        // T, i32 türündedir
let text = identity("hello");  // T, &str türündedir

Yapılarda olduğu gibi, işlevlerde de birden fazla genel tür parametresi kullanabilirsin:

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

let pair = make_pair(10, "ten");  // (i32, &str) döndürür

Jenerik fonksiyonlar, yeniden kullanılabilir mantığı bir kez yazmanıza ve tür güvenliğini korurken bunu birçok türe uygulamanıza olanak tanıyarak kod tekrarını azaltır.

Görev

Kolay

Herhangi bir türle çalışabilen genel işlevlere sahip bir yardımcı modül oluşturalım! Belirli bir yapıya bağlı kalmadan genellemelerin kodunu nasıl esnek ve yeniden kullanılabilir hâle getirdiğini gösteren bağımsız işlevler oluşturacaksın.

Kodunu iki dosyaya ayıracaksın:

utils.rs: Genel amaçlı herkese açık yardımcı işlevlerden oluşan bir koleksiyon oluştur:
- wrap_in_pair<T>: tek bir değer alır ve bu değeri iki kez içeren bir demet döndürür: (value, value). Bunun için türün Clone olması gerekir; bu nedenle <T: Clone> kullan
- swap<T, U>: türleri farklı olabilecek iki değer alır ve bunları ters sırada bir demet olarak döndürür: (U, T)
main.rs: Yardımcı modülünü içe aktar ve bu genel işlevlerin farklı türlerle çalıştığını göster. Aynı işlev tanımlarının tam sayıları, kayan noktalı sayıları ve dizeleri sorunsuz biçimde nasıl işlediğini göster.

Ana dosyanda, yardımcı işlevlerini şu şekilde göster:

wrap_in_pair işlevini bir tam sayıyla (ilk girdi, i32 olarak ayrıştırılır) kullan ve her iki öğeyi de yazdır
wrap_in_pair işlevini bir dizeyle (ikinci girdi) kullan ve her iki öğeyi de yazdır
swap işlevini bir tam sayı (üçüncü girdi, i32 olarak ayrıştırılır) ve bir dizeyle (dördüncü girdi) kullan, ardından yerleri değiştirilmiş sonucu yazdır

Çıktın şu biçimde olmalıdır:

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

Örneğin, 5, hello, 42 ve world girdileriyle:

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

wrap_in_pair işlevinin hem tam sayılarla hem de dizelerle aynı şekilde çalıştığına ve swap işlevinin birbirinden tamamen farklı iki türü işlediğine dikkat et: genel işlevlerin esnekliği budur!

Dört girdi alacaksın: bir tam sayı, bir dize, başka bir tam sayı ve başka bir dize.

Kendin dene

mod utils;

use std::io;

fn main() {
    // Dört girdiyi oku
    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: num1 ile wrap_in_pair kullan ve sonucu yazdır
    // Biçim: Pair of ints: ({value}, {value})

    // TODO: str1 ile wrap_in_pair kullan ve sonucu yazdır
    // Biçim: Pair of strings: ({value}, {value})

    // TODO: num2 ve str2 ile swap kullan, ardından yerleri değiştirilmiş sonucu yazdır
    // Biçim: Swapped: ({string}, {int})
}