async fn greet() -> String {
    String::from("hello")
}

// 等价于
fn greet() -> impl std::future::Future<Output = String> {
    async { String::from("hello") }
}

async fn fetch_data() -> String {
    // 模拟异步操作
    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
    String::from("data")
}

#[tokio::main]
async fn main() {
    let data = fetch_data().await;
    println!("{}", data);
}

trait Future {
    type Output;
    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>;
}

enum Poll<T> {
    Ready(T),    // 完成
    Pending,     // 未完成，稍后再试
}

use tokio::time::{sleep, Duration};

async fn task(id: u32) -> String {
    sleep(Duration::from_millis(100)).await;
    format!("任务 {} 完成", id)
}

#[tokio::main]
async fn main() {
    // 串行
    let r1 = task(1).await;
    let r2 = task(2).await;

    // 并发
    let (r1, r2) = tokio::join!(task(1), task(2));

    // 动态并发
    let mut handles = vec![];
    for i in 0..5 {
        handles.push(tokio::spawn(task(i)));
    }
    for handle in handles {
        let result = handle.await.unwrap();
        println!("{}", result);
    }
}

#[tokio::main]
async fn main() {
    let future = async {
        println!("执行中...");
        42
    };

    let result = future.await;
    println!("结果: {}", result);
}

#[tokio::main]
async fn main() {
    let handle = tokio::spawn(async {
        // 后台任务
        "result"
    });

    // 做其他事情...

    let result = handle.await.unwrap();
    println!("{}", result);
}

use tokio::time::{sleep, Duration};

async fn fetch_user(id: u32) -> String {
    sleep(Duration::from_millis(100)).await;
    format!("User-{}", id)
}

#[tokio::main]
async fn main() {
    let users: Vec<String> = (1..=5)
        .map(|id| fetch_user(id))
        .collect::<Vec<_>>()
        .await
        .into_iter()
        .collect();

    println!("{:?}", users);
}

async fn foo() -> i32 { 42 }

#[tokio::main]
async fn main() {
    let f = foo();      // 这是 Future，不是值
    let v = foo().await; // ✅ 这才是 i32
}

// ❌ 不能在同步函数中 .await
// fn main() {
//     foo().await;
// }

// ✅ 需要异步运行时
#[tokio::main]
async fn main() {
    foo().await;
}