Async Programming

// Async function returns Future<T>
async fn fetch_user(id: String) -> Result<User, HttpError> {
    let response = await http::get("https://api.example.com/users/{id}")
    let user: User = await response.json()
    Ok(user)
}

fn main() {
    // Await the async function
    let user = await fetch_user("123")
    print("Found user: {user.name}")
}

async fn fetch_dashboard_data() -> Dashboard {
    // Run all three requests in parallel
    let (user, posts, notifications) = await parallel(
        fetch_user(),
        fetch_posts(),
        fetch_notifications()
    )

    Dashboard { user, posts, notifications }
}

// Parallel with a list of futures
async fn fetch_all_users(ids: List<String>) -> List<User> {
    let futures = ids.map(id => fetch_user(id))
    await parallel(futures)
}

async fn process_order(order_id: String) -> Result<Receipt, Error> {
    // Step 1: Validate the order
    let order = await fetch_order(order_id)?

    // Step 2: Check inventory (depends on order)
    let inventory = await check_inventory(order.items)?

    // Step 3: Process payment (depends on order)
    let payment = await charge_payment(order.total)?

    // Step 4: Create shipment (depends on all above)
    let shipment = await create_shipment(order, inventory)?

    Ok(Receipt { order, payment, shipment })
}

async fn fetch_with_timeout(url: String) -> Result<Response, Error> {
    match await timeout(Duration::seconds(5), http::get(url)) {
        Ok(response) => Ok(response),
        Err(TimeoutError) => Err(Error::new("Request timed out"))
    }
}

// Retry with exponential backoff
async fn fetch_with_retry(url: String, max_retries: i64) -> Result<Response, Error> {
    var delay = Duration::ms(100)

    for attempt in 1..=max_retries {
        match await fetch_with_timeout(url.clone()) {
            Ok(response) => return Ok(response),
            Err(e) if attempt < max_retries => {
                print("Attempt {attempt} failed, retrying...")
                await sleep(delay)
                delay = delay * 2  // Exponential backoff
            },
            Err(e) => return Err(e)
        }
    }
}

async fn fetch_fastest(urls: List<String>) -> Response {
    let futures = urls.map(url => http::get(url))
    await select(futures)  // Returns first to complete
}

// Race between operation and timeout
async fn with_deadline<T>(
    deadline: Duration,
    operation: Future<T>
) -> Result<T, TimeoutError> {
    await select {
        result = operation => Ok(result),
        _ = sleep(deadline) => Err(TimeoutError)
    }
}

actor DataFetcher {
    var cache: Map<String, Data> = {}

    // Async receive handler
    async receive Fetch(key: String) -> Data {
        // Check cache first
        if let Some(cached) = cache.get(key) {
            return cached
        }

        // Fetch from remote
        let data = await http::get("https://api.example.com/data/{key}")
        let parsed: Data = await data.json()

        // Cache the result
        cache.insert(key, parsed.clone())

        parsed
    }

    async receive FetchMany(keys: List<String>) -> List<Data> {
        // Fetch all in parallel
        let futures = keys.map(key => ask(self, Fetch(key)))
        await parallel(futures)
    }
}

// Async iterator
async fn process_events(stream: EventStream) {
    // Process each event as it arrives
    for await event in stream {
        match event {
            Event::Message(msg) => handle_message(msg),
            Event::Error(e) => handle_error(e),
            Event::Close => break
        }
    }
}

// Transform a stream
async fn transform_stream(input: Stream<RawData>) -> Stream<Processed> {
    input
        .filter(data => data.is_valid())
        .map(async data => {
            await process(data)
        })
}