rust_programming_book 0.1.1

#[allow(dead_code)]
fn find_largest<T>(list: &[T]) -> &T
// this line of code is needed for comparison
//  where T: std::cmp::PartialOrd. It restricts the generic paramter
where
    T: std::cmp::PartialOrd,
{
    let mut largest = &list[0];

    for item in list {
        if item > largest {
            largest = item;
        }
    }
    largest
}

#[allow(dead_code)]
fn add_subtract_values<T>(first_point: T, second_point: T) -> T
where
    T: std::ops::Add<Output = T>,
{
    first_point + second_point
}

#[allow(dead_code)]
struct SurajData<T, U> {
    data_t: T,
    data_u: U,
}
/*
Implementing Debug, in other words restricting T and U to implement Debug trait.
The implementation code for generic parameters should be written in implementation of struct
not in the struct.
*/
#[allow(dead_code)]
impl<T, U> SurajData<T, U>
where
    T: std::fmt::Debug,
    U: std::fmt::Debug,
{
    fn log_data(&self) {
        println!("data_t: {:?}", self.data_t);
        println!("data_u: {:?}", self.data_u);
    }
}

#[allow(dead_code)]
pub fn generics_for_vector() {
    let num_vector = vec![1, 3, 4, 23, 5, 4, 1];
    let char_vector = vec!['a', 'b', 'z', 'k', 'a'];

    println!(
        "largest number in {:#?} is: {}",
        num_vector,
        find_largest(&num_vector)
    );
    println!(
        "largest number in {:#?} is: {}",
        char_vector,
        find_largest(&char_vector)
    );

    add_subtract_values(2, 4);

    // test code for implementing Traits for generic parameters
    let some_suraj_data = SurajData {
        data_t: vec![1, 2, 3, 4, 5, 7, 8],
        data_u: "Hello World!",
    };
    println!("{}", some_suraj_data.data_t.len());
    println!("{}", some_suraj_data.data_u.len());

    some_suraj_data.log_data();
}