Rust lifetime issue with closures within same global scope - rust

Question

Here's the minimal representation of the problem in my code :
use std::collections::HashMap;
fn main() {
let mut map : HashMap<String, String> = HashMap::new();
map.insert(String::from("a"), String::from("first"));
map.insert(String::from("b"), String::from("second"));
let mut funcs: Vec<Box<dyn FnMut(String) -> ()>> = Vec::new();
for (key, val) in map {
funcs.push(Box::new(|v| {
println!("{} : {} : {}",key,val,v);
}))
}
for mut func in funcs {
func(String::from("c"));
}
}
The error : (same for val) :
`key` does not live long enough
values in a scope are dropped in the opposite order they are defined rustcE0597
main.rs(12, 5): `key` dropped here while still borrowed
main.rs(9, 29): value captured here
main.rs(17, 1): borrow might be used here, when `funcs` is dropped and runs the
`Drop` code for type `Vec`
This is a minimalist representation of my real life use case - I'm using a library which requires me to feed it a bunch of closures for an combined execution later on. I first build a HashMap, then loop over it to create a list of FnMut (in this minimal example Fn would also be fine)
I get the general idea of the error that I'm creating key (and val) with temporary lifespan which ends at the end of each loop, and the closures have a "deferred" execution where they will want to access this data which will no longer exist - but I have no idea how to fix it.
I tried map.into_iter(), map.drain() (to not use references), wrapping the data with Rc - without avail. What is the correct solution here ?
Since building the map is a somewhat complex process, I'd like to still have it built before making closures if possible.
EDIT1:
The solution to add move in front of the closure by #Masklinn does work here, but it creates other issues in my real code
The value of the map I use is Vec<MyStruct> which is not copyable, so it cannot be moved. I think I can solve it by implementing Copy trait (my struct is small enough, basically a bunch of Option)
The second issue is that as I create multiple closures, I borrow yet a second HashMap in multiple closures (non mutably), so after the second closure forth I get use of moved value error : how to handle this case ?
EDIT2: Illustration of second problem when using move :
fn main() {
let mut map : HashMap<String, Vec<String>> = HashMap::new();
map.insert(String::from("a"), Vec::from([String::from("first")]));
map.insert(String::from("b"), Vec::from([String::from("first")]));
let map2 : HashMap<String, Vec<String>> = HashMap::new();
let mut funcs: Vec<Box<dyn FnMut(String) -> ()>> = Vec::new();
for (key, val) in map {
funcs.push(Box::new(move |v| {
println!("{} : {:?} : {}, {}",key,val,v, map2.capacity());
}))
}
for mut func in funcs {
func(String::from("c"));
}
}
Error:
use of moved value: `map2`
value moved into closure here, in previous iteration of looprustcE0382
main.rs(12, 54): use occurs due to use in closure
main.rs(7, 9): move occurs because `map2` has type `HashMap<String, Vec<String>>`, which does not implement the `Copy` trait
Should I only be using copyable data (if yes, how ? Wrap the hashmap into a custom copyable struct?), or is there another way?
EDIT : SOLUTION
Thanks to #Masklinn : wrapping non-copyable data into Rc works perfectly !
use std::{collections::HashMap, rc::Rc};
fn main() {
let mut map : HashMap<String, Vec<String>> = HashMap::new();
map.insert(String::from("a"), Vec::from([String::from("first")]));
map.insert(String::from("b"), Vec::from([String::from("first")]));
let map2 : HashMap<String, Vec<String>> = HashMap::new();
let rc_map2: Rc<HashMap<String, Vec<String>>> = Rc::new(map2);
let mut funcs: Vec<Box<dyn FnMut(String) -> ()>> = Vec::new();
for (key, val) in map {
let rc_map2_clone = rc_map2.clone();
funcs.push(Box::new(move |v| {
println!("{} : {:?} : {}, {}",key,val,v, rc_map2_clone.capacity());
}))
}
for mut func in funcs {
func(String::from("c"));
}
}

Answer 1

What is the correct solution here ?
Just add the keyword move before the closure:
funcs.push(Box::new(move |v| {
println!("{} : {} : {}",key,val,v);
}))
By default, lambdas try to infer how the variable closed over should be captured (reference, mutable reference, or value). However this is based exclusively on usage.
Here you're just printing the key and value, so the usage requirements are just shared references, therefore inside the closure you have key: &String and val: &String.
By using move closures, you're telling the lambda to always capture by value (and you'll manage capturing e.g. references by value).
By using a move closure here we're making the closure own the key and value Strings, therefore their lifetimes are not an issue anymore.