Try It Yourself - SyntaxStudy Editor

HTML / CSS / JS

// Generic function — T must implement PartialOrd for comparison
fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut max = &list[0];
    for item in list {
        if item > max {
            max = item;
        }
    }
    max
}

// Generic struct
#[derive(Debug)]
struct Pair<T> {
    first: T,
    second: T,
}

impl<T> Pair<T> {
    fn new(first: T, second: T) -> Self {
        Pair { first, second }
    }
}

// Methods available only when T implements Display + PartialOrd
impl<T: std::fmt::Display + PartialOrd> Pair<T> {
    fn larger(&self) -> &T {
        if self.first >= self.second { &self.first } else { &self.second }
    }
}

// Generic enum — like Option in the standard library
#[derive(Debug)]
enum Maybe<T> {
    Just(T),
    Nothing,
}

impl<T: std::fmt::Display> Maybe<T> {
    fn show(&self) {
        match self {
            Maybe::Just(v) => println!("Just({v})"),
            Maybe::Nothing => println!("Nothing"),
        }
    }
}

fn main() {
    let ints = vec![34, 50, 25, 100, 65];
    println!("largest int = {}", largest(&ints));

let chars = vec!['y', 'm', 'a', 'q'];
    println!("largest char = {}", largest(&chars));

let pair = Pair::new(5, 10);
    println!("larger = {}", pair.larger());

let maybe_str: Maybe<&str> = Maybe::Just("hello");
    maybe_str.show();
    let nothing: Maybe<i32> = Maybe::Nothing;
    nothing.show();
}