Rust: الأنواع العامة في لغة Rust: البرمجة المعلمة بالأنواع

fn max_i32(a: i32, b: i32) -> i32 {
    if a > b { a } else { b }
}

fn max_f64(a: f64, b: f64) -> f64 {
    if a > b { a } else { b }
}

fn max_str(a: &str, b: &str) -> &str {
    if a > b { a } else { b }
}

fn main() {
    println!("{}", max_i32(3, 7));     // 7
    println!("{}", max_f64(2.5, 1.8)); // 2.5
    println!("{}", max_str("apple", "banana")); // banana
}

fn max<T: std::cmp::PartialOrd>(a: T, b: T) -> T {
    if a > b { a } else { b }
}

fn main() {
    println!("{}", max(3, 7));              // 7
    println!("{}", max(2.5, 1.8));          // 2.5
    println!("{}", max("apple", "banana")); // banana
}

// ============================================
// Generic Functions：Applies to any comparable type
// ============================================

// PartialOrd Constraint Assurance T Supports comparison operations
fn find_max<T: std::cmp::PartialOrd>(list: &[T]) -> &T {
    let mut max = &list[0];
    for item in list.iter() {
        if item > max {
            max = item;
        }
    }
    max
}

fn main() {
    let numbers = vec![3, 7, 1, 9, 4];
    println!("i32 Maximum value: {}", find_max(&numbers));

    let floats = vec![2.5, 1.8, 3.14, 0.99];
    println!("f64 Maximum value: {}", find_max(&floats));

    let strings = vec!["apple", "banana", "cherry", "date"];
    println!("&str Maximum value: {}", find_max(&strings));

    // The Same Function，Three Types，Compiler Auto-Expansion
}

i32 Maximum value: 9
f64 Maximum value: 3.14
&str Maximum value: date

// ============================================
// Generic Structures：Point Can store coordinates of any type
// ============================================

#[derive(Debug)]
struct Point<T> {
    x: T,
    y: T,
}

// Implementation Methods for Generic Structures
impl<T> Point<T> {
    // Back x Citation
    fn x(&self) -> &T {
        &self.x
    }

    // Back y Citation
    fn y(&self) -> &T {
        &self.y
    }
}

// For Point of a specific type f64, implement additional methods
impl Point<f64> {
    fn distance_from_origin(&self) -> f64 {
        (self.x.powi(2) + self.y.powi(2)).sqrt()
    }
}

fn main() {
    let int_point = Point { x: 5, y: 10 };
    let float_point = Point { x: 3.0, y: 4.0 };
    let string_point = Point {
        x: "left",
        y: "right",
    };

    println!("int_point: {:?}", int_point);
    println!("float_point x: {}", float_point.x());
    println!("string_point: {:?}", string_point);

    // Only `Point<f64>` has the distance_from_origin method
    println!("Distance from the origin: {:.2}", float_point.distance_from_origin());

    // Compilation Error: int_point is Point<i32>, no such method
    // println!("{}", int_point.distance_from_origin());
}

int_point: Point { x: 5, y: 10 }
float_point x: 3.0
string_point: Point { x: "left", y: "right" }
Distance from the origin: 5.00

// ============================================
// Generic Enumerations: Option<T> and Result<T, E> Usage
// ============================================

// Custom Result Style Enumeration
#[derive(Debug)]
enum MyResult<T, E> {
    Success(T),
    Failure(E),
}

// Division Function：Back Result Style
fn safe_divide<T>(a: T, b: T) -> MyResult<T, String>
where
    T: std::ops::Div<Output = T> + std::cmp::PartialEq + From<u8> + Copy,
{
    if b == 0.into() {
        MyResult::Failure("Division by zero".to_string())
    } else {
        MyResult::Success(a / b)
    }
}

// Using the standard library Option<T>
fn find_in_vector<T: PartialEq>(vec: &[T], target: &T) -> Option<usize> {
    for (i, item) in vec.iter().enumerate() {
        if item == target {
            return Some(i);
        }
    }
    None
}

// Using the standard library Result<T, E>
fn parse_number(s: &str) -> Result<i32, String> {
    s.parse::<i32>().map_err(|e| format!("Parse error: {}", e))
}

fn main() {
    // Option Usage
    let numbers = vec![10, 20, 30, 40, 50];
    match find_in_vector(&numbers, &30) {
        Some(index) => println!("Found 30，Index: {}", index),
        None => println!("Not found"),
    }
    match find_in_vector(&numbers, &99) {
        Some(index) => println!("Found 99，Index: {}", index),
        None => println!("Not found 99"),
    }

    // Result Usage
    match parse_number("42") {
        Ok(n) => println!("Parsing Successful: {}", n),
        Err(e) => println!("Parsing Failed: {}", e),
    }
    match parse_number("hello") {
        Ok(n) => println!("Parsing Successful: {}", n),
        Err(e) => println!("Parsing Failed: {}", e),
    }

    // Custom MyResult Usage
    let result = safe_divide(10.0, 3.0);
    println!("Custom Result: {:?}", result);

    let result = safe_divide(10.0, 0.0);
    println!("Custom Result: {:?}", result);
}

