I need to write an interface for an API where I can access various async methods that take &mut self.
Since I'm writing an interface I have another struct to store the API and then implement the methods to call the API.
struct Foo {
// Bar API interface
bar: Bar,
runner: Runner<Self>,
}
&'static mut is almost never a useful type. You've probably got the 'static from a poor compiler suggestion. When the compiler says you must have a 'static lifetime, what it it's really trying to say is that temporary references are forbidden and won't work, and you should replace &mut T with Arc<Mutex<T>> instead, or redesign the whole architecture to avoid needing this at all.
In practice async runners don't support use of references, or any explicit scope-based mutability at all. They support T: Clone, and that's it. From there users of the type can choose if they make the T something trivially copyable, or Arc<immutable> or Arc<Mutex<something to actually mutate>>.
Rust is incredibly strict about exclusivity and temporary nature of scope-bound loans (&mut), so most of the time you won't be able to do anything non-trivial with them. They are not a way to refer to objects in a genral-purpose way, and they are not required for mutability. They're primarily to enforce temporary exclusive access.
From what I understand you are trying to execute the async methods Foo::_mul32 and Foo::_div64 at the same time using join_all. This can't happen since both of those methods take &mut self which is an exclusive reference and you have only one instance of Foo. You can't have 2 &mut Foo references to the Foo instance at the same time.
Okay, thanks for your response. This makes me be in a weird situation because the Bar API I had in my simplified version runs commands over the network and takes &mut self. The problem is that if I can't do a join_all then the functions are blocking and I need to wait for every connection to finish which is a problem since some functions are based on user input so it could take forever to run.