idea: wrap reactive with wit

[huang12zheng]

I don't know if it makes sense, and I have no solution about it.
and I just want to wrap reactive with wit.

This might allow multiple wasm code that depend on reactive to be depend on only one reactive wasm.

I want to ask you, do you think this will work?

• What in my mind:
  (1) wasi's poll.wit

The inspiration is that I can use resource to simulate an opaque.
I initially thought this might simulate PhantomData, but I was wrong

wit file:

interface poll {
    /// A "pollable" handle.
    resource pollable;

    poll-list: func(in: list<borrow<pollable>>) -> list<u32>;

    poll-one: func(in: borrow<pollable>);
}

binding auto-gen:

pub struct Pollable{
        handle: ::cargo_component_bindings::rt::Resource<Pollable>,  //u32
      }
////
static WAKERS: Mutex<Vec<(io::poll::Pollable, Waker)>> = Mutex::new(Vec::new());

client/guest use library

for index in io::poll::poll_list(&pollables) {
                    ready[usize::try_from(index).unwrap()] = true;
                }

                for (ready, (pollable, waker)) in ready.into_iter().zip(wakers) {
                    if ready {
                        waker.wake()
                    } else {
                        new_wakers.push((pollable, waker));
                    }
                }

• use host's struct Pollable instance of hanlde

with: {
                    "wasi:clocks/wall-clock": crate::preview2::bindings::clocks::wall_clock,
                    "wasi:filesystem/types/descriptor": super::super::filesystem::types::Descriptor,
                    "wasi:filesystem/types/directory-entry-stream": super::super::filesystem::types::DirectoryEntryStream,
                    "wasi:io/poll/pollable": super::super::io::poll::Pollable,
///
pub struct Pollable {
    index: u32,
    make_future: MakeFuture,
    remove_index_on_delete: Option<fn(&mut Table, u32) -> Result<()>>,
}

detail of impl about interface, You don't have to think about it.

impl<T: WasiView> poll::Host for T {
    async fn poll(&mut self, pollables: Vec<Resource<Pollable>>) -> Result<Vec<u32>> {
        type ReadylistIndex = u32;

        let table = self.table_mut();

        let mut table_futures: HashMap<u32, (MakeFuture, Vec<ReadylistIndex>)> = HashMap::new();

        for (ix, p) in pollables.iter().enumerate() {
            let ix: u32 = ix.try_into()?;

            let pollable = table.get(p)?;
            let (_, list) = table_futures
                .entry(pollable.index)
                .or_insert((pollable.make_future, Vec::new()));
            list.push(ix);
        }

        let mut futures: Vec<(PollableFuture<'_>, Vec<ReadylistIndex>)> = Vec::new();
        for (entry, (make_future, readylist_indices)) in table.iter_entries(table_futures) {
            let entry = entry?;
            futures.push((make_future(entry), readylist_indices));
        }

        struct PollList<'a> {
            futures: Vec<(PollableFuture<'a>, Vec<ReadylistIndex>)>,
        }
        impl<'a> Future for PollList<'a> {
            type Output = Vec<u32>;

            fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
                let mut any_ready = false;
                let mut results = Vec::new();
                for (fut, readylist_indicies) in self.futures.iter_mut() {
                    match fut.as_mut().poll(cx) {
                        Poll::Ready(()) => {
                            results.extend_from_slice(readylist_indicies);
                            any_ready = true;
                        }
                        Poll::Pending => {}
                    }
                }
                if any_ready {
                    Poll::Ready(results)
                } else {
                    Poll::Pending
                }
            }
        }

        Ok(PollList { futures }.await)
    }
}

[huang12zheng]

get value from handle:

pub fn get<T: Any + Sized>(&self, key: &Resource<T>) -> Result<&T, TableError> {
        self.get_(key.rep())?
            .downcast_ref()
            .ok_or(TableError::WrongType)
    }

[tigregalis]

This is interesting. Have you gotten any further with this? Sorry, a little off-topic from leptos, I have a similar problem with WIT: I'd like the guest to be able to insert some arbitrary data, e.g. during a setup function, then access that arbitrary data (safely and conveniently) during an update function. Something like:

world {
  resource context; // but this holds any `T` on the client side... the host doesn't really know or care
  export setup: func() -> context; // construct some context object
  export update: func(borrow<context>); // mutate that context object
}

I've run into two problems with the Rust version of this (guest side):

1. update takes an immutable borrow of context, so I can't mutate the context to keep some app state
2. it's not clear to me how to have context hold something generic and pass that across the boundary, while being able to access it concretely on the guest side