Function async_stdin

pub fn async_stdin() -> AsyncReader 

Construct an asynchronous handle to the TTY standard input.

This allows you to read from standard input without blocking the current thread. Specifically, it works by firing up another thread to handle the event stream, which will then be buffered in a mpsc queue, which will eventually be read by the current thread.

This will not read the piped standard input, but rather read from the TTY device, since reading asyncronized from piped input would rarely make sense. In other words, if you pipe standard output from another process, it won’t be reflected in the stream returned by this function, as this represents the TTY device, and not the piped standard input.

Examples found in repository

examples/async.rs (line 12)

fn main() {
    let stdout = stdout();
    let mut stdout = stdout.lock().into_raw_mode().unwrap();
    let mut stdin = async_stdin().bytes();

    write!(
        stdout,
        "{}{}",
        termion::clear::All,
        termion::cursor::Goto(1, 1)
    )
    .unwrap();

    loop {
        write!(stdout, "{}", termion::clear::CurrentLine).unwrap();

        let b = stdin.next();
        write!(stdout, "\r{:?}    <- This demonstrates the async read input char. Between each update a 100 ms. is waited, simply to demonstrate the async fashion. \n\r", b).unwrap();
        if let Some(Ok(b'q')) = b {
            break;
        }

        stdout.flush().unwrap();

        thread::sleep(Duration::from_millis(50));
        stdout.write_all(b"# ").unwrap();
        stdout.flush().unwrap();
        thread::sleep(Duration::from_millis(50));
        stdout.write_all(b"\r #").unwrap();
        write!(stdout, "{}", termion::cursor::Goto(1, 1)).unwrap();
        stdout.flush().unwrap();
    }
}