trait Future {
    type Output;

    // For now, read `Pin<&mut Self>` as `&mut Self`.
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
}

enum Poll<T> {
    Ready(T),
    Pending,
}

fn read_to_string(&mut self, buf: &mut String) -> impl Future<Output = Result<usize>>;

// https://mazhen.tech/p/pinboxdyn-future%E8%A7%A3%E6%9E%90/

// 实现自己的 Future 类型
pub struct HttpRequest {
    url: String,
}
pub struct HttpResponse {
    code: u32,
}

pub struct ResponseFuture {
    request: HttpRequest,
}

impl Future for ResponseFuture {
    type Output = Result<HttpResponse, Error>;

    fn poll(self: Pin<&mut Self>, cx: &mut std::task::Context<'_>) -> Poll<Self::Output> {
        println!("process url:{}", &self.as_ref().get_ref().request.url);
        Poll::Ready(Ok(HttpResponse { code: 200 }))
    }
}

// 在实现 Service 时，关联类型 type Future 设置为我们手工实现的 Future：
struct RequestHandler;

impl Service<HttpRequest> for RequestHandler {
    type Response = HttpResponse;
    type Error = Error;
    type Future = ResponseFuture;

    fn poll_ready(&mut self, cx: &mut std::task::Context<'_>) -> Poll<Result<(), Self::Error>> {
        Poll::Ready(Ok(()))
    }

    fn call(&mut self, req: HttpRequest) -> Self::Future {
        ResponseFuture { request: req }
    }
}

// 然后就可以像正常的 Future 一样，使用 Service ：

#[tokio::main]
async fn main() {
    let mut service = RequestHandler {};
    match service
        .call(HttpRequest {
            url: "/user/mazhen".to_owned(),
        })
        .await
    {
        Ok(r) => println!("Response code: {}", r.code),
        Err(e) => println!("process failed. {:?}", e),
    }
}

// 异步函数
async fn example(x: &str) -> usize {
    x.len()
}
// 等效于
fn example<'a>(x: &'a str) -> impl Future<Output = usize> + 'a {
    async move { x.len() }
}

// 示例 2：
use async_std::io::prelude::*;
use async_std::net;

async fn cheapo_request(host: &str, port: u16, path: &str) -> std::io::Result<String>
{
    let mut socket = net::TcpStream::connect((host, port)).await?;
    let request = format!("GET {} HTTP/1.1\r\nHost: {}\r\n\r\n", path, host);
    socket.write_all(request.as_bytes()).await?;
    socket.shutdown(net::Shutdown::Write)?;
    let mut response = String::new();
    socket.read_to_string(&mut response).await?;
    Ok(response)
}

// response 类型是 impl Future<Output=std::io::Result<String>>
let response = cheapo_request(host, port, path);

pub trait Trait {
    async fn f(&self);
}

// 编译报错：error[E0038]: the trait `main::Trait` cannot be made into an object
pub fn make() -> Box<dyn Trait> {
    unimplemented!()
}

trait HealthCheck {
    async fn check(&mut self, server: &Server) -> bool;
}

fn start_health_check<H>(health_check: H, server: Server)
where
    H: HealthCheck + Send + 'static, // 这里只是对 H 自身进行了限定，并没有 H 的 方法的返回值进行限定
{
    tokio::spawn(async move {
        while health_check.check(&server).await {
            tokio::time::sleep(Duration::from_secs(1)).await;
        }
        emit_failure_log(&server).await;
    });
}

/*
error: future cannot be sent between threads safely
   --> src/main.rs:78:5
    |
78  | /     tokio::spawn(async move {
79  | |         while health_check.check().await {
80  | |             tokio::time::sleep(Duration::from_secs(1)).await;
...   |
83  | |     });
    | |______^ future created by async block is not `Send`
    |
    = help: within `{async block@src/main.rs:78:18: 78:28}`, the trait `Send` is not implemented for `impl Future<Output = bool>`
note: future is not `Send` as it awaits another future which is not `Send`
   --> src/main.rs:79:15
    |
79  |         while health_check.check().await {
    |               ^^^^^^^^^^^^^^^^^^^^ await occurs here on type `impl Future<Output = bool>`, which is not `Send`
note: required by a bound in `tokio::spawn`
   --> /Users/alizj/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tokio-1.47.1/src/task/spawn.rs:168:21
    |
166 |     pub fn spawn<F>(future: F) -> JoinHandle<F::Output>
    |            ----- required by a bound in this function
167 |     where
168 |         F: Future + Send + 'static,
    |                     ^^^^ required by this bound in `spawn`
help: `Send` can be made part of the associated future's guarantees for all implementations of `HealthCheck::check`
    |
71  -     async fn check(&mut self) -> bool;
71  +     fn check(&mut self) -> impl std::future::Future<Output = bool> + Send;
    |
*/

