Crate tiny_bail

Tiny bailing convenience macros.

Bailing is an error-handling pattern that takes the middle path between unwrap and ?:

• Compared to unwrap: Bail will return, continue, or break instead of panicking.
• Compared to ?: Bail will log or quietly discard the error instead of propagating it.

The middle path avoids unwanted panics without the ergonomic challenges of propagating errors with ?.

This crate provides six macro variants:

• or_return!
• or_return_quiet!
• or_continue!
• or_continue_quiet!
• or_break!
• or_break_quiet!

Along with their tiny aliases: r!, rq!, c!, cq!, b!, and bq!.

The macros support Result, Option, and bool types out of the box. Implement IntoResult to extend this to other types.

Example

use tiny_bail::prelude::*;

// With `tiny_bail`:
fn increment_last(arr: &mut [i32]) {
    *r!(arr.last_mut()) += 1;
}

// Without `tiny_bail`:
fn increment_last_manually(arr: &mut [i32]) {
    if let Some(x) = arr.last_mut() {
        *x += 1;
    } else {
        println!("Bailed at src/example.rs:34:18: `arr.last_mut()`");
        return;
    }
}

Getting started

To use this crate, add it to your Cargo.toml:

cargo add tiny_bail

You can set features to customize the logging behavior on failure:

# Log with `println!` instead of `tracing::warn!`.
cargo add tiny_bail --no-default-features
# Log with `log::info!` instead of `tracing::warn!`.
cargo add tiny_bail --no-default-features --features log,info

This crate has zero dependencies other than the logging backend you choose (log, tracing, or nothing).

Modules

explicit

Re-exported macros.

prelude

Re-exported macros and tiny aliases.

Macros

or_break

Unwrap on success, or log the failure and break.

or_break_quiet

Unwrap on success, or quietly discard the failure and break.

or_continue

Unwrap on success, or log the failure and continue.

or_continue_quiet

Unwrap on success, or quietly discard the failure and continue.

or_return

Unwrap on success, or log the failure and return.

or_return_quiet

Unwrap on success, or quietly discard the failure and return.

Traits

IntoResult

A trait for types that can be separated into success and failure values.