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. Her türle çalışan bağımsız işlevler de yazabilirsiniz. Bu, belirli bir yapıya ait olmayan ancak yine de esnek olması gereken bir yardımcı işlevine ihtiyaç duyduğunuzda kullanışlıdır.

Sözdizimi, yapılarla gördüklerinizi yansıtır. Genel parametreyi işlev adından sonra açılı ayraçlar içinde bildirin, 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 değeri alır ve değiştirmeden döndürür. <T> genel türü tanımlar, value: T onu bir parametre olarak kabul eder ve -> T dönüş türünü belirtir. İşlevi çağırdığınızda Rust somut türü çıkarır:

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

Yapılarda olduğu gibi, işlevlerde de birden fazla genel parametre kullanabilirsiniz:

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

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

Jenerik işlevler, yeniden kullanılabilir mantığı bir kez yazıp tür güvenliğini korurken birçok türe uygulamanıza olanak tanır ve kod tekrarını azaltır.

Görev

Kolay

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

Kodunuzu iki dosyaya ayıracaksınız:

utils.rs: Genel amaçlı, herkese açık genel yardımcı işlevlerden oluşan bir koleksiyon oluşturun:
- 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). Bu işlem türün Clone olmasını gerektirir; bu nedenle <T: Clone> kullanın
- swap<T, U>: potansiyel olarak farklı türlerde 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üzü içe aktarın ve bu genel işlevlerin farklı türlerle çalıştığını gösterin. Aynı işlev tanımlarının tamsayıları, kayan noktalı sayıları ve dizeleri sorunsuzca nasıl işlediğini gösterin.

Ana dosyanızda yardımcı işlevlerinizi şu şekilde gösterin:

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

Çıktınız şu biçimi izlemelidir:

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

Örneğin, girdiler 5, hello, 42 ve world olduğunda:

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

wrap_in_pair işlevinin hem tamsayılar hem de dizeler için aynı şekilde çalıştığına ve swap işlevinin birbirinden tamamen farklı iki türü işlediğine dikkat edin: genel işlevlerin esnekliği budur!

Dört girdi alacaksınız: bir tamsayı, bir dize, başka bir tamsayı 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: wrap_in_pair'i num1 ile kullan ve sonucu yazdır
    // Biçim: Pair of ints: ({value}, {value})

    // TODO: wrap_in_pair'i str1 ile kullan ve sonucu yazdır
    // Format: Pair of strings: ({value}, {value})

    // TODO: swap'i num2 ve str2 ile kullan, sonra takas edilmiş sonucu yazdır
    // Biçim: Swapped: ({string}, {int})
}