feature: hyperapp oneshot & mpsc(?) channels

[nick1udwig]

Consider a case where you send a WS request and want to await a WS response

One way to do this that works right now is to:

loop {
  // sleep
  hyperware_process_lib::hyperapp::sleep(DELAY_MS).await;

  if let Some(response) = response_map(id) {
    // if response is here, handle it
  }
}

where id is registered with the request and when the response comes in it gets put into the response_map

It would be a lot nicer to, e.g.,

if let Some(response) = receiver.await {
}

I think either way we need to have the user manage the registration of requests or else it will be enforcing a certain format on their messages.

E.g. in the case of spider:

Store as pending response
https://github.com/nick1udwig/spider/blob/ccb0605012976429f466763a1939cb9024f152a6/spider/src/lib.rs#L850

Handle response
https://github.com/nick1udwig/spider/blob/ccb0605012976429f466763a1939cb9024f152a6/spider/src/lib.rs#L1314
https://github.com/nick1udwig/spider/blob/ccb0605012976429f466763a1939cb9024f152a6/spider/src/lib.rs#L1458

Poll awaiting response
https://github.com/nick1udwig/spider/blob/ccb0605012976429f466763a1939cb9024f152a6/spider/src/lib.rs#L1550-L1579

[nick1udwig]

If we could figure out a way to hide the registration of requests, that would be REALLY nice. Something like how we do send and ResponseFuture

[nick1udwig]

The other thing that would make this a lot more useful would be if we had a spawn like tokio: https://docs.rs/tokio/latest/tokio/task/fn.spawn.html

https://claude.ai/share/cc338dee-36c0-44db-bf28-212602306aca

[nick1udwig]

#162 adds spawn

[nick1udwig]

https://claude.ai/share/223d04b1-a11c-4f20-95de-16082abdb3f8

[nick1udwig]

Need a join-like construct to await multiple spawns

[jurij-jukic]

You can already do most of these things with tokio primitives. Channels are just data types, so it doesn't depend on the executor.
Some examples:

        let (sender, receiver) = mpsc::channel::<String>(10);

        for i in 0..3 {
            // Cloning senders
            let sender_clone = sender.clone();
            spawn(async move {
                for j in 0..5 {
                    let msg: String = format!("Thread {i} -> message {j}");
                    if let Err(err) = sender_clone.send(msg).await {
                        println!("send failed: {err}");
                        break;
                    }
                    if let Err(err) = sleep(200).await {
                        println!("timer failed: {err}");
                    }
                }
            });
        }

        // Dropping original sender
        drop(sender);

        // Consumer async task
        spawn(async move {
            let mut receiver = receiver;
            while let Some(msg) = receiver.recv().await {
                println!("Got: {}", msg);
            }
            println!("All senders closed, channel drained.");
        });

And the sending oneshot sender down mpsc channel to return a response:

        let (worker_tx, mut worker_rx) = mpsc::channel::<oneshot::Sender<u32>>(1);
        spawn(async move {
            if let Some(reply_tx) = worker_rx.recv().await {
                let _ = reply_tx.send(1 + 1);
            }
            println!("Oneshot example worker finished.");
        });

        let (reply_tx, reply_rx) = oneshot::channel();
        if let Err(err) = worker_tx.send(reply_tx).await {
            println!("failed to dispatch oneshot request: {err}");
        } else {
            match reply_rx.await {
                Ok(result) => println!("Oneshot worker computed: {result}"),
                Err(err) => println!("Oneshot worker dropped before replying: {err}"),
            }
        }

Both of these work cleanly in a hyperapp! Just gotta import tokio, features = ["sync"]
Note - can also use futures crate for the same use cases, syntax is just slight bit different, if you don't want to import tokio.

[jurij-jukic]

Join works for async functions in the hyperapp.

    let (first, second) = futures::join!(
        self.fetch_counter("first".to_string()),
        self.fetch_counter("second".to_string()),
    );
    println!("combined results -> {first}, {second}");
    

    #[local]
    async fn fetch_counter(&self, request_body: String) -> String {
        sleep(2000).await.ok();
        request_body
    }

Join doesn't yet work for spawned tasks because they don't return a handle (todo for me.)

[nick1udwig]

Ok this is great. Much better to use existing lib than to write ourselves. Nice find

[jurij-jukic]

PR here: #171