// TODO: Implement the `fixed_reply` function. It should accept two `TcpListener` instances,
// accept connections on both of them concurrently, and always reply clients by sending
// the `Display` representation of the `reply` argument as a response.
use std::fmt::Display;
use tokio::io::AsyncWriteExt;
use tokio::net::TcpListener;

pub async fn fixed_reply<T>(first: TcpListener, second: TcpListener, reply: T)
where
 // `T` cannot be cloned. How do you share it between the two server tasks?
 T: Display + Send + Sync + 'static,
{
 todo!()
}

use std::sync::Arc;

pub async fn fixed_reply<T>(first: TcpListener, second: TcpListener, reply: T)
where
 // `T` cannot be cloned. How do you share it between the two server tasks?
 T: Display + Send + Sync + 'static,
{
 let reply = Arc::new(reply);
 let reply2 = Arc::clone(&reply);
 tokio::spawn(listen(first, reply));
 tokio::spawn(listen(second, reply2));
}

async fn listen<T>(listener: TcpListener, reply: Arc<T>)
where
 T: Display + Send + Sync + 'static,
{
 loop {
 let (mut socket, _) = listener.accept().await.unwrap();
 let reply = Arc::clone(&reply);

 tokio::spawn(async move {
 let reply = reply.to_string();
 socket.write_all(reply.as_bytes()).await.unwrap();
 socket.flush().await.unwrap();
 });
 }
}

//! TODO: get the code to compile by **re-ordering** the statements
//! in the `example` function. You're not allowed to change the
//! `spawner` function nor what each line does in `example`.
//! You can wrap existing statements in blocks `{}` if needed.
use std::rc::Rc;
use tokio::task::yield_now;

fn spawner() {
 tokio::spawn(example());
}

async fn example() {
 let non_send = Rc::new(1);
 yield_now().await;
 println!("{}", non_send);
}

async fn example() {
 {
 let non_send = Rc::new(1);
 println!("{}", non_send);
 }
 yield_now().await;
}

async fn xxx(...) -> T {
 // ...
}

fn xxx(...) -> impl Future<Output = T> {
 // ...
}