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 or continue instead of panicking.
• Compared to ?: Bail will log or ignore the error instead of propagating it.

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

This crate provides four macro variants: r!, rq!, c!, and cq!; along with their long-form aliases or_return!, or_return_quiet!, or_continue!, and or_continue_quiet!, respectively.

use tiny_bail::prelude::*;

/// Increment the last number of a list, or warn if it's empty.
fn increment_last(list: &mut [i32]) {
    // With `r!`:
    *r!(list.last_mut()) += 1;

    // Without `r!`:
    if let Some(x) = list.last_mut() {
        *x += 1;
    } else {
        println!("Bailed at src/example.rs:34:18: `list.last_mut()`");
        return;
    }
}

The macros support bool, Option, and Result types out-of-the-box. This can be extended by implementing the Success trait for other types.

You can specify a return value as an optional first argument to the macro, or omit it to default to Default::default()—which even works in functions with no return value.

Modules

• prelude
  Re-exported macros.

Macros

• c
  Unwrap or continue with a warning.
• cq
  Unwrap or continue quietly.
• or_continue
  The long-form alias of c!.
• or_continue_quiet
  The long-form alias of cq!.
• or_return
  The long-form alias of r!.
• or_return_quiet
  The long-form alias of rq!.
• r
  Unwrap or return with a warning.
• rq
  Unwrap or return quietly.

Traits

• Success
  An extension trait for extracting success from fallible types.