     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51

    /// Exits a function early with an `Error`.
    ///
    /// The `bail!` macro provides an easy way to exit a function. `bail!(X)` is
    /// equivalent to writing:
    ///
    /// ```rust,ignore
    /// return Err(format_err!(X))
    /// ```
    #[macro_export]
    macro_rules! bail {
        ($e:expr) => {
            return Err($crate::err_msg($e));
        };
        ($fmt:expr, $($arg:tt)+) => {
            return Err($crate::err_msg(format!($fmt, $($arg)+)));
        };
    }

    /// Exits a function early with an `Error` if the condition is not satisfied.
    ///
    /// Similar to `assert!`, `ensure!` takes a condition and exits the function
    /// if the condition fails. Unlike `assert!`, `ensure!` returns an `Error`,
    /// it does not panic.
    #[macro_export]
    macro_rules! ensure {
        ($cond:expr, $e:expr) => {
            if !($cond) {
                bail!($e);
            }
        };
        ($cond:expr, $fmt:expr, $($arg:tt)+) => {
            if !($cond) {
                bail!($fmt, $($arg)+);
            }
        };
    }

    /// Constructs an `Error` using the standard string interpolation syntax.
    ///
    /// ```rust
    /// #[macro_use] extern crate failure;
    ///
    /// fn main() {
    ///     let code = 101;
    ///     let err = format_err!("Error code: {}", code);
    /// }
    /// ```
    #[macro_export]
    macro_rules! format_err {
        ($($arg:tt)*) => { $crate::err_msg(format!($($arg)*)) }
    }

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)