Struct smol::Timer

pub struct Timer { /* fields omitted */ }

Fires at the chosen point in time.

Timers are futures that output the Instant at which they fired.

Examples

Sleep for 1 second:

use smol::Timer;
use std::time::Duration;

async fn sleep(dur: Duration) {
    Timer::after(dur).await;
}

sleep(Duration::from_secs(1)).await;

Set a timeout on an I/O operation:

use futures::future::Either;
use futures::io::{self, BufReader};
use futures::prelude::*;
use smol::Timer;
use std::time::Duration;

async fn timeout<T>(
    dur: Duration,
    f: impl Future<Output = io::Result<T>>,
) -> io::Result<T> {
    futures::pin_mut!(f);
    match future::select(f, Timer::after(dur)).await {
        Either::Left((out, _)) => out,
        Either::Right(_) => Err(io::ErrorKind::TimedOut.into()),
    }
}

// Create a buffered stdin reader.
let mut stdin = BufReader::new(smol::reader(std::io::stdin()));

// Read a line within 5 seconds.
let mut line = String::new();
timeout(Duration::from_secs(5), stdin.read_line(&mut line)).await?;

Implementations

impl Timer

pub fn after(dur: Duration) -> Timer

Fires after the specified duration of time.

Examples

use smol::Timer;
use std::time::Duration;

Timer::after(Duration::from_secs(1)).await;

pub fn at(when: Instant) -> Timer

Fires at the specified instant in time.

Examples

use smol::Timer;
use std::time::{Duration, Instant};

let now = Instant::now();
let when = now + Duration::from_secs(1);
Timer::at(when).await;

Trait Implementations

impl Debug for Timer

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

Formats the value using the given formatter.

impl Drop for Timer

fn drop(&mut self)

Executes the destructor for this type.

impl Future for Timer

type Output = Instant

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.