Hi! Thanks for opening your first issue here! 😄

Looks interesting! I am not an expert on the crates you mentioned, so it would be great to firstly know some background. For example, do you mean that nuclei acts as a replacement of tokio for async runtime? This does seem to be possible since frb does not enforce one specific async system (but may need a bit of refactor for some details if needed).

Looks interesting! I am not an expert on the crates you mentioned, so it would be great to firstly know some background. For example, do you mean that nuclei acts as a replacement of tokio for async runtime? This does seem to be possible since frb does not enforce one specific async system (but may need a bit of refactor for some details if needed).

Yes mostly I think it's possible to be guarded by a feature like rust-async-nuclei and will be used instead of tokio
Nuclei under it will Uses async-io feature of async-global-executor by default
But can be changed to tokio
Mostly it's an abstraction on top of executors

In a asynchronous runtime there is two important sections Executor and reactor

Also there is two different patterns reactor and proactor

Both tokio and async-std is using reactor model

Nuclei is a very young crate that is implemented with proactor pattern and that is using io_uring in linux for example

I see. I guess it would be great to allow users to define their own async runtimes. For example, currently we use https://github.com/fzyzcjy/flutter_rust_bridge/blob/master/frb_rust/src/rust_async/io.rs (for non-web) and https://github.com/fzyzcjy/flutter_rust_bridge/blob/master/frb_rust/src/rust_async/web.rs (for web). I guess it may be possible to abstract out a bit more s.t. we can change to arbitrary runtime. For example, instead of hardcoding tokio::task::JoinHandle, we may do

pub trait BaseAsyncRuntime {
    type JoinHandle;

    fn spawn<F>(&self, future: F) -> JoinHandle<F::Output>
    where
        F: Future + Send + 'static,
        F::Output: Send + 'static;
}

impl BaseAsyncRuntime for SimpleAsyncRuntime {
    JoinHandle = tokio::task::JoinHandle
...
}

I see. I guess it would be great to allow users to define their own async runtimes. For example, currently we use https://github.com/fzyzcjy/flutter_rust_bridge/blob/master/frb_rust/src/rust_async/io.rs (for non-web) and https://github.com/fzyzcjy/flutter_rust_bridge/blob/master/frb_rust/src/rust_async/web.rs (for web). I guess it may be possible to abstract out a bit more s.t. we can change to arbitrary runtime. For example, instead of hardcoding tokio::task::JoinHandle, we may do

pub trait BaseAsyncRuntime {
    type JoinHandle;

    fn spawn<F>(&self, future: F) -> JoinHandle<F::Output>
    where
        F: Future + Send + 'static,
        F::Output: Send + 'static;
}

impl BaseAsyncRuntime for SimpleAsyncRuntime {
    JoinHandle = tokio::task::JoinHandle
...
}

Exactly I will create a PR for you to review and then we can discuss base on code in more detail

Looking forward to it!

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.

This thread has been automatically locked since there has not been any recent activity after it was closed. If you are still experiencing a similar issue, please open a new issue.