Hacked it like this but I feel like this isn't a good solution.

Are you sure &String is the best option here? What do you think about using &str?

explained in the other inline.

The problem here is with lifetimes. I tried to use str but the compiler was yelling that it should have a static lifetime. And when I made it static it also tried to force me to make all things using these variables to be static. I don't think we want them to be static at all. Maybe I'm doing something wrong, IDK.

.clone() works fine as well, I thought I've already tried it and something was broken but apparently it works.

Yes, good catch, I took this code from somewhere and forgot to remove the loop, thx.

I do not think this is possible honestly. If we move the backup data into this function, we're not going to be able to use it for further calls that need to use this data. I think we have to borrow.

Currently we pretend to borrow, but we copy the values when they arrive.

Yes, it may look like this. In fact, we do borrow, not only pretend. We copy only the stuff that we need in the async calls. I think we talked about this and I guess rust just doesn't recognize whether we await all asyncs or not and assumes we may not, therefore it sees the lifetimes' collisions (that we launch some async stuff in this function, that will live, for instance, for 10 secs, then we exit this function and the outer scope that owns the backup data terminates after 3secs, so we would end up with dead references (if we passed the refs to the async function)).

Not sure about the best practice for this. @varun @jimpo?

Also a question - do I understand this correctly?

We can do it, yes.

I talked to the guy in swm who is good at rust and he said that this pattern's ok, it doesn't look the best but it's common in rust. Thing is, if we do not clone, rust will try to move these values into the outbound. We do not want that, we want to use them again later.

He showed me a similar pattern that he's seen many times in rust code:

let f = {
  let clon_a = a.clone();
  let clon_b = b.clone();
  move || {
    return clon_a + clon_b;
  }
}

Great! Thanks for checking that