That’s a simple rust TCP echo server code:

use std::io::{BufReader, BufRead};

use std::io::Write;

use std::net::{TcpListener, TcpStream};

use std::env::{args, Args};


fn handle_client(mut stream_for_writing: TcpStream) -> () {
    let stream_for_reading = stream_for_writing.try_clone().unwrap();
    let mut buffer = String::new();
    let mut reader = BufReader::new(&stream_for_reading);

    reader.read_line(&mut buffer).expect("read fail");
    buffer = buffer.trim().to_string();

    let request = buffer.clone();
    
    writeln!(stream_for_writing, "{}", request).expect("response send fail");
}

fn handle_streams(listener: &TcpListener) {
    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                handle_client(stream);
            }

            Err(e) => {
                eprintln!("connecting fail, cause: {}", e);
            }
        }
    }
}

fn main() -> () {
    let arguments: Args = args();
    let arguments_string_vector: Vec<String> =  arguments.collect();
    let listener_ip_address: &String = arguments_string_vector.get(1).unwrap();
    let listener_port: &String = arguments_string_vector.get(2).unwrap();
    let listener_address = format!("{}:{}", listener_ip_address, listener_port);
    let listener_bind_error_message = format!("bind fail on {}", listener_address);
    let listener = TcpListener::bind(listener_address.clone())
        .expect(&listener_bind_error_message);
    handle_streams(&listener);
}

The question is, how to make it asynchronous, so it would be one-thread program, able to serve for a number of clients at the same time? It is also importaint, that it should not be reading other clients’ (not current) messageses (would not mash-up messages from different clients, confusing with the answer).