Default Generic Type Parameters

trait Add<Rhs = Self> {
    type Output;
    fn add(self, rhs: Rhs) -> Self::Output;
}

use std::ops::Add;

#[derive(Debug, Clone, Copy, PartialEq)]
struct ComplexNumber {
    real: f64,
    imag: f64,
}

impl Add for ComplexNumber {
    type Output = ComplexNumber; // The result is a new ComplexNumber

    fn add(self, other: ComplexNumber) -> ComplexNumber {
        ComplexNumber {
            real: self.real + other.real, // Sum the real parts
            imag: self.imag + other.imag, // Sum the imaginary parts
        }
    }
}

fn main() {
    let num1 = ComplexNumber { real: 3.0, imag: 4.0 };
    let num2 = ComplexNumber { real: 1.0, imag: 2.0 };

    let result = num1 + num2; // Use the overloaded + operator
    println!("Result: {:?}", result); // Expected output: ComplexNumber { real: 4.0, imag: 6.0 }
}

use std::ops::Add;

struct Inches(u32);
struct Feet(u32);

// Implement Add for Inches, specifying that we're adding Feet to Inches.
impl Add<Feet> for Inches {
    type Output = Inches;

    fn add(self, other: Feet) -> Inches {
        // Convert feet to inches (1 foot = 12 inches) before adding.
        Inches(self.0 + (other.0 * 12))
    }
}

fn main() {
    let length_in_inches = Inches(24); // 24 inches
    let length_in_feet = Feet(2);        // 2 feet

    let result = length_in_inches + length_in_feet; // Expected to add 24 inches and 2 feet
    println!("Result: {} inches", result.0);        // Expected output: 48 inches
}