use async_trait::async_trait;

#[async_trait]
trait Advertisement {
    async fn run(&self);
}

struct Modal;

#[async_trait]
impl Advertisement for Modal {
    async fn run(&self) {
        self.render_fullscreen().await;
        for _ in 0..4u16 {
            remind_user_to_join_mailing_list().await;
        }
        self.hide_for_now().await;
    }
}
// 后续可以使用：Vec<Box<dyn Advertisement + Sync>> or &[&dyn Advertisement],

trait Service<Request> {
    type Response;
    type Error;

    // ERROR: `impl Trait` not allowed outside of function and inherent method return types
    fn call(&mut self, req: Request) -> impl Future<Output = Result<Self::Response, Self::Error>>;
}

pub trait Service<Request> {
    type Response;
    type Error;
    type Future: Future<Output = Result<Self::Response, Self::Error>>;

    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>;

    fn call(&mut self, req: Request) -> Self::Future;
}

use std::io;
use std::future::Future;

fn cheapo_request(host: &str, port: u16, path: &str) -> impl Future<Output = io::Result<String>> + 'static
{
    let host = host.to_string();
    let path = path.to_string();

    async move {
        // 捕获了 host、path 的所有权
        //... use &*host, port, and path ...
    }
}

let input = async_std::io::stdin();

// future 是 Future<Output=Result>
let future = async {
    let mut line = String::new();
    // ？ 是 async block 返回，结果类型 std::io::Result<usize>
    input.read_line(&mut line).await?;
    println!("Read line: {}", line);

    // Ok(()) // 错误

    // 正确，指定 Ok 所属的 Result 类型
    Ok::<(), std::io::Error>(())
    // 或者
    // std::result::Result::<(), std::io::Error>::Ok(());
};

use async_std::net;
use async_std::task;

// serve_one 是一个 impl Future<Output=()> 的匿名类型对象
let serve_one = async {
    // ? 是 async block 返回(而非 block 所在的函数），类型是 Result
    let listener = net::TcpListener::bind("localhost:8087").await?;
    let (mut socket, _addr) = listener.accept().await?;
};

pub async fn many_requests(requests: Vec<(String, u16, String)>) -> Vec<std::io::Result<String>>
{
    let mut handles = vec![];
    for (host, port, path) in requests {
        handles.push(
            task::spawn_local(
                // 使用 async move 来获取 host、path 的所有权。
                async move {
                    cheapo_request(&host, port, &path).await
                }
            ));
    }
    //...
}

loop {
    async move {
        break; // error[E0267]: `break` inside of an `async` block
    }
}

// 示例 1：
fn async_callback<F, Fut>(callback: F)
where
    F: FnOnce() -> Fut,
    Fut: Future<Output = String>;


// 示例 2：Fn trait bound 返回一个 Future 对象，该对象同时也需要是泛型参数，这样才能进一步限界
impl<F, Fut, Res, S> Handler<((),), S> for F
where
    // 闭包整体要实现 FnOnce() -> Fut、Clone、Send、Sync 和 'static
    F: FnOnce() -> Fut + Clone + Send + Sync + 'static,
    // 闭包的返回值需要实现 Future<Output = Res> 和 Send
    Fut: Future<Output = Res> + Send,
    Res: IntoResponse,

    let mut vec: Vec<String> = vec![];
    // closure 类型是：impl FnMut() -> impl Future<Output=()>
    let closure = || async {
        // error: captured variable cannot escape `FnMut` closure body
        vec.push(ready(String::from("")).await);
    };

      /*
      error: captured variable cannot escape `FnMut` closure body
      --> src/main.rs:69:22
      |
      68 |       let mut vec: Vec<String> = vec![];
      |           ------- variable defined here
      69 |       let closure = || async {
      |  ____________________-_^
      | |                    |
      | |                    inferred to be a `FnMut` closure
      70 | |         vec.push(ready(String::from("")).await);
      | |         --- variable captured here
      71 | |     };
      | |_____^ returns an `async` block that contains a reference to a captured variable, which then escapes the closure body
      |
      = note: `FnMut` closures only have access to their captured variables while they are executing...
      = note: ...therefore, they cannot allow references to captured variables to escape
      */

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error + Send + 'static>> {
    let mut vec: Vec<String> = vec!["a".to_string()];
    // closure 类型是： impl Fn() -> impl Future<Output=()> 类型
    let closure = || async {
        vec.iter().for_each(|i| println!("{i}"));
    };
    closure().await;
}

