Struct Loss 

pub struct Loss(/* private fields */);

The markdown-projection loss class of an island: a description of how faithfully the projection carries it, for a consumer to surface (a caller warned that a form field silently dropped a table). It is not a switch: crate::export::to_markdown dispatches on Island::island_type, never on this.

Open on Island::island_type’s terms: the wire string is the stored value, and Fidelity is the closed view over it. A class this build lacks is carried verbatim, so a reader that merely opens a document does not move its content hash (DOCUMENT_STORAGE.md § Byte-stability).

One value per wire string, so the encoding is injective: a built-in’s name spells that built-in and nothing else, and the reserved-name rule the payload-carrying axes need (Invariant::ReservedUnknownTag and its two siblings) has nothing to guard here.

Read fidelity through Loss::fidelity, never by comparing against Loss::LOSSLESS: an uninterpretable class degrades to Fidelity::Unrepresentable, so nothing is claimed to carry faithfully on the strength of a name this build cannot read.

Implementations

impl Loss

pub const LOSSLESS: Loss

Markdown carries it faithfully (round-trips identically).

pub const DEGRADED: Loss

Markdown carries an approximation (round-trips visibly, not identically).

pub const UNREPRESENTABLE: Loss

No markdown encoding: what an island type with no projection carries.

pub fn new(class: &str) -> Loss

Wrap a wire class. Every string is a class, uninterpretable ones included; Loss::fidelity is where that is resolved.

An interpretable class borrows its 'static spelling, so decoding an island allocates only for the uninterpretable. Equality is by name either way, so Loss::new("lossless") == Loss::LOSSLESS.

pub fn as_str(&self) -> &str

The wire discriminator, and the canonical-form bytes.

pub fn fidelity(&self) -> Fidelity

The fidelity this class describes, with an uninterpretable class degraded to the safe end.

Carrying the raw class preserves the byte round-trip. Reading it through here keeps that carriage from being mistaken for a claim about the projection.

Trait Implementations

impl Clone for Loss

fn clone(&self) -> Loss

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Loss

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

Formats the value using the given formatter.

impl Eq for Loss

impl PartialEq for Loss

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Loss