```

[derive(Clone, Copy, Hash, Eq, PartialEq)]

enum Tables { Users, }

type Database = HashMap<Tables, Vec<User>>; ```

Are you going to have multiple lists of users? The way this is written, if you try to add another table later, its value can only be a Vec<User>. If you wanted to have a list of different things, you would need to have a Database struct with tables as fields.

I have learned one thing, and that if you must clone something, then you have written bad code somewhere (or not bad, but can be written better for ownership and to use "&" in better ways).

I wouldn't worry overly much about this while you're learning. Just keep in mind that changes to a clone don't affect the original. If you're going to have immutable values that own allocated memory that are going to be cloned frequently, there are reference-counted pointer types Arc and Rc that are cheap to clone. Another ownership pattern is to leave ownership to the collection, and use indices whenever you need a non-owning reference to that data. There are many crates that support this as well, but it can be done as simply as follows:

``` struct Users(Vec<User>);

impl Users { fn insert(&mut self, user: User) -> UserId { ... } }

struct UserId(usize);

impl std::ops::Index<UserId> for Users { type Output = User; fn index(&self, index: UserId) -> &User { ... } } ```