How to put traits in Rust's function types in an array's type?

I'm trying to create an array of functions that sort numbers, but am having issues with the declaring the array's type. I can't get it to be generic over the input parameter of the functions.

How do I accomplish that the array sorts has functions whose first and only parameter only require implementing the traits Ord and Copy instead of being u32?

// What I have now. Note the fn(&mut [u32])
let sorts: [(&'static str, fn(&mut [u32])); 6] = [
    ("Insertion sort", insertion_sort),
    ("Selection sort", selection_sort),
    ("Bubble sort", bubble_sort),
    ("Merge sort", merge_sort),
    ("Quick sort", quick_sort),
    ("Heap sort", heap_sort),
];

fn insertion_sort(array: &mut [impl Ord + Copy]) { }
fn selection_sort(array: &mut [impl Ord + Copy]) { }
fn bubble_sort(array: &mut [impl Ord + Copy]) { }
fn merge_sort(array: &mut [impl Ord + Copy]) { }
fn quick_sort(array: &mut [impl Ord + Copy]) { }
fn heap_sort(array: &mut [impl Ord + Copy]) { }

// What I want to accomplish. Note the fn(&mut [impl Ord + Copy])
let sorts: [(&'static str, fn(&mut [impl Ord + Copy])); 6] = [
    ("Insertion sort", insertion_sort),
    ("Selection sort", selection_sort),
    ("Bubble sort", bubble_sort),
    ("Merge sort", merge_sort),
    ("Quick sort", quick_sort),
    ("Heap sort", heap_sort),
];

The reason I would like to do this is so that I don't need to change the type of the sorting functions array when apply them to an array of numbers of a different type.

EDIT: What I want to accomplish is the following. Basically I want to test different sorting implementations easily by applying them in turn to an array defined earlier. The sorts array is used as follows, including the answer as provided by syskov.

fn main() {
    let problem: [u8; 32] = rand::random();
    fn create_sorts<T: Ord + Copy>() -> [(&'static str, fn(&mut [T])); 7] {
        [
            ("Insertion sort", insertion_sort),
            ("Selection sort", selection_sort),
            ("Bubble sort", bubble_sort),
            ("Merge sort", merge_sort),
            ("Quick sort", quick_sort),
            ("Heap sort", heap_sort),
            ("Stooge sort", stooge_sort),
        ]
    }

    println!("{:?}", problem);
    for (name, sort) in create_sorts().iter() {
        let mut problem_ = problem.clone();

        let now = Instant::now();
        sort(&mut problem_);
        let elapsed = now.elapsed();

        let judgment: &str = match is_sorted(&problem_) {
            true => "✓",
            false => "✗",
        };

        println!("{} in {:?}: {}", judgment, elapsed, name);
    }
}

I don't know exactly context when sorts is used, but you can have some sort of generic function it based on numbers array you sort. It would reduce boilerplate.

fn main () {
    fn insertion_sort(array: &mut [impl Ord + Copy]) { }
    fn selection_sort(array: &mut [impl Ord + Copy]) { }
    fn bubble_sort(array: &mut [impl Ord + Copy]) { }
    fn merge_sort(array: &mut [impl Ord + Copy]) { }
    fn quick_sort(array: &mut [impl Ord + Copy]) { }
    fn heap_sort(array: &mut [impl Ord + Copy]) { }

    fn create_sorts<T: Ord + Copy>() -> [(&'static str, fn (&mut [T])); 6] {
        [
            ("Insertion sort", insertion_sort),
            ("Selection sort", selection_sort),
            ("Bubble sort", bubble_sort),
            ("Merge sort", merge_sort),
            ("Quick sort", quick_sort),
            ("Heap sort", heap_sort),
        ]
    }

    let sorts_u32 = create_sorts::<u32>();
    let sorts_u64 = create_sorts::<u64>();
}

You need to have a generic function or struct to store your array. Something similar to examples below.

fn dumb<T>() 
where T : Ord + Copy
{

    // What I want to accomplish. Note the fn(&mut [impl Ord + Copy])
    let sorts: [(&'static str, fn(&mut [T])); 6] = [
        ("Insertion sort", insertion_sort),
        ("Selection sort", selection_sort),
        ("Bubble sort", bubble_sort),
        ("Merge sort", merge_sort),
        ("Quick sort", quick_sort),
        ("Heap sort", heap_sort),
    ];
    
}

struct Sorts<T> 
where T : Ord + Copy
{
    sorts : [(&'static str, fn(&mut [T])); 6]
}

impl<T> Sorts<T> 
where T : Ord + Copy
{

    pub fn new() -> Self {
        Sorts {
            sorts : [
                ("Insertion sort", insertion_sort),
                ("Selection sort", selection_sort),
                ("Bubble sort", bubble_sort),
                ("Merge sort", merge_sort),
                ("Quick sort", quick_sort),
                ("Heap sort", heap_sort),
            ]
        }
    }

}