pub struct ExitCode(/* private fields */);Expand description
This type represents the status code the current process can return to its parent under normal termination.
ExitCode is intended to be consumed only by the standard library (via
Termination::report()). For forwards compatibility with potentially
unusual targets, this type currently does not provide Eq, Hash, or
access to the raw value. This type does provide PartialEq for
comparison, but note that there may potentially be multiple failure
codes, some of which will not compare equal to ExitCode::FAILURE.
The standard library provides the canonical SUCCESS and FAILURE
exit codes as well as From<u8> for ExitCode for constructing other
arbitrary exit codes.
§Portability
Numeric values used in this type don’t have portable meanings, and different platforms may mask different amounts of them.
For the platform’s canonical successful and unsuccessful codes, see
the SUCCESS and FAILURE associated items.
§Differences from ExitStatus
ExitCode is intended for terminating the currently running process, via
the Termination trait, in contrast to ExitStatus, which represents the
termination of a child process. These APIs are separate due to platform
compatibility differences and their expected usage; it is not generally
possible to exactly reproduce an ExitStatus from a child for the current
process after the fact.
§Examples
ExitCode can be returned from the main function of a crate, as it implements
Termination:
Implementations§
1.61.0 · Source§impl ExitCode
impl ExitCode
1.61.0 · Sourcepub const SUCCESS: ExitCode
pub const SUCCESS: ExitCode
The canonical ExitCode for successful termination on this platform.
Note that a ()-returning main implicitly results in a successful
termination, so there’s no need to return this from main unless
you’re also returning other possible codes.
1.61.0 · Sourcepub const FAILURE: ExitCode
pub const FAILURE: ExitCode
The canonical ExitCode for unsuccessful termination on this platform.
If you’re only returning this and SUCCESS from main, consider
instead returning Err(_) and Ok(()) respectively, which will
return the same codes (but will also eprintln! the error).
Sourcepub fn exit_process(self) -> !
🔬This is a nightly-only experimental API. (exitcode_exit_method #97100)
pub fn exit_process(self) -> !
exitcode_exit_method #97100)Exit the current process with the given ExitCode.
Note that this has the same caveats as process::exit(), namely that this function
terminates the process immediately, so no destructors on the current stack or any other
thread’s stack will be run. If a clean shutdown is needed, it is recommended to simply
return this ExitCode from the main function, as demonstrated in the type
documentation.
§Differences from process::exit()
process::exit() accepts any i32 value as the exit code for the process; however, there
are platforms that only use a subset of that value (see process::exit platform-specific
behavior). ExitCode exists because of this; only
ExitCodes that are supported by a majority of our platforms can be created, so those
problems don’t exist (as much) with this method.
§Examples
#![feature(exitcode_exit_method)]
// there's no way to gracefully recover from an UhOhError, so we just
// print a message and exit
fn handle_unrecoverable_error(err: UhOhError) -> ! {
eprintln!("UH OH! {err}");
let code = match err {
UhOhError::GenericProblem => ExitCode::FAILURE,
UhOhError::Specific => ExitCode::from(3),
UhOhError::WithCode { exit_code, .. } => exit_code,
};
code.exit_process()
}Trait Implementations§
1.75.0 · Source§impl Default for ExitCode
The default value is ExitCode::SUCCESS
impl Default for ExitCode
The default value is ExitCode::SUCCESS