async fn for_each_city<F, Fut>(mut f: F)
where
    // 错误：不支持
    F: FnMut(&str) -> Fut,
    // 等价于: Rust 为包含引用参数的闭包函数限界自动添加 HRTB 注解
    // F: for<'c> FnMut(&'c str) -> Fut,

    Fut: Future<Output = ()>,
{
    for x in ["New York", "London", "Tokyo"] {
        f(x).await;
    }
}

async fn do_something2(city_name: &str) { todo!() }

async fn main() {
    for_each_city(do_something2).await;
}

/*
error[E0308]: mismatched types
 --> src/main.rs:101:5
  |
101 |     for_each_city(do_something2).await;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ one type is more general than the other
  |
  = note: expected opaque type `impl for<'c> Future<Output = ()>`
             found opaque type `impl Future<Output = ()>`
  = note: distinct uses of `impl Trait` result in different opaque types
note: the lifetime requirement is introduced here
 --> src/main.rs:89:34
  |
89  |     F: for<'c> FnMut(&'c str) -> Fut,
  |                                  ^^^

error: implementation of `FnMut` is not general enough
 --> src/main.rs:101:5
  |
86  | / async fn for_each_city<F, Fut>(mut f: F)
87  | | where
88  | |     // 错误：不支持
89  | |     F: for<'c> FnMut(&'c str) -> Fut,
  | |        ----------------------------- doesn't satisfy where-clause
90  | |     Fut: Future<Output = ()>,
  | |_____________________________- due to a where-clause on `for_each_city`...
...
101 |       for_each_city(do_something2).await;
  |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: ...`for<'a> fn(&'a str) -> impl Future<Output = ()> {do_something2}` must implement `FnMut<(&'c str,)>`
  = note: ...but it actually implements `FnMut<(&'0 str,)>`, for some specific lifetime `'0`

error: implementation of `FnMut` is not general enough
 --> src/main.rs:101:34
  |
86  | / async fn for_each_city<F, Fut>(mut f: F)
87  | | where
88  | |     // 错误：不支持
89  | |     F: for<'c> FnMut(&'c str) -> Fut,
  | |        ----------------------------- doesn't satisfy where-clause
90  | |     Fut: Future<Output = ()>,
  | |_____________________________- due to a where-clause on `for_each_city`...
...
101 |       for_each_city(do_something2).await;
  |                                    ^^^^^
  |
  = note: ...`for<'a> fn(&'a str) -> impl Future<Output = ()> {do_something2}` must implement `FnMut<(&'c str,)>`
  = note: ...but it actually implements `FnMut<(&'0 str,)>`, for some specific lifetime `'0`
*/

// 另一个例子 2：
async fn f1<Fut>(_: impl for<'a> Fn(&'a u8) -> Fut) where Fut: Future<Output = ()>, { todo!() }

async fn main() {
    async fn g(_: &u8) { todo!() }
    // error[E0308]: mismatched types
    // error: implementation of `Fn` is not general enough
    f1(g).await;
}

