Asynchronous 为什么我会得到；受特质约束的未来并不满足；使用.await或“join！”之类的宏时？

我正在开发一个异步Rust程序，但是

加入宏不工作<代码>等待

也不起作用。我的问题在哪里

我在书中看到了一些例子

这也不起作用：

#[async_std::main]
async fn main() {}

我没有使用Tokio或Hyper，因为它是一个简单的程序

use async_std::task;
use futures::executor::block_on;
use futures::join;
use futures::stream::{FuturesUnordered, StreamExt};
use rand::distributions::{Distribution, Uniform};
use std::thread;
use std::time::{Duration, Instant};

fn main() {
    let start = "bename Allah";
    println!("{}", start);

    fn fibonacci(n: u64) -> u64 {
        if n <= 1 {
            return 1;
        } else {
            return fibonacci(n - 1) + fibonacci(n - 2);
        }
    }

    fn fib(n: u64) {
        println!("Its : {}", fibonacci(n));
    }

    async fn calculate() {
        let do1 = fib(45);
        let do2 = fib(20);

        join!(do1, do2);
    }

    calculate();
    //i used block_on(calculate()) but got same error :(
}

我得到这个错误：

error[E0277]：特性绑定“（）：core:：future:：future:：future`不满足
-->src\main.rs:28:15
|
28 |加入！（do1，do2）；
|^^^特性'core:：future:：future:：future'未为`（）`
| 
：：C:\Users\Mahdi\.cargo\registry\src\github.com-1ecc6299db9ec823\futures-util-0.3.4\src\future\maybe\u done.rs:42:24
|
42 | pub fn maybe_done（未来：未来）->MaybeDone{
|----“futures\u util:：future:：maybe\u done:：maybe\u done”中的此绑定需要`

您的问题可以归结为：

fn alpha() {}

async fn example() {
    alpha().await;
}

error[E0277]：未满足特性绑定“（）：std:：future:：future”
-->src/lib.rs:4:5
|
4 | alpha（）.等待；
|^^^^^^^^^^^^^^^^^^^未为`（）`

您正在尝试等待未实现

未来的
。
alpha
的返回类型为
（）
。您可能打算使函数
异步
：

async fn alpha() {}
//^^^

async fn example() {
    alpha().await;
}

另见：







值得指出的是，计算斐波那契数并不适合异步工作。另请参见：



谢普马斯特说得太对了！
我找到了一个新的解决方案来正确执行此操作：

use std::thread;
fn main() {
let start = "bename Allah";
println!("{}", start);

fn fibonacci(n: u64) -> u64 {
    if n <= 1 {
        return 1;
    } else {
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}

fn fib(n: u64) {
    println!("Its : {}", fibonacci(n));
}

fn calculate() {
    let do1 = thread::spawn (move || {
        fib(45);
    });
    let do2 = thread::spawn (move || {
        fib(20);
    });
    do1.join();
    do2.join();
}

calculate();

}

使用std:：thread；
fn main（）{
让我们开始吧；
println！（“{}”，开始）；
fn斐波那契（n:u64）->u64{
如果n非常感谢！！！我来自Kotlin Coroutine structures，rust async对我来说太难看了：），rust async结构与其他语言有很多不同。但是谢谢你的帮助！
use std::thread;
fn main() {
let start = "bename Allah";
println!("{}", start);

fn fibonacci(n: u64) -> u64 {
    if n <= 1 {
        return 1;
    } else {
        return fibonacci(n - 1) + fibonacci(n - 2);
    }
}

fn fib(n: u64) {
    println!("Its : {}", fibonacci(n));
}

fn calculate() {
    let do1 = thread::spawn (move || {
        fib(45);
    });
    let do2 = thread::spawn (move || {
        fib(20);
    });
    do1.join();
    do2.join();
}

calculate();

}