// ...
use futures_retry::{RetryPolicy, StreamRetryExt};

// In this example we use a free function to handle errors, while in your project you have
// more options: for simple cases a simple closure will do, for complex cases you might go
// as far as implementing an `ErrorHandler` trait for a custom type with some complex logic.
fn handle_error(e: io::Error) -> RetryPolicy<io::Error> {
  match e.kind() {
    io::ErrorKind::Interrupted => RetryPolicy::Repeat,
    io::ErrorKind::PermissionDenied => RetryPolicy::ForwardError(e),
    _ => RetryPolicy::WaitRetry(Duration::from_millis(5)),
  }
}

async fn serve_connection(stream: TcpStream) {
  // ...
}

#[tokio::main]
async fn main() {
  let addr = //...
  # "127.0.0.1:12345";
  let mut listener = TcpListener::bind(addr).await.unwrap();
  let server = listener.incoming()
    .retry(handle_error) // Magic happens here
    .and_then(|(stream, _attempt)| {
      tokio::spawn(serve_connection(stream));
      ok(())
    })
    .try_for_each(|_| ok(()))
    .map_err(|(e, _attempt)| eprintln!("Caught an error {}", e));
  # // This nasty hack is required to exit immediately when running the doc tests.
  # let server = select(ok::<_, ()>(()), server).map(|_| ());
  server.await
}