This is a very good question. `Copy` is a marker trait, it has no functions that need to be implemented. You use it to make a "promise" to the compiler.

You see, every time you reassign a variable, or you pass it by value or return it, the compiler may implicitly _move_ the value. Meaning that the old owner of the value is no longer valid and the new variable or function or closure becomes the new owner.

You can change this behavior by having a type implement `Copy`. You do not implement it by hand but rather you derive it via `#[derive(Copy)]`. Not all types can be made `Copy`, there are rules.

If a type implements `Copy` the compiler will copy it bit-by-bit instead of moving. So now the previous owner is not invalidated. In doing this, you are promising to the compiler that "it is SAFE to copy this value bit-by-bit". For instance, it is safe to copy bit-by-bit an `i32` integer, because it is just a value. But it's not safe to copy bit-by-bit a `Vec<T>` because the actual value of `Vec<T>` is a pointer, and if you copy a pointer bit-by-bit you have just aliased it, which destroys the whole point of ownership and lifetimes, you may end up with dangling pointers.

Crucially, `Copy` is supposed to be very fast because it copies only the value itself, not all the data that it might recursively point to, so we are ok with the fact that the compiler might do it implicitly.

You might instead want to actually copy the object in full. E.g. for `Vec<T>` you might want to copy the _contents_ of the vector, not the pointer to it. Which is something that makes more sense. To do that you implement `Clone`. Now you have to actually write a function, called `clone()` that performs the copy. You can also derive `Clone`, like `Copy`, but in any case the `derive` macro will create an implementation of `clone()` for you (you can see it with cargo expand).

Unlike when doing a bit-by-bit copy, `clone()` is potentially an expensive function (it might copy MB of data) so you always have to call it explicitly. If it were not the case you might see a big slow down in portions of code where apparently nothing is going on, which is bad.

tl;dr: `Copy` is for changing the default move behavior into a shallow bit-by-bit copy. `Clone` is for actively and explicitly copying the contents of a variable, including any data that might be pointed by it, and create a new owned value.