Enum Subsystem 

#[non_exhaustive]
pub enum Subsystem {
    Storage,
    Extract,
    Validate,
    Retrieve,
    Consolidate,
    Scope,
}

Coarse subsystem tag for a LunarisError — one classifying match, inside the crate that owns the enum.

Four places classified LunarisError by variant independently: the Prometheus kind label, the HTTP status map, and the Python and TypeScript SDK error codes. Every one ended in a wildcard arm — not by carelessness, but because LunarisError is #[non_exhaustive] and a downstream crate has no choice. So the compiler could never flag a new variant going unclassified, and when Scope was added all four silently began reporting it as unknown. Two of them carried a claim of totality: a comment reading “New variants in the future MUST extend this match”, and a test named error_kind_maps_every_lunaris_error_variant. Writing the instruction down did not make the next variant obey it.

#[non_exhaustive] does not apply inside the defining crate, so the match in LunarisError::subsystem is exhaustiveness-checked for real: adding a variant without tagging it fails to compile here. Consumers still write their wildcard, but they can now walk Subsystem::ALL to prove their own map is total — turning a silent “unknown” into a failing test.

let err = LunarisError::Scope(ScopeError::Invalid("bad:scope".into()));
assert_eq!(err.subsystem(), Subsystem::Scope);
assert_eq!(err.subsystem().label(), "scope");  // metrics / HTTP envelope
assert_eq!(err.subsystem().code(), "SCOPE");   // Python + TypeScript SDKs

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Storage

Extract

Validate

Retrieve

Consolidate

Scope

Implementations

impl Subsystem

pub const ALL: &'static [Subsystem]

Every subsystem, in declaration order. Generated from the same list as LunarisError::subsystem, so it cannot fall behind the enum the way a hand-written list does.

pub const fn label(self) -> &'static str

Lowercase tag — the Prometheus kind label and the error field of the server’s JSON envelope.

pub const fn code(self) -> &'static str

Uppercase tag — the code the Python and TypeScript SDKs put in front of the message so callers can branch without parsing.

pub fn sample_error(self) -> LunarisError

A representative error of this subsystem.

Exists so a consumer that maps LunarisError to something of its own — an HTTP status, an SDK code — can walk Self::ALL and feed its mapper a real value for every subsystem, instead of hand-listing the ones whoever wrote the test remembered. Every such mapper needs a wildcard arm it cannot delete, so this is the only way to prove the arm is unreachable.

Trait Implementations

impl Clone for Subsystem

fn clone(&self) -> Subsystem

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Subsystem

impl Debug for Subsystem

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

Formats the value using the given formatter.

impl Eq for Subsystem

impl Hash for Subsystem

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Subsystem

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Subsystem