Cannot return Iterator::Item from function

I'm writing a function to select a random variant from an enum with the help of the crate strum and its EnumIter derive macro:

#[derive(EnumIter)]
pub enum Colors {
	Red,
	Blue,
	Purple
}

fn get_random_enum<T: Iterator>(iter: &mut T, rng: &mut Random) -> <T as Iterator>::Item {
	
	let options = iter.collect::<Vec<_>>();
	let count = options.len();
	
	let idx = rng.rand_range(0, (count-1) as u32);
	let item = options[idx as usize];

	return item;
}


fn main() {
    let rng = create_MyRandomNumberGenerator();
    let color = get_random_enum(&mut Colors::iter(), rng);
}

This does not compile, as it states that:

error[E0507]: cannot move out of index of `Vec<<T as Iterator>::Item>`
  --> stage/main.rs:15:13
   |
15 |     let item = options[idx as usize];
   |                ^^^^^^^^^^^^^^^^^^^^^ move occurs because value has type `<U as Iterator>::Item`, which does not implement the `Copy` trait

I'm quite new to Rust, but as I understand, <U as Iterator>::Item does not implement the Copy trait and that's the reason I cannot just return it.

Checking the generated code by the strum macro, I see that Item is just an alias of my Colors enum, but even if I add the Copy derive to my enum this still does not work.
I'm quite lost what's the way to implement this in Rust.

Unlike in C++, Rust generics are principled, meaning that they need to always typecheck for any possible instantiation of their generic parameters. Therefore it does not suffice to implement Copy for your concrete struct/enum, but you also need to require it in the generic type bound. The same would even be necessary if we returned a .clone()d instance of the Item, we would then still need to require the Clone trait for any Item.

Solution: As the compiler hints at, we need the generic function to require the Item type of the iterator to implement Copy:

fn get_random_enum<T: Iterator<Item=I>, I: Copy>(iter: &mut T, rng: &mut Random) -> I {
    
    let options = iter.collect::<Vec<_>>();
    let count = options.len();
    
    let idx = rng.rand_range(0, (count-1) as u32);
    let item = options[idx as usize];

    return item;
}

You can remove the desired item from that Vec that way you don't have to introduce any more bounds:

fn get_random_item<T: Iterator>(iter: &mut T, rng: &mut Random) -> <T as Iterator>::Item {
    let mut items = iter.collect::<Vec<_>>();
    let count = items.len();

    let idx = rng.rand_range(0, (count - 1));

    items.swap_remove(idx)
}

If your random generator implements rand::Rng you can also just use the IteratorRandom extension trait to directly choose on of the items:

use rand::seq::IteratorRandom;
fn get_random_enum<T: IntoEnumIterator, R: Rng>(rng: &mut R) -> T {
    T::iter().choose_stable(rng).unwrap()
}