Enum ExitReason 

pub enum ExitReason {
    Normal,
    Shutdown,
    ShutdownReason(String),
    Killed,
    Error(String),
}

The reason a process exited.

Exit reasons determine how linked processes and supervisors respond to process termination.

Normal vs Abnormal Exits

• Normal exits (ExitReason::Normal, ExitReason::Shutdown, ExitReason::ShutdownReason): Do not trigger restarts for Transient children in supervisors. Links with trap_exit = false do not propagate.

• Abnormal exits (ExitReason::Killed, ExitReason::Error): Trigger restarts and propagate through links.

Examples

use starlang_core::ExitReason;

let reason = ExitReason::Normal;
assert!(reason.is_normal());

let reason = ExitReason::Error("connection lost".to_string());
assert!(!reason.is_normal());

Variants

Normal

Process completed successfully.

This is the standard exit reason when a process finishes its work without errors.

Shutdown

Process was asked to shut down.

Used when a supervisor or other controller requests graceful termination.

ShutdownReason(String)

Process was asked to shut down with a specific reason.

Similar to Shutdown but includes additional context.

Killed

Process was forcefully terminated.

Used with Process::exit(pid, ExitReason::Killed) for unconditional termination that cannot be trapped.

Error(String)

Process terminated due to an error.

This is an abnormal exit that will trigger supervisor restarts and propagate through links.

Implementations

impl ExitReason

pub fn is_normal(&self) -> bool

Returns true if this is a normal exit reason.

Normal exits include Normal, Shutdown, and ShutdownReason. These do not trigger supervisor restarts for Transient children.

Examples

use starlang_core::ExitReason;

assert!(ExitReason::Normal.is_normal());
assert!(ExitReason::Shutdown.is_normal());
assert!(ExitReason::ShutdownReason("done".into()).is_normal());
assert!(!ExitReason::Killed.is_normal());
assert!(!ExitReason::Error("oops".into()).is_normal());

pub fn is_abnormal(&self) -> bool

Returns true if this is an abnormal exit reason.

Abnormal exits include Killed and Error. These trigger supervisor restarts and propagate through links to non-trapping processes.

pub fn is_killed(&self) -> bool

Returns true if this is the Killed variant.

The Killed reason is special: it cannot be trapped and always terminates the target process.

pub fn error(msg: impl Display) -> ExitReason

Creates an error exit reason from any displayable type.

Examples

use starlang_core::ExitReason;

let reason = ExitReason::error("something went wrong");
assert_eq!(reason, ExitReason::Error("something went wrong".to_string()));

pub fn shutdown(msg: impl Display) -> ExitReason

Creates a shutdown exit reason with a message.

Examples

use starlang_core::ExitReason;

let reason = ExitReason::shutdown("maintenance");
assert!(reason.is_normal());

Trait Implementations

impl Clone for ExitReason

fn clone(&self) -> ExitReason

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ExitReason

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

Formats the value using the given formatter.

impl Default for ExitReason

fn default() -> ExitReason

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ExitReason

fn deserialize<__D>( __deserializer: __D, ) -> Result<ExitReason, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ExitReason

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

Formats the value using the given formatter.

impl Eq for ExitReason

impl From<&str> for ExitReason

fn from(s: &str) -> ExitReason

Converts to this type from the input type.

impl From<String> for ExitReason

fn from(s: String) -> ExitReason

Converts to this type from the input type.

impl PartialEq for ExitReason

fn eq(&self, other: &ExitReason) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ExitReason

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ExitReason