Rust - return a future in a closure

Question

I am trying to add a return type of a future in a closure. But the compiler is telling me that

`impl Trait` only allowed in function and inherent method return types, not in closure return

I have have also tried wrapping it in Box but that didn't work. I tried type aliases but they are nighly only features. I am unable to understand how else can I solve it.

pub async fn execute_event_handler(
    event_handler: Option<Arc<PyFunction>>,
    event_loop: Arc<Py<PyAny>>,
) -> Result<(), Box<dyn std::error::Error>> {
    if let Some(handler) = event_handler {
        match &(*handler) {
            PyFunction::SyncFunction(function) => {
                println!("Startup event handler");
                Python::with_gil(|py| -> Result<(), Box<dyn std::error::Error>> {
                    function.call0(py)?;
                    Ok(())
                })?;
            }
            PyFunction::CoRoutine(function) => {
                let future = Python::with_gil(
                    |py| -> impl Future<Output = Result<Py<PyAny>, PyErr>> + Send { // this is giving an error
                        println!("Startup event handler async");

                        let coroutine = function.as_ref(py).call0().unwrap();
                        pyo3_asyncio::into_future_with_loop((*event_loop).as_ref(py), coroutine)
                            .unwrap()
                    },
                );
                future.await?;
            }
        }
    }
    Ok(())
}

PS: I want to wrap the closure output in an Result type and hence a return type is necessary.

What happens if you just omit the return type from the closure? Usually an explicit return type on a closure is unnecessary. — cdhowie, May 14 '22 at 16:10
@cdhowie , I want to wrap it in an `Result` and hence a return type is necessary. — Sanskar Jethi, May 14 '22 at 16:29
You can return a `Result` without explicitly annotating the return type. — cdhowie, May 14 '22 at 16:42
@cdhowie , can you please show me an example for the same? I am not sure how is it done. — Sanskar Jethi, May 14 '22 at 16:52
`let returns_future_result = || async { Result::<_, ()>::Ok(()) };` — MeetTitan, May 14 '22 at 20:28

score 1 · Answer 1 · edited May 15 '22 at 00:29

1

Don't annotate the future.

If you need to annotate the enclosing type (e.g. Result), you can either annotate it when returning it (Result::<_, ErrorType>) or as the return type, but let inference find the future type itself with _: || -> Result<_, ErrorType>.

edited May 15 '22 at 00:29

cdhowie

158,093
24
286
300

answered May 14 '22 at 21:14

Chayim Friedman

47,971
5
48
77

1

Note that you can apply turbofish directly to the enum variant, which is a bit more terse (`Ok::<_, ErrorType>(|| ...)`). – cdhowie May 15 '22 at 00:31

Rust - return a future in a closure

1 Answers1