Found 30，Index: 2
Not found 99
Parsing Successful: 42
Parsing Failed: Parse error: invalid digit found in string
Custom Result: Success(3.3333333333333335)
Custom Result: Failure("Division by zero")

// ============================================
// Multiple Type Parameters + Combining Generic Methods
// ============================================

use std::fmt::Display;

// Generic struct with two type parameters
#[derive(Debug)]
struct Pair<K, V> {
    key: K,
    value: V,
}

// Implement methods for Pair<K, V>
impl<K, V> Pair<K, V> {
    fn new(key: K, value: V) -> Self {
        Pair { key, value }
    }
}

// Constrained methods: only available when both K and V implement Display
impl<K: Display, V: Display> Pair<K, V> {
    fn print(&self) {
        println!("Key: {}, Value: {}", self.key, self.value);
    }
}

// Generic Methods：Mixing Different Types of Parameters
fn mix_and_match<T, U>(a: T, b: U) -> String
where
    T: Display,
    U: Display,
{
    format!("Mixed: {} and {}", a, b)
}

fn main() {
    // Multiple Type Parameters: String and i32
    let pair1 = Pair::new("Age".to_string(), 25);
    pair1.print();

    // Multiple Type Parameters: &str and f64
    let pair2 = Pair::new("PI", 3.14159);
    pair2.print();

    // Different Types of Combinations
    let pair3 = Pair::new(100, "HTTP OK");
    // pair3.print();  // ❌ Compilation Error: i32 and &str both implement Display, but no error here.
    // In fact i32 and &str both implement Display, so you can call it
    // This is just to demonstrate the concept of constraint methods.
    pair3.print();

    // Mixing Different Types
    println!("{}", mix_and_match(42, "answer"));
    println!("{}", mix_and_match(3.14, 100));
}

Key: Age, Value: 25
Key: PI, Value: 3.14159
Key: 100, Value: HTTP OK
Mixed: 42 and answer
Mixed: 3.14 and 100

// ============================================
// Comprehensive Example：Generic Stack + Generic Search Algorithms
// ============================================

use std::fmt::Display;

struct Stack<T> {
    items: Vec<T>,
}

impl<T> Stack<T> {
    fn new() -> Self {
        Stack { items: Vec::new() }
    }

    fn push(&mut self, item: T) {
        self.items.push(item);
    }

    fn pop(&mut self) -> Option<T> {
        self.items.pop()
    }

    fn peek(&self) -> Option<&T> {
        self.items.last()
    }

    fn is_empty(&self) -> bool {
        self.items.is_empty()
    }

    fn len(&self) -> usize {
        self.items.len()
    }
}

impl<T: Display> Stack<T> {
    fn print_all(&self) {
        for item in &self.items {
            print!("{} ", item);
        }
        println!();
    }
}

fn find_first<T: PartialEq>(items: &[T], target: &T) -> Option<usize> {
    items.iter().position(|x| x == target)
}

fn swap_if_greater<T: PartialOrd>(a: &mut T, b: &mut T) {
    if *a > *b {
        std::mem::swap(a, b);
    }
}

fn main() {
    let mut int_stack: Stack<i32> = Stack::new();
    int_stack.push(10);
    int_stack.push(20);
    int_stack.push(30);
    println!("=== Integer Stack ===");
    println!("Stack Contents: ");
    int_stack.print_all();
    println!("Stack top: {:?}", int_stack.peek());
    println!("Pop up: {:?}", int_stack.pop());
    println!("Remaining {} element", int_stack.len());

    let mut str_stack: Stack<&str> = Stack::new();
    str_stack.push("Rust");
    str_stack.push("is");
    str_stack.push("awesome");
    println!("\n=== String Stack ===");
    str_stack.print_all();

    let nums = vec![10, 20, 30, 40, 50];
    println!("\n=== Generic Search ===");
    println!("Find 30: Index {:?}", find_first(&nums, &30));
    println!("Find 99: Index {:?}", find_first(&nums, &99));

    let words = vec!["apple", "banana", "cherry"];
    println!("Find 'banana': Index {:?}", find_first(&words, &"banana"));

    let mut x = 42;
    let mut y = 10;
    println!("\n=== Generic Swaps ===");
    println!("Before the exchange: x={}, y={}", x, y);
    swap_if_greater(&mut x, &mut y);
    println!("After the exchange: x={}, y={}", x, y);
}

=== Integer Stack ===
Stack Contents: 
10 20 30 
Stack top: Some(30)
Pop up: Some(30)
Remaining 2 element

=== String Stack ===
Rust is awesome 

=== Generic Search ===
Find 30: Index Some(2)
Find 99: Index None
Find 'banana': Index Some(1)

=== Generic Swaps ===
Before the exchange: x=42, y=10
After the exchange: x=10, y=42