trait Future {
    type Output;

    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>> {
    // 可以使用 async block 来生成待返回的 impl Future 对象
    async move {
        Ok::<Result(usize)>(2)
    }
}

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

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),
    }
}

use std::io;
use std::future::Future;
fn cheapo_request<'a>(host: &'a str, port: u16, path: &'a str)
    -> impl Future<Output = io::Result<String>> + 'a
{
    // async move 也不能保证返回的 Future 对象一定是 'static 的
    // 特别是这里捕获的 host、path 本身是借用，而且不是 'static，
    // 所以返回的 Future 也是具有 'a 而非 'static
    async move {
        //... function body ...
    }
}

// 解决办法：捕获对象而非借用类型
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 ...
    }
}

// 下面是 OK 的：
use async_std::task;
let mut handles = vec![];
for (host, port, path) in requests {
    // 将 host、port、path 所有权转移到 async block 中
    handles.push(task::spawn(async move {
        cheapo_request(&host, port, &path).await
    }));
}

// https://doc.rust-lang.org/std/keyword.async.html#control-flow
async fn example() -> i32 {
    let x = async {
        return 5; // async block 提前返回，而不是所在的函数返回，返回返回值
    };

    x.await
}

//https://rust-lang.github.io/async-book/part-guide/more-async-await.html
async {
    let x = foo()?;   // This `?` only exits the async block, not the surrounding function.
    consume(x);

   // Ok(()) // 错误，需要指定 Ok 所属的 Result 完整类型，参考下面的例子

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

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
    }
}

let app = Router::new()
    .route(
        "/",
        any_service(service_fn(
            // 等效于生成一个 impl Fn() -> impl Future<Output=Result<Response, Infallible> 匿名类型对象
            |_: Request| async {
                let res = Response::new(Body::from("Hi from `GET /`"));
                Ok::<_, Infallible>(res) // service_fn 的闭包必须返回 Result
        }))
    )

// 错误：同步闭包不支持 HRTB
// 返回的 Combined 也是有 lifetime 的，但是它的 lifetime 和 a、b 之间约束缺少定义，所以编译器报错。
// 如果只是纯输入有借用，但是输出没有借用（或为 'static) 且闭包内部没有借用方式捕获上下文，则是 OK 的。
let mut closure = |a: &i32, b: &str|  {Combined { num: a, text: b }}

// 错误：不支持 &mut T 捕获上下文对象
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 block 的异步闭包不支持 &mut T 捕获上下文对象（&T 捕获 OK）
let vec: Vec<String> = vec![];
let closure = || async {
    vec.push(ready(String::from("")).await);
};

// OK: async cloure 支持 &mut T 捕获上下文对象
let vec: Vec<String> = vec![];
let closure = async || {
    // async closure 使用 &'closure mut Vec<String> 方式捕获了上下文对象 vec，直到这个闭包被 drop（如被 .await)。
    vec.push(ready(String::from("")).await);
};
// OK： move 捕获
let string: String = "Hello, world".into();
let closure = async move || {
    // 闭包获得了 string 的所有权
    ready(&string).await;
};

// 错误：同步闭包不支持 HRTB
let mut closure = |a: &i32, b: &str|  {Combined { num: a, text: b }}

// OK: 异步闭包支持自动添加 HRTB 和 move
let arg = async |x: i32| { async_add(x, 1).await };
let ret = async || -> Vec<Id> { async_iterator.collect().await };
let hr = async |x: &str| { do_something(x).await }; // 支持 HRTB
let s = String::from("hello, world");
let c = async move || { do_something(&s).await };

// https://www.eventhelix.com/rust/rust-to-assembly-async-await/

// Await this function until the unit has reached the target position.
async fn goto(unit: UnitRef, pos: i32) {
    UnitGotoFuture {
        unit,
        target_pos: pos,
    }
    .await;
}

goto(unit.clone(), 10).await;
// The code here will execute after the unit has reached position 10

async fn foo(x: &i32) -> i32 {
    *x
}