/*
error[E0308]: mismatched types
  --> src/main.rs:57:9
   |
57 |         f1(g).await;
   |         ^^^^^ one type is more general than the other
   |
   = note: expected opaque type `impl for<'a> Future<Output = ()>`
              found opaque type `impl Future<Output = ()>`
   = note: distinct uses of `impl Trait` result in different opaque types
note: the lifetime requirement is introduced here
  --> src/main.rs:44:48
   |
44 | async fn f1<Fut>(_: impl for<'a> Fn(&'a u8) -> Fut)
   |                                                ^^^

error: implementation of `Fn` is not general enough
  --> src/main.rs:57:9
   |
44 |   async fn f1<Fut>(_: impl for<'a> Fn(&'a u8) -> Fut)
   |   -                        ------------------------- doesn't satisfy where-clause
   |  _|
   | |
45 | | where
46 | |     Fut: Future<Output = ()>,
   | |_____________________________- due to a where-clause on `f1`...
...
57 |           f1(g).await;
   |           ^^^^^
   |
   = note: ...`for<'a> fn(&'a u8) -> impl Future<Output = ()> {main::g}` must implement `Fn<(&'a u8,)>`
   = note: ...but it actually implements `Fn<(&'0 u8,)>`, for some specific lifetime `'0`

error: implementation of `Fn` is not general enough
  --> src/main.rs:57:15
   |
44 |   async fn f1<Fut>(_: impl for<'a> Fn(&'a u8) -> Fut)
   |   -                        ------------------------- doesn't satisfy where-clause
   |  _|
   | |
45 | | where
46 | |     Fut: Future<Output = ()>,
   | |_____________________________- due to a where-clause on `f1`...
...
57 |           f1(g).await;
   |                 ^^^^^
   |
   = note: ...`for<'a> fn(&'a u8) -> impl Future<Output = ()> {main::g}` must implement `Fn<(&'a u8,)>`
   = note: ...but it actually implements `Fn<(&'0 u8,)>`, for some specific lifetime `'0`
*/

pub type BoxFuture<'a, T> = Pin<Box<dyn Future<Output = T> + Send + 'a>>;

// https://blog.rust-lang.org/inside-rust/2024/08/09/async-closures-call-for-testing/

fn async_callback<F, Fut>(callback: F)
where
    // F 闭包输入、输出没有借用，没有 HRTB 的问题，故可以返回 Future 对象
    F: FnOnce() -> Fut,
    Fut: Future<Output = String>;


fn async_callback<F>(callback: F)
where
    // F 闭包输入包含借用时，由于不支持 HRTB，故需要返回 Pin<Box<...>> 类型
    F: FnOnce(&str) -> Pin<Box<dyn Future<Output = ()>>>;

async fn do_something(name: &str) {}

// OK
async_callback(|name| Box::pin(async {
    do_something(name).await;
}));

// OK: 强制将返回的 Pin<Box<impl Future<Output=()>>> 转换为 Pin<Box<dyn Future<Output=()>>>
// 这里将 impl Future<Output=()> 转换为 dyn Future<Output=()> 是 type coerce 支持的。
let ac = |name| {
    let b: Pin<Box<dyn Future<Output=()>>> = Box::pin(async {
        do_something(name).await;
    });
    b
};
async_callback(ac);

// ERROR: 这是由于 ac 的类型是 impl Fn(&str) -> Pin<Box<impl Future<Output=()>>>, 与 F 的限界不匹配
let ac = |name| {
    Box::pin(async {
        do_something(name).await;
    })
};
async_callback(ac);

/*
error[E0271]: expected `{[email protected]:83:14}` to return `Pin<Box<dyn Future<Output = ()>>>`, but it returns `Pin<Box<{async block@src/main.rs:84:18: 84:23}>>`
  --> src/main.rs:84:9
   |
83 |       let ac = |name| {
   |                ------ this closure
84 | /         Box::pin(async {
85 | |             do_something(name).await;
86 | |         })
   | |__________^ expected `Pin<Box<dyn Future<Output = ()>>>`, found `Pin<Box<{async block@src/main.rs:84:18: 84:23}>>`
87 |       };
88 |       async_callback(ac);
   |       -------------- -- closure used here
   |       |
   |       required by a bound introduced by this call
   |
   = note: expected struct `Pin<Box<(dyn Future<Output = ()> + 'static)>>`
              found struct `Pin<Box<{async block@src/main.rs:84:18: 84:23}>>`
note: required by a bound in `async_callback`
  --> src/main.rs:62:24
   |
60 | fn async_callback<F>(callback: F)
   |    -------------- required by a bound in this function
61 | where
62 |     F: FnOnce(&str) -> Pin<Box<dyn Future<Output = ()>>>,
   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `async_callback`

For more information about this error, try `rustc --explain E0271`.
error: could not compile `my-demo` (bin "my-demo") due to 1 previous error
*/

fn async_callback<F>(callback: F)
where
    F: FnOnce(&str) -> Box<dyn Future<Output = ()>>,
{
    callback("hello there!");
}

