Errors

Using the ? operator propagates the error from the expression. How this works depends on whether ? is used from an async expression or from a handler. Using ? in an async expression propagates the error out of the async expression. This makes the output of the async expression a Result. Using ? from a handler immediately propagates the error out of the select! expression. Let’s look at the accept loop example again:

  1. use tokio::net::TcpListener;
  2. use tokio::sync::oneshot;
  3. use std::io;
  5. #[tokio::main]
  6. async fn main() -> io::Result<()> {
  7.     // [setup `rx` oneshot channel]
  9.     let listener = TcpListener::bind("localhost:3465").await?;
  11.     tokio::select! {
  12.         res = async {
  13.             loop {
  14.                 let (socket, _) = listener.accept().await?;
  15.                 tokio::spawn(async move { process(socket) });
  16.             }
  18.             // Help the rust type inferencer out
  19.             Ok::<_, io::Error>(())
  20.         } => {
  21.             res?;
  22.         }
  23.         _ = rx => {
  24.             println!("terminating accept loop");
  25.         }
  26.     }
  28.     Ok(())
  29. }

Notice listener.accept().await?. The ? operator propagates the error out of that expression and to the res binding. On an error, res will be set to Err(_). Then, in the handler, the ? operator is used again. The res? statement will propagate an error out of the main function.