// 等价为：返回类型为 impl Future 隐藏具体类型。
fn foo(x: Rc<i32>) -> impl Future<Output=i32> {
    // 编译器生成的一个具体类型，其中 state 是跨 .await 的状态机
    struct FooFuture { x: Rc<i32>, state: bool };
    // 为具体类型实现 Future trait
    impl Future for FooFuture { /* poll 实现 */ }
    FooFuture { x, state: false }
}

// 另一个例子：如果函数的参数包含借用类型，则返回的实现 impl Future 的隐式类型对象也具有 lifetime。
async fn foo(x: &str) -> usize {
    let len = x.len();
    len
}
// 等价为：这里 foo 返回一个 匿名 Future 类型，生命周期 'a 来自参数 &'a str。
fn foo<'a>(x: &'a str) -> impl std::future::Future<Output = usize> + 'a {
    struct FooFuture<'b> {x: &'b str, state: bool };
    impl<'b> Future for FooFuture<'b> {/* pool 实现*/ }
    FooFuture{x, state: false} // FooFuture 的 lifetime 和 x 一致，都是 'a
}
// 后续调用 foo 返回的 fut 类型为：impl Future<Output = i32> + '_，推导的生命周期和 v 一致。
let fut = foo(&mut v);
// 错误：fut 不是 'static 类型，不满足 spawn() 参数的限界要求
tokio::spawn(fut).await?;

use tokio::io::{self, AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;

#[tokio::main]
async fn main() -> io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:6142").await?;
    loop {
        let (mut socket, _) = listener.accept().await?;
        tokio::spawn(async move { // 这里的 async block 返回的 impl Future 对象由编译器自动推导实现了 Send
            let mut buf = vec![0; 1024];

            loop {
                match socket.read(&mut buf).await {
                    Ok(0) => return,
                    Ok(n) => {
                        if socket.write_all(&buf[..n]).await.is_err() {
                            return;
                        }
                    }
                    Err(_) => {
                        return;
                    }
                }
            }
        });
    }
}

async fn foo(x: &mut i32) -> i32 {
    *x += 1;
    tokio::task::yield_now().await;   // 第一个 await
    *x *= 2;
    tokio::task::yield_now().await;   // 第二个 await
    *x + 3
}

// 去语法糖，返回 impl Future + '_
fn foo<'a>(x: &'a mut i32) -> impl std::future::Future<Output = i32> + 'a {
    async move {
        *x += 1;
        tokio::task::yield_now().await; // 第一个 await
        *x *= 2;
        tokio::task::yield_now().await; // 第二个 await
        *x + 3
    }
}
// 进一步去语法糖，编译器生成一个实现 Future 的匿名类型 FooFuture，内部的状态机保存 .await 点的 Future 状态
fn foo<'a>(x: &'a mut i32) -> impl std::future::Future<Output = i32> + 'a {
    FooFuture{x, state: State::Start{x}}
}

// 编译器为 async fn() { ... } 生成一个匿名类型，包含各 .await 状态机对象。
// 如果 async {} 通过 &T/&mut T 借用捕获了上下文对象，则生成的匿名类型是有 lifetime 标记的。
struct FooFuture<'a> {
    state: State<'a>,
}