async fn do_something(name: &str) {}

fn main() {
    async_callback(|name| {
        Box::new(async {
            do_something(name).await;
        })
    });
}

/*
error: lifetime may not live long enough
  --> src/main.rs:71:9
   |
70 |       async_callback(|name| {
   |                       ----- return type of closure is Box<(dyn Future<Output = ()> + '2)>
   |                       |
   |                       has type `&'1 str`
71 | /         Box::new(async {
72 | |             do_something(name).await;
73 | |         })
   | |__________^ returning this value requires that `'1` must outlive `'2`
*/

fn async_callback<F>(callback: F)
where
    F: FnOnce(&str) -> Box<dyn Future<Output = ()>>,
{
}

async fn do_something(name: &str) {}

fn main() {
    let ac = |name| {
        let a = async {
            do_something(name).await;
        };
        let b: Box<dyn Future<Output = ()>> = Box::new(a);
        b
    };
    async_callback(ac);

/*
error[E0373]: async block may outlive the current function, but it borrows `name`, which is owned by the current function
  --> src/main.rs:76:17
   |
76 |         let a = async {
   |                 ^^^^^ may outlive borrowed value `name`
77 |             do_something(name).await;
   |                          ---- `name` is borrowed here
   |
note: async block is returned here
  --> src/main.rs:80:9
   |
80 |         b
   |         ^
help: to force the async block to take ownership of `name` (and any other referenced variables), use the `move` keyword
   |
76 |         let a = async move {
   |                       ++++
*/
}

fn async_callback<F>(callback: F)
where
    // 这里的 F 输入参数包含借用，所以实际是隐式的 HRTB 限界
    F: FnOnce(&str) -> Box<dyn Future<Output = ()>>,
{
    callback("just for test");
}

async fn do_something(name: &str) {}

fn main() {
    let ac = |name| {
        let a = async move {
            do_something(name).await;
        };
        let b: Box<dyn Future<Output = ()>> = Box::new(a);
        b
    };
    // 但是 ac 的类型是：impl fn(&'2 str) -> Box<dyn Future<Output = ()>> 类型，
    // 而不是限界的 FnOnce(&str) -> Box<dyn Future<Output = ()>> 类型
    async_callback(ac);
}

/*
error: implementation of `FnOnce` is not general enough
  --> src/main.rs:80:9
   |
80 |         b
   |         ^ implementation of `FnOnce` is not general enough
   |
   = note: closure with signature `fn(&'2 str) -> Box<dyn Future<Output = ()>>` must implement `FnOnce<(&'1 str,)>`, for any lifetime `'1`...
   = note: ...but it actually implements `FnOnce<(&'2 str,)>`, for some specific lifetime `'2`

error: implementation of `FnOnce` is not general enough
  --> src/main.rs:82:5
   |
82 |     async_callback(ac);
   |     ^^^^^^^^^^^^^^^^^^ implementation of `FnOnce` is not general enough
   |
   = note: closure with signature `fn(&'2 str) -> Box<dyn Future<Output = ()>>` must implement `FnOnce<(&'1 str,)>`, for any lifetime `'1`...
   = note: ...but it actually implements `FnOnce<(&'2 str,)>`, for some specific lifetime `'2`
*/

let s = String::from("hello, world");
// Implements `AsyncFn()` along with `FnMut` and `Fn`
// because it can copy the `&String` that it captures.
let _ = async || {
    println!("{s}");
};

let s = String::from("hello, world");
// Implements `AsyncFn()` but not `FnMut` or `Fn` because
// it moves and owns a value of type `String`, and therefore
// the future it returns needs to take a pointer to data
// owned by the closure.
let _ = async move || {
    println!("{s}");
};

let mut s = String::from("hello, world");
// Implements `AsyncFnMut()` but not `FnMut` or `Fn`
// because it needs to reborrow a mutable pointer to `s`.
let _ = async move || {
    s.push('!');
};


// https://rust-lang.github.io/rfcs/3668-async-closures.html#interaction-with-return-type-notation-naming-the-future-returned-by-calling
let s = String::from("hello, world");

let closure = async move || {
    ready(&s);
};
// At this point, `s` is moved out of.  However, the
// allocation for `s` is still live.  It just lives as a
// captured field in `closure`.

