Crate guts

Traits for constructing/destructuring from/into a type’s internal guts.

Example

mod state_machine {
    use guts::{Guts, FromGutsUnchecked};

    /// A State machine's internal state.
    pub enum State {
        Off,
        On,
    }

    /// A State machine that hides its internal state.
    pub struct StateMachine {
        state: State,
    }

    impl Default for StateMachine {
        /// Creates a state machine in the only allowed initial state: `Off`.
        fn default() -> Self {
            Self { state: State::Off }
        }
    }

    impl Guts for StateMachine {
        type Guts = State;
    }

    impl FromGutsUnchecked for StateMachine {
        /// Creates a state machine in an arbitrary state, unsafely.
        unsafe fn from_guts_unchecked(guts: Self::Guts) -> Self {
            Self { state: guts }
        }
    }
}

use guts::FromGutsUnchecked;
use state_machine::{State, StateMachine};

// A machine can easily be safely created in its initial state:
let machine = StateMachine::default();

// To create a machine in a non-initial state `unsafe { … }` is required:
let machine = unsafe { StateMachine::from_guts_unchecked(State::On) };

Traits

FromGuts

Safely constructing values from their guts.

FromGutsUnchecked

Unsafely constructing values from their guts without checking invariants.

Guts

Safely access a value’s guts.

GutsMut

Safely mutably access a value’s guts.

HasGuts

The base trait of FromGuts and IntoGuts, its more useful companions.

IntoGuts

Safely destructuring values into their guts.

TryFromGuts

Safely constructing values from their guts with possible failure.