# Struct std::process::ExitCode

1.61.0 · source ·

    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()`), and intentionally does not provide accessors like `PartialEq`, `Eq`, or `Hash`. Instead 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`:

    use std::process::ExitCode;

    fn main() -> ExitCode {
        if !check_foo() {
            return ExitCode::from(42);
        }

        ExitCode::SUCCESS
    }

Run

## Implementations§

source§

### impl ExitCode

source

#### 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.

source

#### 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).

source

#### pub fn exit_process(self) -> !

🔬This is a nightly-only experimental API. (`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 `ExitCode`s 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()
    }

Run

## Trait Implementations§

source§

### impl Clone for ExitCode

source§

#### fn clone(&self) -> ExitCode

Returns a copy of the value. Read more
1.0.0 · source§

#### fn clone_from(&mut self, source: &Self)

Performs copy-assignment from `source`. Read more
source§

### impl Debug for ExitCode

source§

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more
1.75.0 · source§

### impl Default for ExitCode

The default value is `ExitCode::SUCCESS`

source§

#### fn default() -> Self

Returns the “default value” for a type. Read more
source§

### impl ExitCodeExt for ExitCode

Available on Windows only.
source§

#### fn from_raw(raw: u32) -> Self

🔬This is a nightly-only experimental API. (`windows_process_exit_code_from`)
Creates a new `ExitCode` from the raw underlying `u32` return value of a process. Read more
source§

### impl From<u8> for ExitCode

source§

#### fn from(code: u8) -> Self

Construct an `ExitCode` from an arbitrary u8 value.

source§

### impl Termination for ExitCode

source§

#### fn report(self) -> ExitCode

Is called to get the representation of the value as status code. This status code is returned to the operating system.
source§

### impl Copy for ExitCode

## Auto Trait Implementations§

§

### impl RefUnwindSafe for ExitCode

§

### impl Send for ExitCode

§

### impl Sync for ExitCode

§

### impl Unpin for ExitCode

§

### impl UnwindSafe for ExitCode

## Blanket Implementations§

source§

### impl<T> Any for Twhere T: 'static + ?Sized,

source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
source§

### impl<T> Borrow<T> for Twhere T: ?Sized,

source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

### impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

### impl<T> From<T> for T

source§

#### fn from(t: T) -> T

Returns the argument unchanged.

source§

### impl<T, U> Into<U> for Twhere U: From<T>,

source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

source§

### impl<T> ToOwned for Twhere T: Clone,

§

#### type Owned = T

The resulting type after obtaining ownership.
source§

#### fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

### impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

#### type Error = Infallible

The type returned in the event of a conversion error.
source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

### impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.