[][src]Crate smol

A small and fast async runtime.

This crate simply re-exports other smaller async crates (see the source).

To use tokio-based libraries with smol, apply the async-compat adapter to futures and I/O types.

Examples

Connect to an HTTP website, make a GET request, and pipe the response to the standard output:

use smol::{io, net, prelude::*, Unblock};

fn main() -> io::Result<()> {
    smol::block_on(async {
        let mut stream = net::TcpStream::connect("example.com:80").await?;
        let req = b"GET / HTTP/1.1\r\nHost: example.com\r\nConnection: close\r\n\r\n";
        stream.write_all(req).await?;

        let mut stdout = Unblock::new(std::io::stdout());
        io::copy(&stream, &mut stdout).await?;
        Ok(())
    })
}

There's a lot more in the examples directory.

Modules

channel

An async multi-producer multi-consumer channel.

fs

Async filesystem primitives.

future

Combinators for the Future trait.

io

Tools and combinators for I/O.

lock

Async synchronization primitives.

net

Async networking primitives for TCP/UDP/Unix communication.

prelude

Traits Future, AsyncBufRead, AsyncRead, AsyncSeek, AsyncWrite, and their extensions.

process

Async interface for working with processes.

stream

Combinators for the Stream trait.

Macros

pin

Pins a variable of type T on the stack and rebinds it as Pin<&mut T>.

ready

Unwraps Poll<T> or returns Pending.

Structs

Async

Async adapter for I/O types.

Executor

An async executor.

LocalExecutor

A thread-local executor.

Task

A spawned future.

Timer

A future that expires at a point in time.

Unblock

Runs blocking I/O on a thread pool.

Functions

block_on

Blocks the current thread on a future, processing I/O events when idle.

spawn

Spawns a task onto the global executor (single-threaded by default).

unblock

Runs blocking code on a thread pool.