How to convert &Vector<Mutex> to Vector<Mutex>

Question

I'm working my way trough the Rust examples. There is this piece of code:

fn new(name: &str, left: usize, right: usize) -> Philosopher {
    Philosopher {
        name: name.to_string(),
        left: left,
        right: right,
    }
}

what is the best way to adapt this to a vector ? This works:

 fn new(v: Vec<Mutex<()>>) -> Table {
    Table {
       forks: v
    }
 }

Than I tried the following:

fn new(v: &Vec<Mutex<()>>) -> Table {
     Table {
         forks: v.to_vec()
     }
 }

But that gives me:

the trait `core::clone::Clone` is not implemented 
for the type    `std::sync::mutex::Mutex<()>` 

Which make sense. But what must I do If I want to pass a reference to Table and do not want to store a reference inside the Table struct ?

Answer 1

The error message actually explains a lot here. When you call to_vec on a &Vec<_>, you have to make a clone of the entire vector. That's because Vec owns the data, while a reference does not. In order to clone a vector, you also have to clone all of the contents. This is because the vector owns all the items inside of it.

However, your vector contains a Mutex, which is not able to be cloned. A mutex represents unique access to some data, so having two separate mutexes to the same data would be pointless.

Instead, you probably want to share references to the mutex, not clone it completely. Chances are, you want an Arc:

use std::sync::{Arc, Mutex};

fn main() {
    let things = vec![Arc::new(Mutex::new(()))];
    things.to_vec();
}