Deserialize tuple value life time issue - rust

Question

When I try to deserialise a value inside a tuple, it won't allow me to push the result into an array.
fn main() {
let raw_value = vec![(1, ("a", "a", 1))];
//serialise
let mut serialized_value = vec![];
for val in raw_value.iter() {
serialized_value.push((
bincode::serialize(&val.0).unwrap(),
bincode::serialize(&val.1).unwrap(),
));
}
//deserialise
let mut deserialized_value: Vec<(&str, &str, i32)> = vec![];
for val in serialized_value {
deserialized_value.push(bincode::deserialize(&val.1).unwrap());
}
}
It issues the following error:
error[E0597]: `val.1` does not live long enough
--> src/main.rs:18:54
|
18 | deserialized_value.push(bincode::deserialize(&val.1).unwrap());
| ---------------------------------------------^^^^^^-----------
| | |
| | borrowed value does not live long enough
| borrow later used here
19 | }
| - `val.1` dropped here while still borrowed
But this works fine if I refactor the value to not be inside a tuple.
Any ideas why?

Answer 1

You are iterating destructively through serialized_value.
Because of that, after the given loop iteration ends, the val is dropped and after the whole loop the serialized_value is fully consumed.
If you iterate through &serialized_value instead, then the val will be reference to the element in the container and serialized_value will be kept alive on the stack, because it's being referenced.

Answer 2

Adding to #miszcz2137's answer, here is the working version:
fn main() {
let raw_value = vec![(1, ("a", "a", 1))];
//serialise
let mut serialized_value = vec![];
for val in raw_value.iter() {
serialized_value.push((
bincode::serialize(&val.0).unwrap(),
bincode::serialize(&val.1).unwrap(),
));
}
//deserialise
let mut deserialized_value: Vec<(&str, &str, i32)> = vec![];
for val in &serialized_value {
deserialized_value.push(bincode::deserialize(&val.1).unwrap());
}
println!("{:?}", deserialized_value);
}
[("a", "a", 1)]
That said, it's not quite idiomatic to fill a vector through a for loop. It's much better practice to use iterators and .collect():
fn main() {
let raw_value = vec![(1, ("a", "a", 1))];
//serialise
let serialized_value: Vec<_> = raw_value
.iter()
.map(|val| {
(
bincode::serialize(&val.0).unwrap(),
bincode::serialize(&val.1).unwrap(),
)
})
.collect();
//deserialise
let deserialized_value: Vec<(&str, &str, i32)> = serialized_value
.iter()
.map(|val| bincode::deserialize(&val.1).unwrap())
.collect();
println!("{:?}", deserialized_value);
}
[("a", "a", 1)]