[][src]Crate smol

A small and fast async runtime.

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(())
    })
}

This example uses the net module for networking, but you can also use the primitive Async type. See the full code.

Look inside the examples directory for more.

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.