异步编程

#[neon::export]
async fn fetch_data(url: String) -> Result {
    let response = reqwest::get(&url).await?;
    let body = response.text().await?;
    Ok(body)
}

const { fetchData } = require('./native');

async function main() {
    const data = await fetchData('https://api.example.com/data');
    console.log(data);
}

use neon::prelude::*;

struct ComputeTask {
    input: i32,
}

impl Task for ComputeTask {
    type Output = i32;
    type Error = String;
    type JsEvent = JsNumber;

    fn perform(&self) -> Result {
        // 在后台线程执行
        Ok(self.input * 2)
    }

    fn complete(self, mut cx: TaskContext, result: Result) -> JsResult {
        match result {
            Ok(val) => Ok(cx.number(val as f64)),
            Err(e) => cx.throw_error(e),
        }
    }
}

fn compute_async(mut cx: FunctionContext) -> JsResult {
    let input = cx.argument::(0)?.value(&mut cx) as i32;
    let task = ComputeTask { input };
    
    let promise = task.schedule(&mut cx)?;
    Ok(promise)
}

use neon::prelude::*;

fn create_promise(mut cx: FunctionContext) -> JsResult {
    let (deferred, promise) = cx.promise();
    
    // 可以在其他线程 resolve
    let channel = cx.channel();
    thread::spawn(move || {
        let result = expensive_computation();
        
        channel.send(move |mut cx| {
            let value = cx.string(result);
            deferred.resolve(&mut cx, value);
            Ok(())
        });
    });
    
    Ok(promise)
}