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 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 // .await 对 call() 返回的 future 进行 poll
    {
        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 ...
    }
}

// 解决办法：捕获对象而非借用类型
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()?;   // ? 引起所在的 async block 返回
    consume(x);

   // Ok(()) // 错误，需要指定 Ok 所属的 Result 完整类型。
   Ok::<(), std::io::Error>(()) // 正确，指定 Ok 所属的 Result 类型
   // 或者
   // 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
        }))
    )

// 错误：不支持 &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
*/

let closure = || {
    async {
        vec.push(ready(String::from("")).await);
    }
};

let closure = || -> Future {
    // 返回的 Future 里面持有 &mut vec
}

let fut = closure();
// closure 调用已经结束了
// 但 fut 里面还想持有 &mut vec

let mut vec = vec![];

let closure = || {
    // 试图返回一个持有 &mut vec 的对象
    async {
        vec.push(String::new());
    }
};

let mut vec: Vec<String> = vec![];

let fut = async move {
    vec.push(ready(String::from("")).await);
};

use std::cell::RefCell;
  use std::future::ready;
  use std::rc::Rc;
  
  let vec = Rc::new(RefCell::new(Vec::<String>::new()));
  
  let closure = {
      let vec = Rc::clone(&vec);
  
      move || {
          let vec = Rc::clone(&vec);
  
          async move {
              let value = ready(String::from("")).await;
              vec.borrow_mut().push(value);
          }
      }
  };
  ```    

核心判断规则是：

1. async 里跨 .await 使用的东西，会变成 Future 状态的一部分。
2. 如果它是借用，借用就会被 Future 保存。
3. 如果这个 Future 是从 FnMut closure 返回的，那么对 closure 捕获变量的借用就“逃逸”了，所以不允许。

## 新的 async closure 语法

Rust 1.75+ 开始正式支持 `async closure`: 使用 `async || {}` 语法（而非 `|| async {}`）。

新的 `async closure` 带来了两个新的语义：
1. 支持 `&mut T` 捕获上下文对象（它修改了异步闭包场景下 `&mut T` 的语义）;
2. 支持 HRTB（编译器自动添加，但不能显式添加）；

这两个语义都是伴随着 `async closure` 新的 `AsyncFn/AsyncFnMut/AsyncFnOnce trait` 来实现的。

```rust
// OK：move 捕获
let string: String = "Hello, world".into();
let closure = async move || {
  // 闭包获得了 string 的所有权
  ready(&string).await;
};

|| -> impl Future<Output = ()> {
    async { ... }
}

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

let mut vec = Vec::new();

let closure = || async {
    vec.push(String::new());
};

trait FnMut<Args> {
    // 虽然 Rust 支持关联类型带 lifetime 标记，但是这里的 Output 没有带 lifetime 标记，所以它是编译器推导的固定
    // lifetime 类型。
    type Output;

    fn call_mut(&mut self, args: Args) -> Self::Output;
}

trait Fn<Args> {
    type Output;

    fn call(&self, args: Args) -> Self::Output;
}

// 错误：Fn 返回值不能包含借用
let s = String::from("hello");
let f = || -> &str {
    &s
};

// OK: async cloure 支持 &mut T 捕获上下文对象
let mut vec: Vec<String> = vec![];
// 注意返回的 closure 也必须是可变的。
let mut closure = async || {
    // async closure 使用 &'closure mut Vec<String> 方式捕获了上下文对象 vec，直到这个闭包被 drop（如被 .await)。
    vec.push(ready(String::from("")).await);
};
closure().await;

pub trait AsyncFnMut<Args>: AsyncFnOnce<Args> where Args: Tuple,{
    // 关联类型也可以带 lifetime 标记
    type CallRefFuture<'a>: Future<Output = Self::Output> where Self: 'a;

    // Required method
    extern "rust-call" fn async_call_mut(
        &mut self,
        args: Args,
    ) -> Self::CallRefFuture<'_>;
}

// OK, 异步闭包继续支持 move
let s = String::from("hello, world");
let c = async move || { do_something(&s).await };

let arg = async |x: i32| { async_add(x, 1).await };
let ret = async || -> Vec<Id> { async_iterator.collect().await };

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

// OK: 异步闭包支持 HRTB（自动添加）
let hr = async |x: &str| { do_something(x).await };


// 编译器为 hr 生成的匿名类型对象和实现的 AsyncFu trait 如下：
struct ClosureEnv;  
impl<'a> AsyncFn<(&'a str,)> for ClosureEnv {
    // 由于返回的对象包含 'a lifetime 标记，所以可以满足输入参数 x 的任意 lifetime。
    type CallRefFuture<'a>: Future<Output = Self::Output> where Self: 'a;

