Extend call_with_explicit_closure to block that returns a closure

[clouds56]

Feature Request

Now this would compile

rsx! {
  input {
    oninput: move |e| value.set(e.value()) // it is using `oninput::call_with_explicit_closure(..)`
  }
}

while this would not

rsx! {
  input {
    oninput: {
      let prefix = prefix.clone();
      move |e| value.set(format!("{}{}", prefix, e.value()) // using `oninput(..)`
    }
  }
}

Implement Suggestion

Shall we extend call_with_explicit_closure to work with a block which last expr is an explicit closure?
Since there's no "clone" closure in rust, it seems to be very common that we'd like to clone something before move (like Rc, Arc, SmolStr, etc.). not everything here is signal that Copy.
Now I have to

let prefix2 = prefix.clone()
rsx! {
  input {
    oninput: 
      move |e| value.set(format!("{}{}", prefix, e.value())
  }
}

See also
https://users.rust-lang.org/t/clone-when-moving-into-a-closure/82680
https://internals.rust-lang.org/t/feature-request-add-clone-closure/15484/2

[ealmloff]

This is a very common case and fairly easy to implement so I think this is worth adding. Once the expression gets complex enough, you will still need type annotations on the function argument for event handlers until rust's type inference improves:

fn main() {
    dioxus::launch(|| {
        let mut value = use_signal(String::new);
        let prefix = String::from("Hello, ");
        rsx! {
          input {
            oninput: 'a: {
              let prefix = prefix.clone();
              break 'a move |e: FormEvent| value.set(format!("{}{}", prefix, e.value()));

              todo!()
            }
          }
        }
    });
}