Enum Value 

pub enum Value<T, B: BoundaryKind = GenericBoundary> {
    Interior(T),
    Boundary {
        reason: B,
        last: T,
    },
}

The core type. Interior or Boundary. One distinction. Every domain.

Variants

Interior(T)

Interior: the value is in safe territory.

Boundary

Boundary: the value crossed the edge. Carries the reason and last known value.

Fields

reason: B

last: T

Implementations

impl<T, B: BoundaryKind> Value<T, B>

pub fn interior(value: T) -> Self

Construct an interior value.

pub fn boundary(reason: B, last: T) -> Self

Construct a boundary value with a reason and last known value.

pub fn is_interior(&self) -> bool

pub fn is_boundary(&self) -> bool

pub fn or(self, fallback: T) -> T

Unwrap the interior value, or return a fallback.

pub fn unwrap(self) -> T

Unwrap the interior value, or panic.

pub fn map<U>(self, f: impl FnOnce(T) -> U) -> Value<U, B>

Map over the interior value. Boundaries propagate unchanged.

pub fn propagate(self) -> Result<T, B>

Extract the interior value, or return the boundary reason as Err for ? propagation. The residual is not carried through propagation — match explicitly to access it.

pub fn trace(self, chain: &mut Chain, label: &'static str) -> Result<T, B>

where T: Debug,

Extract the interior value while recording the step in a trace. If boundary, records the residual in the chain and returns the reason. If interior, records the value and continues.

pub fn and_then<U: Default>( self, f: impl FnOnce(T) -> Value<U, B>, ) -> Value<U, B>

Chain operations that may themselves hit a boundary. Requires U: Default so a boundary can carry a last value when types change.

Trait Implementations

impl<T: Debug, B: Debug + BoundaryKind> Debug for Value<T, B>

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

Formats the value using the given formatter.