Async system interaction.

[semtexzv]

I'm working on an app, that requires doing some async stuff. Currently there is no way to interact between these 2 systems.
Even a simple mechanism for posting messages to change state would be very helpful.

[fwcd]

Nuit's state management is a bit different from other GUI frameworks that rely on message passing (e.g. Elm-inspired ones), but if you have an idea of how to make it work, feel free to contribute!

[semtexzv]

I think it'll have to be callback based (to include State changes). What I'd do for SwiftUI:

1. Start a thread pool (or single background thread) tokio executor to execute long running operations.
2. Implement a new spawn method that posts long running work onto background executor, and processes the result on main thread.

pub fn spawn<Item, Fut, Fun>(fut: Fut, fun: Fun)
where
    Fut: Future<Output =Item> + Send + 'static,
    Fun: FnOnce(Item) + 'static,
{
    // copied from dispatch crate
    fn context_and_function<F>(closure: F) -> (*mut c_void, dispatch_function_t)
    where F: FnOnce() {
        extern fn work_execute_closure<F>(context: Box<F>) where F: FnOnce() {
            (*context)();
        }

        let closure = Box::new(closure);
        let func: extern fn(Box<F>) = work_execute_closure::<F>;
        unsafe {
            (mem::transmute(closure), mem::transmute(func))
        }
    }

    // Somehow assert we're on main thread before spawning onto background queue.
    tokio::spawn(async move {
        let item = fut.await;

        let (context, work) = context_and_function(fun);
        unsafe {
            dispatch_async_f(dispatch_get_main_queue(), context, work);
        }
    })
}

Example use:

#[derive(Bind)]
struct Sample {
    running: State<bool>,
    result: State<Option<String>>,
}

impl View for Sample {
    type Body = impl View;

    fn body(&self) -> Self::Body {
        let text = if self.running.get() { "Run" } else { "Cancel" };

        let running = self.running.clone();
        let result = self.result.clone();
        Button::with_text(text, move || {
            running.set(false);
            nuit::spawn(make_long_running_operation(), |val| {
                result.set(val);
                running.set(false);
            })
        })
    }
}

My question here is, would this work with state tracking and accurately cause the tree to be re-evaluated?