Rust异步编程(5)-问号使用、send的trait、递归

问号

1. 问号使用

use futures;
async fn foo() -> Result<(),String>{
    Ok(())
}

async fn func()->Result<(),String>{
    let fut = async{
        foo().await?;
        Ok(())
    };
    fut.await
}

fn main() {
    let _ = futures::executor::block_on(func());
}

2. send的trait

1. 如果所有的子类型都是实现Send trait的，那么它本身也是实现Send trait的;否则未实现，下方代码无法编译通过：

use std::rc::Rc;
#[derive(Default)]
struct NoSend(Rc<()>);
async fn bar() {}
async fn foo() {
    let x = NoSend::default();  //x未实现Send trait，则无法在线程之间传递，不安全，因此无法编译
    bar().await;
}
fn required_send(_: impl Send) {}
fn main() {
    required_send(foo());
}

2. 如果要在async方法中使用未实现Send trait的变量，则需要在变量外层加上代码块标记：

#[derive(Default)]
struct NoSend(Rc<()>);
async fn bar(){

}
async fn foo(){
    {
        let x = NoSend::default();
    }
    bar().await;
}

3. 递归

1. 正常递归执行的问题

use futures;


//非递归
async fn first(){}
async fn second() {}

async fn foo(){
    first().await;
    second().await;
}

//上面代码编译后生成的代码：
////-------------
//enum Foo{
//	First(first),
//	Second(second),
//}
//

//enum FooState {
//	F1_Pending,
//	F1_Ready,
//	F2_Pending,
//	F2_Ready,
//  Ready
//}
//struct Foo {
//	f1: Foo::First,
//	f2: Foo::Second,
//	state: FooState, 
//}
////--------------

//递归
async fn re() {
    re().await;
    re().await;
}

//上面方法递归编译后内容，无限循环的结构体，导致无法确定大小，因此编译失败
//enum Re {
//	First(Re),
//	Second(Re),
//}
//
//struct Re {
//	f1: Ree::First,
//	f2: Ree::Second,
//	//state,
//}

fn main() {
    futures::executor::block_on(foo());
    futures::executor::block_on(re());
}

2. 解决方法
   使用BoxFuture，装载递归方法，可以避免死循环
   加入到box中，编译出的结构体，不会无限死循环，固定大小

use futures::future::{BoxFuture, FutureExt};

fn re() -> BoxFuture<'static, ()> {
    async move{
        re().await;
        re().await;
    }.boxed()
}

fn main() {
    re();
    println!("Hello, world!");
}