Struct SmolRT 

pub struct SmolRT(/* private fields */);

The SmolRT implements AsyncRuntime trait

Implementations

impl SmolRT

pub fn new_global() -> Self

pub fn new_with_executor(executor: Arc<Executor<'static>>) -> Self

spawn coroutine with specified Executor.

Safety

You should run block_on on this executor somewhere (self.block_on also counts), otherwise the future spawn into this executor will not run.

Trait Implementations

impl AsyncExec for SmolRT

fn current() -> Self

Initiate executor using current thread.

Safety

You should run Self::block_on() with this executor.

If spawn without a block_on() running, it’s possible the runtime just init future without scheduling.

fn one() -> Self

Initiate executor with one background thread.

NOTE

Self::block_on() is optional.

fn multi(size: usize) -> Self

Initiate executor with multiple background threads.

NOTE

When num == 0, start threads that match cpu number Self::block_on() is optional.

fn spawn<F, R>(&self, f: F) -> Self::AsyncHandle<R>

where F: Future<Output = R> + Send + 'static, R: Send + 'static,

Spawn a task in the background

fn spawn_detach<F, R>(&self, f: F)

where F: Future<Output = R> + Send + 'static, R: Send + 'static,

Depends on how you initialize SmolRT, spawn with executor or globally

fn block_on<F, R>(&self, f: F) -> R

where F: Future<Output = R> + Send, R: 'static,

Run a future to completion on the runtime

NOTE: when initialized with an executor, will block current thread until the future returns

type AsyncHandle<R: Send> = SmolJoinHandle<R>

type ThreadHandle<R: Send> = BlockingJoinHandle<R>

fn spawn_blocking<F, R>(f: F) -> Self::ThreadHandle<R>

where F: FnOnce() -> R + Send + 'static, R: Send + 'static,

Run blocking code in a background thread pool, and return an async join handle

fn to_dyn(self) -> Arc<dyn AsyncExecDyn>

where Self: Sized,

impl AsyncExecDyn for SmolRT

fn spawn_detach_dyn(&self, f: Box<dyn Future<Output = ()> + Send + Unpin>)

Spawn a task and detach it (no handle returned).

impl AsyncIO for SmolRT

type AsyncFd<T: AsRawFd + AsFd + Send + Sync + 'static> = SmolFD<T>

The type used to represent async file descriptors.

async fn connect_tcp(addr: &SocketAddr) -> Result<Self::AsyncFd<TcpStream>>

Connect to a TCP address asynchronously.

async fn connect_unix(addr: &Path) -> Result<Self::AsyncFd<UnixStream>>

Connect to a Unix socket address asynchronously.

fn to_async_fd_rd<T: AsRawFd + AsFd + Send + Sync + 'static>( fd: T, ) -> Result<Self::AsyncFd<T>>

Wrap a readable file object as an async handle

fn to_async_fd_rw<T: AsRawFd + AsFd + Send + Sync + 'static>( fd: T, ) -> Result<Self::AsyncFd<T>>

Wrap a readable/writable file object as an async handle.

impl AsyncTime for SmolRT

type Interval = SmolInterval

The type used for periodic timers.

fn sleep(d: Duration) -> impl Future + Send

Sleep for the specified duration.

fn interval(d: Duration) -> Self::Interval

Create a periodic timer that ticks at the specified interval.

fn timeout<F>( d: Duration, func: F, ) -> impl Future<Output = Result<<F as Future>::Output, ()>> + Send

where F: Future + Send,

Apply a timeout to a future.

impl Clone for SmolRT

fn clone(&self) -> SmolRT

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SmolRT

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl AsyncRuntime for SmolRT