Useful messaging without broker ceremony.

use fibril_client::SubEvent;
use std::time::Duration;

while let SubEvent::Delivery(msg) = sub.recv().await {
    match send_email(msg.text()?).await {
        Ok(()) => msg.complete().await?,
        Err(err) if err.is_temporary() => {
            msg.retry_after(Duration::from_secs(30)).await?
        }
        Err(_) => msg.fail().await?,
    };
}

await foreach (var msg in sub.Deliveries())
{
    try
    {
        await SendEmailAsync(msg.Text());
    }
    catch (EmailException error)
    {
        if (error.IsTemporary)
            msg.RetryAfter(TimeSpan.FromSeconds(30));
        else
            msg.Fail();
        continue;
    }
    msg.Complete();
}

for msg := range sub.Deliveries {
    sendErr := sendEmail(msg.Text())
    var settleErr error
    switch {
    case sendErr == nil:
        settleErr = msg.Complete()
    case isTemporary(sendErr):
        settleErr = msg.RetryAfter(30 * time.Second)
    default:
        settleErr = msg.Fail()
    }
    if settleErr != nil {
        return settleErr
    }
}

for await (const msg of sub) {
  try {
    await sendEmail(msg.text());
  } catch (error) {
    if (isTemporary(error)) {
      await msg.retryAfter(30_000); // milliseconds
    } else {
      await msg.fail();
    }
    continue;
  }
  await msg.complete();
}

async for msg in sub:
    try:
        await send_email(msg.text())
    except TemporaryEmailError:
        await msg.retry_after(30)  # seconds
    except EmailError:
        await msg.fail()
    else:
        await msg.complete()