// 编译器会为每个 .await 会生成一个状态枚举的分支。
enum State<'a> {
    // 枚举值的 field 包含跨 .await 的对象引用，所以在这些 .await 点间进行状态切换前，需要确保栈变量 x 的地址不变。
    // 所以 poll() 的 self 参数是 Pin<&mut Self> 类型，Pin 可以确保 Self 不被移动，进而确保这些栈变量地址有效。
    Start { x: &'a mut i32 },
    Awaiting1 { x: &'a mut i32, fut: tokio::task::YieldNow },
    Awaiting2 { x: &'a mut i32, fut: tokio::task::YieldNow },
    Done,
}

// Start：刚开始执行，捕获 &mut x。
// Awaiting1：第一个 await 处挂起，持有内部 future。
// Awaiting2：第二个 await 处挂起，持有内部 future。
// Done：完成状态。

// 为匿名类型实现 Future
use std::pin::Pin;
use std::task::{Context, Poll};

impl<'a> std::future::Future for FooFuture<'a> {
    type Output = i32;

    fn poll( mut self: Pin<&mut Self>, cx: &mut Context<'_> ) -> Poll<Self::Output> {
        unsafe {
            let me = self.get_unchecked_mut();
            loop {
                match &mut me.state {
                    // 进入第一个 await
                    State::Start { x } => {
                        *x += 1;
                        let fut = tokio::task::yield_now();
                        me.state = State::Awaiting1 { x: *x, fut };
                        return Poll::Pending;
                    }
                    State::Awaiting1 { x, fut } => {
                        // poll 内部 Future
                        match Pin::new(fut).poll(cx) {
                            Poll::Pending => return Poll::Pending,
                            Poll::Ready(()) => {
                                *x *= 2;
                                let fut = tokio::task::yield_now();
                                me.state = State::Awaiting2 { x: *x, fut };
                            }
                        }
                    }
                    State::Awaiting2 { x, fut } => {
                        match Pin::new(fut).poll(cx) {
                            Poll::Pending => return Poll::Pending,
                            Poll::Ready(()) => {
                                let result = *x + 3;
                                me.state = State::Done;
                                return Poll::Ready(result);
                            }
                        }
                    }
                    State::Done => panic!("polled after completion"),
                }
            }
        }
    }
}

// 执行流程示意
// Start：执行 *x += 1 → 创建第一个 future → 切换 Awaiting1 → Poll::Pending
// Awaiting1：poll 第一个 future，完成后执行 *x *= 2 → 创建第二个 future → 切换 Awaiting2 → Poll::Pending
// Awaiting2：poll 第二个 future，完成后计算 *x + 3 → 切换 Done → 返回结果
// Done：Future 已完成，再 poll 会 panic

trait MyTrait {
    async fn do_work(&self) -> i32;
}

// 编译器会将其内部处理为类似：
trait MyTrait {
    type DoWorkFuture<'a>: Future<Output = i32> + 'a
    where Self: 'a;

    fn do_work(&self) -> Self::DoWorkFuture<'_>;
}

warning: use of `async fn` in public traits is discouraged as auto trait bounds cannot be specified
 --> src/lib.rs:7:5
  |
7 |     async fn fetch(&self, url: Url) -> HtmlBody;
  |     ^^^^^
  |
help: you can desugar to a normal `fn` that returns `impl Future` and add any desired bounds such as `Send`, but these cannot be relaxed without a breaking API change
  |
7 -     async fn fetch(&self, url: Url) -> HtmlBody;
7 +     fn fetch(&self, url: Url) -> impl std::future::Future<Output = HtmlBody> + Send;
  |

// 示例 1：
// async fn fetch(&self, url: Url) -> HtmlBody;
fn fetch(&self, url: Url) -> impl std::future::Future<Output = HtmlBody> + Send; // impl Trait 无论是在函数输入还是输出位置都支持限界

// 示例 2：使用 Box::pin + dyn Future + Send 是 trait async fn 的常见做法。
use std::future::Future;

trait MyTrait {
    fn do_work(&self) -> Pin<Box<dyn Future<Output = i32> + Send + '_>>;
}

// 然后在实现里用 Box::pin(async move { ... }) 返回：
impl MyTrait for MyStruct {
    fn do_work(&self) -> Pin<Box<dyn Future<Output = i32> + Send + '_>> {
        Box::pin(async move {
            // 捕获的变量必须 Send
            42
        })
    }
}

use async_trait::async_trait;

#[async_trait]
trait MyTrait {
    async fn do_work(&self) -> i32;
}

struct MyStruct;

#[async_trait]
impl MyTrait for MyStruct {
    async fn do_work(&self) -> i32 {
        42
    }
}

#[trait_variant::make(HttpService: Send)]
pub trait LocalHttpService {
    async fn fetch(&self, url: Url) -> HtmlBody;
}

// This creates two versions of your trait: LocalHttpService for single-threaded
// executors and HttpService for multithreaded work-stealing executors

// 生成的 HttpService 版本：
pub trait HttpService: Send {
    fn fetch(
        &self,
        url: Url,
    ) -> impl Future<Output = HtmlBody> + Send;
}

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;
}

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


  // 示例：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,

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!()
}

