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	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.