async_closure

这个crate利用nightly-only功能async_fn_in_trait来模仿async_closures。

这次你不必在异步代码中将局部闭包返回的Future装箱！

使用这个crate的步骤

1. 选择一个用于特质边界的异步特质

   • 当确定没有临时引用类型被捕获时（即所有捕获的类型满足'static约束），在capture_no_lifetimes模块中使用特质。
   • 否则，在capture_lifetimes模块中使用特质。

   // e.g. take a closure that potentially captures references and will change its states.
   
   // 0. import the `AsyncFnMut` trait and companion macro `async_closure_mut`
   #![feature(async_fn_in_trait)]
   #![allow(incomplete_features)]
   use async_closure::{capture_lifetimes::AsyncFnMut, async_closure_mut};
   
   // 1. Adjust your caller where the trait bound looks like the following
   async fn take_a_mut_closure<'env, T, F>(mut cb: F) -> T
   where
       // 'env means the lifetime of captured variables outside the function
       // 'any means the lifetime of arguments coming from inside the function
       // also note how we express and represent one argument via `(arg1, )`,
       // likewise we can declare more arguments via `(arg1, arg2, arg3, )` etc.
       F: for<'any> AsyncFnMut<'env, (&'any str,), Output = T>,
   {
       let mut s = String::from("-");
       let args = (&s[..],); // type inference doesn't work well here
       cb.call_mut(args).await;
   
       s.push('+');
       let args = (&s[..],);
       cb.call_mut(args).await
   }
   

2. 使用其伴随宏来自动生成一个值，其类型是独特且未命名的，但实现了该特质。宏的语法包含两部分

   • 对于capture_lifetimes风格的宏

     1. 一个代码块{}，其中声明了多个通过,分隔的赋值语句field_name: field_type = field_value
     2. 一个异步闭包async |arg1: arg1_type, ...| -> return_type { /* 任何异步代码 */ }

     注意：AsyncFn*系列只包含单个生命周期参数'a，并且你必须在field_type和return_type中使用它来表示非静态引用类型。但如果那里的类型不包含引用，'a就不再需要。

   let (outer, mut buf, buffer) = (String::new(), String::new(), String::new());
   
   // 2. Define a capturing closure
   let cb1 = async_closure_mut!({
       s: &'a str = &outer,            // shared reference
       buf: &'a mut String = &mut buf, // mutable reference
       arc: Arc<str> = buffer.into(),  // owned type without explicit mutation
       len: usize = 0,                 // owned type with mutation, see the code below
   }; async |arg: &str| -> Result<usize, ()> 
      // Annotate both inputs and output: no lifetime parameter on arguments' type!
   {
       // Write async code here, using the field names and argument names as variables.
       // Note: the type of fields here depends on `AsyncFn*`.
       // i.e. for this macro, all field comes from `let Self { pattern_match } = &mut self;`
       // thus `s: &mut &'a str`, `buf: &mut &'a mut String` etc.
       // If you use `async_closure!`, then `s: &&'a str`, `buf: &&'a mut String` etc.
       // If you use `async_closure_once!`, then `s: &'a str`, `buf: &'a mut String` etc.
   
       Ok(*len)
   });
   

   • 对于非 capture_lifetimes 风格的宏，组件相同，除了
     • 你不能使用'a
       • 即field_type和return_type不能是临时引用类型

3. 将值传递给调用函数

   take_a_mut_closure(cb1).await.unwrap(); // That's it :)
   

async fn take_and_return_a_mut_closure<'env, T, F>(mut cb: F) -> (T, F)
where
    F: for<'any> AsyncFnMut<'env, (&'any str,), Output = T>,
{
    let s = String::from("-");
    (cb.call_mut((&s[..],)).await, cb) // Note: return the closure type
}

async fn test4() {
    let mut buf = String::new();
    let cb = async_closure_mut!({
        buf: &'a mut String = &mut buf
    }; async |arg: &str| -> () {
        buf.push_str(arg);
    });
    let (_output, cb_again) = take_and_return_a_mut_closure(cb).await;

    cb_again.buf.push('+'); // Still use it
    assert_eq!(cb_again.buf, "-+");
    
    take_a_mut_closure(cb_again).await; // And pass it into another function
    // Note: since AsyncFnMut is the subtrait to AsyncFnOnce,
    //       you can pass it into a fucntion that requires AsyncFnOnce
    //       as long as they have identical generic parameters.
}