Pattern for calling async methods on members of the application object... ?

[andretietz]

I've been hitting this problem and I wonder if this isn't a common problem already and might have a good pattern to solve...
I am comparable young to rust, so please forgive me if this is a straight forward question :/

Following code doesn't compile:

  fn update(&mut self, message: Message) -> Command<Message> {
    match message {
      Message::Setup(item) => {
        return match initial_setup::update(&mut self.data, item) {
          Ok(company) => Command::perform(self.database.save_company(company), |result| match result {
            Ok(_) => Message::EnterRunning,
            Err(error) => Message::Error(error),
          }),
          Err(_) => Command::perform(async {}, |_| Message::EnterSetup), // <= is there a better way to do this?
        };
      }

Here the error message:

70 |     fn update(&mut self, message: Message) -> Command<Message> {
   |               ---------
   |               |
   |               `self` is a reference that is only valid in the associated function body
   |               let's call the lifetime of this reference `'1`
...
74 |             Ok(company) => Command::perform(self.database.save_company(company), |result| match result {
   |  __________________________^
75 | |             Ok(_) => Message::EnterRunning,
76 | |             Err(error) => Message::Error(error),
77 | |           }),
   | |            ^
   | |            |
   | |____________`self` escapes the associated function body here
   |              argument requires that `'1` must outlive `'static`

Problem here is that the async part might be executed when Self is not alife anymore.

Is there a common pattern that is used to do things like this?

What I do to work around this atm, is creating a function, that recreates the database everytime I need do something with it (no member database in my Application object anymore), which seems odd...

[lufte]

For long-lived objects that need to be kept in the state but are used from async contexts use a smart pointer like std::sync::Arc. This way you can clone your Arc (knowing that it requires no (much) more memory than a normal pointer) and pass it by value to your async function without problem. If you need mutable access there are other options available too.