// Manually call `AsyncFnOnce` -- this isn't stable since
// `AsyncFnOnce` isn't stable, but it's useful for the demo.
let fut = AsyncFnOnce::call_once(closure, ());
// At this point, `closure` is dropped.  However, the
// allocation for `s` is still live.  It now lives as a
// captured field in `fut`.

fut.await;
// After the future is awaited, it's dropped.  At that
// point, the allocation for `s` is dropped.



// They can have arguments annotated with types:
let _ = async |_: u8| { todo!() };

// They can have their return types annotated:
let _ = async || -> u8 { todo!() };

// They can be higher-ranked:
let _ = async |_: &str| { todo!() };

// They can capture values by move:
let x = String::from("hello, world");
let _ = async move || do_something(&x).await };

takes_an_async_fn(async |s| { other_fn(s).await }).await;

// AsyncFn{,Once,Mut} 可以用于返回值、泛型参数限界
// 也就是：The AsyncFn* trait can be used anywhere a Fn* trait bound is allowed
//
/// In return-position impl trait:
fn closure() -> impl AsyncFn() { async || {} }

/// In trait bounds:
trait Foo<F>: Sized where F: AsyncFn()
{
    fn new(f: F) -> Self;
}

/// in GATs:
trait Gat {
    type AsyncHasher<T>: AsyncFn(T) -> i32;
}

async fn takes_an_async_fn(f: impl AsyncFn(&str)) {
    futures::join(f("hello"), f("world")).await;
}

// 作为限界：
// 老的写法，不建议：闭包和返回值分别限界：
fn doesnt_exactly_take_an_async_closure<F, Fut>(callback: F)
where
    F: FnOnce() -> Fut,
    Fut: Future<Output = String>
{ todo!() }

// 建议: 新的写法
fn takes_an_async_closure<F: AsyncFnOnce() -> String>(callback: F) { todo!() }

// https://rust-lang.github.io/rfcs/3668-async-closures.html#interaction-with-return-type-notation-naming-the-future-returned-by-calling

/// An async-aware version of the [`FnOnce`](crate::ops::FnOnce) trait.
///
/// All `async fn` and functions returning futures implement this trait.
pub trait AsyncFnOnce<Args> {
    /// Future returned by [`AsyncFnOnce::async_call_once`].
    type CallOnceFuture: Future<Output = Self::Output>;

    /// Output type of the called closure's future.
    type Output;

    /// Call the [`AsyncFnOnce`], returning a future which may move out of the called closure.
    fn async_call_once(self, args: Args) -> Self::CallOnceFuture;
}

/// An async-aware version of the [`FnMut`](crate::ops::FnMut) trait.
///
/// All `async fn` and functions returning futures implement this trait.
pub trait AsyncFnMut<Args>: AsyncFnOnce<Args> {
    /// Future returned by [`AsyncFnMut::async_call_mut`] and [`AsyncFn::async_call`].
    type CallRefFuture<'a>: Future<Output = Self::Output>
    where
        Self: 'a;

    /// Call the [`AsyncFnMut`], returning a future which may borrow from the called closure.
    fn async_call_mut(&mut self, args: Args) -> Self::CallRefFuture<'_>;
}

/// An async-aware version of the [`Fn`](crate::ops::Fn) trait.
///
/// All `async fn` and functions returning futures implement this trait.
pub trait AsyncFn<Args>: AsyncFnMut<Args> {
    /// Call the [`AsyncFn`], returning a future which may borrow from the called closure.
    fn async_call(&self, args: Args) -> Self::CallRefFuture<'_>;
}

// 老的写法 OK：
fn foo<F, T>()
where
    F: FnOnce() -> T,
    F::Output: Send, //~ OK，Output 为 FnOnce 的关联类型
    // 等效于
    //T: Send
{
}
// 或者：
fn async_callback<F, Fut>(callback: F)
where
    F: FnOnce() -> Fut,
    Fut: Future<Output = String> + Send + 'static
{ todo!() }


// 新的写法不行：
fn foo<F, T>()
where
    F: async FnOnce() -> T,
    F::Output: Send,
    //~^ ERROR use of unstable library feature
    F::CallOnceFuture: Send,
    //~^ ERROR use of unstable library feature
{
}

