std::panic - Rust
Description: API documentation for the Rust `panic` macro in crate `std`.
Keywords: rust, rustlang, rust-lang, panic

# 1.0.0[−][src]Macro std::panic

    macro_rules! panic {
        () => { ... };
        ($msg:expr) => { ... };
        ($msg:expr,) => { ... };
        ($fmt:expr, $($arg:tt)+) => { ... };
    }

Panics the current thread.

This allows a program to terminate immediately and provide feedback to the caller of the program. `panic!` should be used when a program reaches an unrecoverable state.

This macro is the perfect way to assert conditions in example code and in tests. `panic!` is closely tied with the `unwrap` method of both `Option` and `Result` enums. Both implementations call `panic!` when they are set to None or Err variants.

This macro is used to inject panic into a Rust thread, causing the thread to panic entirely. Each thread's panic can be reaped as the `Box<Any>` type, and the single-argument form of the `panic!` macro will be the value which is transmitted.

`Result` enum is often a better solution for recovering from errors than using the `panic!` macro. This macro should be used to avoid proceeding using incorrect values, such as from external sources. Detailed information about error handling is found in the book.

The multi-argument form of this macro panics with a string and has the `format!` syntax for building a string.

See also the macro `compile_error!`, for raising errors during compilation.

# Current implementation

If the main thread panics it will terminate all your threads and end your program with code `101`.

# Examples

    panic!();
    panic!("this is a terrible mistake!");
    panic!(4); // panic with the value of 4 to be collected elsewhere
    panic!("this is a {} {message}", "fancy", message = "message");

Run