https://www.reddit.com/r/rust/comments/9sbhp0/overflow_evaluating_the_requirement_while_using/

Cargo.toml

[package]
name = "foo"
version = "0.1.0"
authors = ["Wim Looman <wim@nemo157.com>"]
edition = "2018"

[[bin]]
name = "foo"
path = "main.rs"

[dependencies]
tokio = { version = "*", features = ["async-await-preview"] }
tokio-async-await = { version = "*", features = ["async-await-preview"] }
futures = { version = "0.1" }

main.rs

#![feature(async_await, await_macro, futures_api, try_trait)]

use std::sync::Arc;
use tokio::{self, io::{AsyncRead}, net::{TcpStream}, await};
use futures::Stream;
use tokio_async_await::stream::StreamExt;

struct VarInt(u32);

enum SbHandshakeMessage {
    Handshake {
        next_state: VarInt,
        proto_ver: VarInt,
        server_address: String,
        server_port: u32,
    }
}

struct Server;

impl Server {
    fn new() -> Server {
        Server
    }
}

#[derive(Debug)]
struct ParseError;

impl From<std::io::Error> for ParseError {
    fn from(_: std::io::Error) -> ParseError {
        ParseError
    }
}

macro_rules! warn {
    ($($tt:tt)*) => {eprintln!($($tt)*)}
}

async fn handle_clients() -> Result<(), ()> {
    let server = Arc::new(Server::new());

    let addr = "0.0.0.0:25565".parse().unwrap();
    let mut listener = tokio::net::TcpListener::bind(&addr).expect("failed to listen on address")
                    .incoming()
                    .map_err(|e| warn!("{}", e));
    while let Some(socket) = await!(listener.next()) {
        let server_arc = Arc::clone(&server);
        if let Ok(socket) = socket {
            tokio::spawn_async(async { await!(handle_client(socket, server_arc)); });
        }
    }
    Ok(())
}

async fn handle_client(socket: TcpStream, server: Arc<Server>) -> Result<(), ()> {
    let (mut socket_read, mut socket_write) = socket.split();
    let mut write_buffer = Vec::<u8>::new();

    let SbHandshakeMessage::Handshake { next_state, .. } = await!(receive_msg(&mut socket_read)).map_err(|e| warn!("{:?}", e))?;
    Ok(())
}

async fn receive_msg<R: AsyncRead>(mut reader: R) -> Result<SbHandshakeMessage, ParseError> {
    let mut buf = vec![0; 2];
    let res = await!(tokio::io::read_exact(&mut reader, &mut buf));
    match std::ops::Try::into_result(res) {
        Ok(ok) => ok,
        Err(err) => return std::ops::Try::from_error(From::from(err)),
    };
    Ok(SbHandshakeMessage::Handshake {
        next_state: VarInt(1),
        proto_ver: VarInt(404),
        server_address: "localhost".to_owned(),
        server_port: 25565,
    })
}

fn main() {
    tokio::run(handle_clients());
}