// 这是由于：x 的返回值是 Future<Output=Result<()> 类型，而不是 spawn() 要求的 Future<Output=Result<()>> + Send + 'static 类型：
async fn foo(x: impl AsyncFn(&str)) -> Result<()> {
    tokio::spawn(x("hello, world")).await
}

/*
error[E0277]: cannot be sent between threads safely
   --> src/lib.rs
    |
    |     tokio::spawn(x("hello, world")).await
    |     ------------ ^^^^^^^^^^^^^^^^^ cannot be sent between threads safely
    |     |
    |     required by a bound introduced by this call

*/

// https://smallcultfollowing.com/babysteps/blog/2023/02/01/async-trait-send-bounds-part-1-intro/#fnref:1
trait HealthCheck {
    async fn check(&mut self, server: &Server) -> bool;
}

fn start_health_check<H>(health_check: H, server: Server)
where
    H: HealthCheck + Send + 'static,
{
    tokio::spawn(async move {
        while health_check.check(&server).await {
            tokio::time::sleep(Duration::from_secs(1)).await;
        }
        emit_failure_log(&server).await;
    });
}

/*
error: future cannot be sent between threads safely
   --> src/lib.rs:15:18
    |
15  |       tokio::spawn(async move {
    |  __________________^
16  | |         while health_check.check(&server).await {
17  | |             tokio::time::sleep(Duration::from_secs(1)).await;
18  | |         }
19  | |         emit_failure_log(&server).await;
20  | |     });
    | |_____^ future created by async block is not `Send`
    |
    = help: within `[async block@src/lib.rs:15:18: 20:6]`, the trait `Send` is not implemented for `impl Future<Output = bool>`
*/

/*
note: future is not `Send` as it awaits another future which is not `Send`
   --> src/lib.rs:16:15
    |
16  |         while health_check.check(&server).await {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^ await occurs here
*/

trait HealthCheck {
    // async fn check(&mut self, server: &Server) -> bool;
    fn check(&mut self, server: &Server) -> impl Future<Output = bool>;
                                           // ^ Problem is here! This returns a future, but not necessarily a `Send` future.
}

impl<Ptr> Unpin for Pin<Ptr>
where
    Ptr: Unpin,

// https://github.com/rust-lang/rfcs/blob/master/text/3654-return-type-notation.md
trait Service<Request> {
    type Response;

    // Invoke the service.
    async fn call(&self, req: Request) -> Self::Response;
}

// 下面的 LogService call() 方法只能在 thread-per-core or single-threaded executor 中使用，而不能在多线程 executor 中使用。
pub struct LogService<S>(S);
impl<S, R> Service<R> for LogService<S>
where
    S: Service<R>,
    R: Debug,
{
    type Response = S::Response;

    async fn call(&self, request: R) -> S::Response {
        eprintln!("{request:?}");
        self.0.call(request).await
    }
}

// 多线程中使用报错：
async fn spawn_call<S>(service: S) -> S::Response
where
    S: Service<(), Response: Send> + Send + 'static,
{
    tokio::spawn(async move {
        service.call(()).await // <--- Error
    }).await
}


/*
error: future cannot be sent between threads safely
   --> src/lib.rs:6:5
    |
6   | /     tokio::spawn(async move {
7   | |         service.call(()).await // <--- Error
8   | |     }).await.unwrap()
    | |______^ future created by async block is not `Send`
    |
    = help: within `{async block@src/lib.rs:6:18: 8:6}`, the trait `Send` is not implemented for `impl Future<Output = <S as Service<()>>::Response>`, which is required by `{async block@src/lib.rs:6:18: 8:6}: Send`
note: future is not `Send` as it awaits another future which is not `Send`
   --> src/lib.rs:7:9
    |
7   |         service.call(()).await // <--- Error
    |         ^^^^^^^^^^^^^^^^ await occurs here on type `impl Future<Output = <S as Service<()>>::Response>`, which is not `Send`
*/

// 解决办法：修改 call() 方法的返回值，返回一个 Send 类型对象
trait SendService<Request>: Send {
    type Response;

    // Invoke the service.
    fn call(
        &self,
        req: Request,
    ) -> impl Future<Output = Self::Response> + Send;
    // 具体实现可能是返回一个 Pin<Box<dyn Future + Send>> 类型对象
}

