Struct SmolRT 

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

Implementations

impl SmolRT

pub fn new_global() -> Self

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

spawn coroutine with specified Executor

Trait Implementations

impl AsyncExec for SmolRT

fn spawn<F, R>(&self, f: F) -> impl AsyncJoinHandle<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: Send + 'static,

Run a future to completion on the runtime

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

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: &PathBuf) -> 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>>

Convert a readable file descriptor to an async handle.

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

Convert a readable/writable file descriptor to an async handle.

fn connect_tcp_timeout( addr: &SocketAddr, timeout: Duration, ) -> impl Future<Output = Result<Self::AsyncFd<TcpStream>, Error>> + Send

where Self: AsyncTime,

Connect to a TCP address with a timeout.

fn connect_unix_timeout( addr: &PathBuf, timeout: Duration, ) -> impl Future<Output = Result<Self::AsyncFd<UnixStream>, Error>>

where Self: AsyncTime,

Connect to a Unix socket with a timeout.

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 tick(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