    extern "rust-call" fn async_call(
        &self,
        args:  (&'a str,),
    ) -> Self::CallRefFuture<'_>;
}

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

// 普通异步函数
async fn goto(unit: UnitRef, pos: i32) {
    UnitGotoFuture {
        unit,
        target_pos: pos,
    }
    .await;
}

goto(unit.clone(), 10).await;

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

// 等效为：一个返回类型为 impl Future 匿名具体类型的普通函数。
fn foo(x: Rc<i32>) -> impl std::future::Future<Output=i32> {
    
    // 编译器生成的一个具体的、匿名类型，其中 state 是跨 .await 的状态(对于复杂场景，如有多个 await 时，一般是 enum 类型，每
    // 个 enum variant 都包含一个实现 Future 的匿名类型)
    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 }, // 每个状态都持有一个 future 对象
    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 内部生成一个匿名关联类型：
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;
  |

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

// 示例：引入泛型类型 Fut，并对 Fut 进行限界：
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,
    //
    // 注意：这里的 Fut 是一个泛型参数，不支持 & 也没有 lifetime 标识，所以语义是：对任意生命周期 'c，f(&'c str) 都返回同一个 Fut 类型。
    F: FnMut(&str) -> Fut,
    Fut: Future<Output = ()>,
{
    for x in ["New York", "London", "Tokyo"] {
        f(x).await;
    }
}

// do_something2 概念上接近于：
//      fn do_something2<'c>(city_name: &'c str) -> impl Future<Output = ()> + 'c
// 注意返回的 Future 依赖 'c。也就是说它实际更像：
//      for<'c> Fn(&'c str) -> DoSomething2Future<'c>
// 而不是每次都返回同一个类型的 Fut：
//      for<'c> Fn(&'c str) -> Fut

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

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

// 区别在于：
// for_each_city() 的要求是：输入的闭包函数返回一个固定 Fut
//   for<'c> FnMut(&'c str) -> Fut
// 但是传入的 async fn do_something2() 返回类型是随输入参数变化的 'c 类型：
//   for<'c> FnMut(&'c str) -> Fut<'c>
// 
// Rust 里普通泛型参数 Fut 不能表达这种“返回类型族”。这就是报错里说的：
// expected opaque type `impl for<'c> Future<Output = ()>`
//    found opaque type `impl Future<Output = ()>`
//
// 更直白地说：
// do_something2(&'short str) 返回的 Future 可能借用了 'short 的参数；
// do_something2(&'long str) 返回的 Future 又借用了 'long 的参数。
// 它们不是一个生命周期无关的固定 Fut，而是一类不同 lifetime 的函数族。

/*
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`
*/

// 另一个例子 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>>;

// 把待返回的 Future 装箱到带有 lifetime 的 trait object 中：
use std::future::Future;
use std::pin::Pin;

async fn for_each_city<F>(mut f: F)
where
    F: FnMut(&str) -> Pin<Box<dyn Future<Output = ()> + '_>>,
    // 等效为：
    // F: for<'c> FnMut(&'c str) -> Pin<Box<dyn Future<Output = ()> + 'c>>,
    // 这样返回的 Pin<Box<dyn Future>> 对象的 lifetime 和输入参数一致，而不是如下所示的强迫所有 'c 都共用一个固定 Fut 类型。
    // F: FnMut(&str) -> Fut,
    // Fut: Future<Output=()>>
{
    for x in ["New York", "London", "Tokyo"] {
        f(x).await;
    }
}

// 等效于：fn do_something2(city_name: &'c str) -> impl Future<Output=()> + 'c
async fn do_something2(city_name: &str) {
    todo!()
}

async fn main() {
    for_each_city(|city| Box::pin(do_something2(city))).await;
}

// 另一个例子：
// 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 闭包输入包含借用时，需要返回 Pin<Box<...>> 类型
    F: FnOnce(&str) -> Pin<Box<dyn Future<Output = ()> + Send + '_>>;

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 `{closure@main.rs: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::async_trait]
trait Service {
    async fn call(&self, req: String) -> String;
}

// 大致变成：
trait Service {
    fn call<'async_trait>(
        &'async_trait self,
        req: String,
    ) -> Pin<Box<dyn Future<Output = String> + Send + 'async_trait>>;
}

// 在定义和实现 trait 时都需要添加 #[async_trait]
#[async_trait::async_trait]
impl Service for MyService {
    async fn call(&self, req: String) -> String {
        format!("hello {req}")
    }
}

// 大致变成：
impl Service for MyService {
    fn call<'async_trait>(
        &'async_trait self,
        req: String,
    ) -> Pin<Box<dyn Future<Output = String> + Send + 'async_trait>> {
        Box::pin(async move { // 使用 async move 的目的是让 'async_trait 为 'static，满足 tokio::spawn() 等函数签名要求。
            format!("hello {req}")
        })
    }
}