I can't seem to use Actions at all without running into lifetime issues

[J-Cake]

Hey guys, I'm struggling to get Actions working. No matter what I do, I cannot even seem to access the value passed into the action without triggering lifetime issues. My code looks like this:

#[derive(Debug, Default, Clone, Serialize, Deserialize, Eq, PartialEq)]
pub struct Upload {
    pub message: String
}

impl Upload {
    pub async fn dispatch(&self) -> Result<Leave, crate::ApiError> {
        // do the actual API magic here
    }
}

// ---

#[component]
pub fn upload_form() -> impl View {
    let textedit = RwSignal::new(String::new());
    let upload = Action::<Upload, Result<(), crate::ApiError>>::new(async move |upload: &Upload| {
        upload.dispatch().await
    });

    view! {
        <textarea value=textedit />
        <button on:click=move |_| upload.dispatch(Upload {
            message: textedit.get()
        }) />
    }
}

The error I get is this:

error: lifetime may not live long enough
  --> src/example.rs:17
   |
17 |       let send_request = Action::<LeaveRequest, Result<(), crate::ApiError>>::new(async move |req: &Upload| {
   |  __________________________________________________________________________________________________-______-_^
   | |                                                                                    |            |
   | |                                                                                    |            return type of closure `{async closure body@src/example.rs:17}` contains a lifetime `'2`
   | |                                                                                    let's call the lifetime of this reference `'1`
18 | |         upload.dispatch().await;
19 | |     });
   | |_____^ returning this value requires that `'1` must outlive `'2`

Interrestingly, I tried to forego the middle closure by simply passing in Upload::dispatch directly, but I get a type mismatch error:

// ---
    let upload = Action::<Upload, Result<(), crate::ApiError>>::new(Upload::dispatch);
// ---

error[E0308]: mismatched types
  --> src/example.rs:17
   |
49 |     let send_request = Action::<Upload, Result<(), crate::Error>>::new(Upload::dispatch);
   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
   |
   = note: expected opaque type `impl for<'a> futures::Future<Output = std::result::Result<(), crate::ApiError>>`
              found opaque type `impl futures::Future<Output = std::result::Result<(), crate::ApiError>>`
   = help: consider `await`ing on both `Future`s
   = note: distinct uses of `impl Trait` result in different opaque types

[gbj]

The async closure feature maybe giving you a less-than-helpful helpful error here. Yours is the equivalent of this

move |upload: &Upload| async move {
  upload.dispatch().await
}

So you can see the &Upload reference is moved into the async block. This means that the async block has some lifetime &'a, which is the lifetime of &'a Upload.

But the function signature is this

pub fn new<F, Fu>(action_fn: F) -> Self
where
    F: Fn(&I) -> Fu + 'static,
    Fu: Future<Output = O> + 'static,

i.e., Fu the Future needs to be 'static: it cannot hold references to anything outside itself, but needs to own its own data. Ultimately this is a hard requirement of handing the Future off to wasm-bindgen-futures to actually run it.

So you need to do something like this

move |upload: &Upload| {
    let upload = upload.clone();
    async move { upload.dispatch().await }
}

so that the Future owns its data.

Alternately, you can design your dispatch function in such a way that it assures the compiler it doesn't actually hold the reference to &Upload in the async part. This is possible depending on what you're actually doing with the string. For example this would work, because it doesn't actually capture the reference in the async block

pub fn dispatch(&self) -> impl Future<Output = ()> + 'static {
    let len = self.message.len();
    async {
        _ = len;
        // do something with the length
    }
}

The reason that you only get &Upload rather than Upload, by the way, is that the original value gets stored in the .input() signal, which records the most-recently-submitted value -- useful for things like optimistic UI.

tl;dr: just .clone() the Upload before moving it into the async bit

[J-Cake]

I can confirm this worked for me. Thanks for your help