// https://smallcultfollowing.com/babysteps/blog/2023/02/13/return-type-notation-send-bounds-part-2/
fn start_health_check<H>(health_check: H, server: Server)
where
    H: HealthCheck + Send + 'static,
    H::check(..): Send, // <— return type notation

// Here the where clause H::check(..): Send means “the type(s) returned when you call H::check must
// be Send. Since async functions return a future, this means that future must implement Send.

// 完整例子：
#![feature(return_type_notation)]
#![allow(dead_code)]

use std::time::Duration;

struct Server;

trait HealthCheck {
    async fn check(&mut self, server: &Server) -> bool;
}

fn start_health_check<H>(mut health_check: H, server: Server)
where
    H: HealthCheck + Send + 'static,
    H::check(..): Send + 'static, // 加 'static 也 OK
{
    tokio::spawn(async move {
        while health_check.check(&server).await {
            tokio::time::sleep(Duration::from_secs(1)).await;
        }
        emit_failure_log(&server).await;
    });
}

async fn emit_failure_log(_server: &Server) { }

// 注意：下面的 method 需要被替换为 Trait 实际的方法名称，例如上面的 check(...)
fn foo<T, U>()
where
    // Associated type bound
    T: Trait<method(..): Send + 'static>,
    // Path bound
    U: Trait,
    U::method(..): Send + 'static,
{}

trait Trait {
    // In GAT bounds.
    type Item: Trait<method(..): Send + 'static>;
}

// In opaque item bounds too.
fn rpit() -> impl Foo<method(..): Send + 'static>;

// https://rust-lang.github.io/rfcs/3668-async-closures.html#interaction-with-return-type-notation-naming-the-future-returned-by-calling
async fn foo(x: F) -> Result<()>
where
    F: AsyncFn(&str) -> Result<()>,
    // The future from calling `F` is `Send` and `'static`.
    F(..): Send + 'static,
    // Which expands to two bounds:
    // `for<'a> <F as AsyncFnMut>::CallRefFuture<'a>: Send`
    // `<F as AsyncFnOnce>::CallOnceFuture: Send`
    // the latter is only if `F` is bounded with `async Fn` or `async FnMut`.
{
    tokio::spawn(x("hello, world")).await
}

// https://github.com/rust-lang/rust/pull/138424#issuecomment-2766836658
#![feature(return_type_notation)]
trait Trait {
    async fn foo() {}
}

trait Other {}
impl<T> Other for T
where
    T: Trait,
    T::foo(..): Send,
{}
impl Other for u32 {}

// https://github.com/rust-lang/rust/pull/138424#issuecomment-2766947426
#![feature(return_type_notation)]
trait Trait {
    fn foo() -> impl Sized;
}

trait Id {
    type This: ?Sized;
}
impl<T: ?Sized> Id for T {
    type This = T;
}

trait GetOpaque {
    type Opaque: ?Sized;
}
impl<T: ?Sized, U> GetOpaque for T
where
    T: Trait,
    T::foo(..): Id<This = U>,
{
    type Opaque = U;
}
type FooTypePos<T> = <T as GetOpaque>::Opaque;

impl Trait for u8 {
    fn foo() -> impl Sized {
        || ()
    }
}
struct ContainsOpaque(FooTypePos<u8>);

// 另一个例子：https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=9691749c3f46ed13e459ee1d6382f7e8
#![feature(return_type_notation)]

async fn spawn_call<S>(service: S) -> S::Response
where
    S: Service<(), Response: Send, call(..): Send> + Send + 'static,
{
    tokio::spawn(async move {
        service.call(()).await
    }).await.unwrap()
}

trait Service<Request> {
    type Response;

    // Invoke the service.
    async fn call(&self, req: Request) -> Self::Response;
}


// 另一个例子：https://play.rust-lang.org/?version=nightly&mode=debug&edition=2021&gist=6d45f55355188001ea6499314ce30b4b
#![feature(return_type_notation)]

trait Factory {
    fn widgets(&self) -> impl Iterator<Item = Widget>;
}

struct ReverseWidgets<F: Factory<widgets(..): DoubleEndedIterator>> {
    factory: F,
}

impl<F> Factory for ReverseWidgets<F>
where
    F: Factory<widgets(..): DoubleEndedIterator>,
{
    fn widgets(&self) -> impl Iterator<Item = Widget> {
        self.factory.widgets().rev()
        //                     👆 requires that the iterator be double-ended
    }
}

struct Widget;