async fn for_each_city<F, Fut>(mut f: F)
where
    // 错误：不支持 HRTB，这个 HRTB 是 Rust 为包含引用的限界自动添加的，等效于： F: for<'c> FnMut(&'c str) -> Fut,
    F: FnMut(&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
*/

use async_trait::async_trait;

// 在定义和实现 trait 时都需要添加 #[async_trait]
#[async_trait]
trait Advertisement {
    // 等效于：
    // fn run(&self) -> Pin<Box<dyn Future(Output=()) + Send + 'static>
    async fn run(&self);
}

// Advertisement 是 dyn-safe 的，支持 trait object，如 Vec<Box<dyn Advertisement + Sync>> 或 &[&dyn
// Advertisement]

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;
    }
}

// https://blog.rust-lang.org/inside-rust/2024/08/09/async-closures-call-for-testing/
fn async_callback<F>(callback: F)
where
    // F 闭包输入包含借用时，但返回的对象不包含借用，故 OK
    F: FnOnce(&str) -> Pin<Box<dyn Future<Output=()>>>; // 等效为：Pin<Box<dyn Future + 'static>>

async fn do_something(name: &str) {}

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


// Rust 1.75+ 异步闭包 AsyncFn** 限界直接支持 HRTB
// Instead of writing:
fn higher_ranked<F>(callback: F)
where
    F: Fn(&Arg) -> Pin<Box<dyn Future<Output = ()> + '_>>
{ todo!() }
// Write this:
fn higher_ranked<F: AsyncFn(&Arg)> { todo!() } // 自动生成 HRTB


async fn for_each_city<F>(mut f: F)
where
    F: AsyncFnMut(&str),
//     ...which is sugar for:
//  F: for<'a> AsyncFnMut(&'a str),
{
    for x in ["New York", "London", "Tokyo"] {
        f(x).await;
    }
}

async fn increment_city_population_db_query(city_name: &str) { todo!() }
async fn main() {
    // Works for `async fn` that is higher-ranked.
    for_each_city(increment_city_population_db_query).await;
}

// 原理类似于：（AsyncFn、AsyncFnMut 类似）
impl<F, Args, Fut, T> AsyncFnOnce<Args> for F
where
    F: FnOnce<A, Output = Fut>,
    Fut: Future<Output = T>,
{
    type Output = T;
    type CallOnceFuture = Fut;

    fn async_call_once(self, args: Args) -> Self::CallOnceFuture {
        FnOnce::call_once(self, args)
    }
}

// 以下类型自动实现了 AsyncFn*:
// Async functions:
async fn foo() {}

// Functions that return a concrete future type:
fn foo() -> Pin<Box<dyn Future<Output = ()>>> { Box::pin(async {}) }

// Closures that return an async block:
let c = || async {};

fn is_async_fn(_: impl AsyncFn(&str)) {}

async fn async_fn_item(s: &str) { todo!() }
is_async_fn(s);
// ^^^ This works.

fn generic(f: impl Fn() -> impl Future<Output = ()>) {
    is_async_fn(f);
    // ^^^ This does not work (yet).
}

// Instead of writing:
takes_async_callback(|arg| async {
    // Do things here...
});
// Write this:
takes_async_callback(async |arg| {
    // Do things here...
});


// 异步闭包限界
// Instead of writing:
fn doesnt_exactly_take_an_async_closure<F, Fut>(callback: F)
where
    F: FnOnce() -> Fut,
    Fut: Future<Output = String>
{ todo!() }
// Write this:
fn takes_an_async_closure<F: AsyncFnOnce() -> String>(callback: F) { todo!() }


// 异步闭包限界支持 HRTB
// Instead of writing:
fn higher_ranked<F>(callback: F)
where
    F: Fn(&Arg) -> Pin<Box<dyn Future<Output = ()> + '_>>
{ todo!() }

// Write this:
fn higher_ranked<F: AsyncFn(&Arg)> { todo!() }

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!() };

// async closure 支持 HRTB
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;
}

// 用于限界时支持 HRTB
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!() }