Challenge 1: Writing smallest — Possible Solution
====================================================================

fn smallest<T: PartialOrd + Copy>(list: &[T]) -> T {
    let mut smallest = list[0];
    for &item in list {
        if item < smallest {
            smallest = item;
        }
    }
    smallest
}

fn main() {
    let numbers = [34, 12, 89, 3, 56];
    println!("Smallest number: {}", smallest(&numbers));

    let letters = ['m', 'a', 'z', 'b'];
    println!("Smallest letter: {}", smallest(&letters));
}

WHY THIS WORKS AS AN ANSWER
------------------------------
smallest mirrors this chapter's largest almost exactly, with only the
comparison operator flipped (< instead of >) — the same two trait
bounds are needed for the same reasons: PartialOrd because < has to be
defined for T, and Copy because list[0] and item are copied out of the
slice rather than moved (moving out of a shared reference/slice isn't
allowed at all, per Course 1 Chapter 3's move semantics).

Calling smallest(&numbers) with an array of i32 and smallest(&letters)
with an array of char both compile and run using the SAME generic
function definition — no separate smallest_i32/smallest_char needed.
Per this chapter's monomorphization explanation, the compiler
generates two distinct, fully specialized versions of this function
behind the scenes (one for i32, one for char), even though only one
was written — both calls have zero runtime dispatch overhead despite
using literally the same source code.