Enum Halt 

#[repr(C)]
pub enum Halt<Q = usize, H = Q>
where
    Q: RawState,
    H: RawState,
{
    Halt(H),
    Step(Q),
}

The Halt implementation is a binary enum designed to represent either a halting state or a stepping state within a Turing machine or similar computational model.

Variants

Halt(H)

Step(Q)

Implementations

impl<Q, H> Halt<Q, H>

where Q: RawState, H: RawState,

pub const fn is_halt(&self) -> bool

Returns true if the enum is Halt::Halt otherwise false

pub const fn is_step(&self) -> bool

Returns true if the enum is Halt::Step otherwise false

impl<Q, H> Halt<Q, H>

where Q: RawState, H: RawState,

pub const fn from_halt(state: H) -> Halt<Q, H>

Creates a new instance of a Halt with a halted state.

pub const fn from_state(state: Q) -> Halt<Q, H>

Creates a new instance of a Halt with a continuing state.

pub const fn swap(&mut self, other: &mut Halt<Q, H>)

swap the inner value of the halt state with that of the given state.

pub const fn view(&self) -> Halt<&Q, &H>

returns a new instance of the halt state containing a reference to its inner value.

pub const fn view_mut(&mut self) -> Halt<&mut Q, &mut H>

returns a new instance of the halt state containing a mutable reference to its inner value.

pub fn to_owned(&self) -> Halt<Q, H>

where Q: Clone, H: Clone,

returns an owned version of the current haltable state

impl<Q> Halt<Q>

where Q: RawState,

pub fn into_inner(self) -> Q

consumes the current haltable state, returning the inner state.

pub fn halt(self) -> Halt<Q>

consumes the current instance to ensure a halting state

pub fn into_state(self) -> State<Q>

consumes the current haltable state, returning the inner state.

pub fn into_halt_state(self) -> State<Halt<Q>>

consumes the current instance to initialize a wrapper instance

pub const fn as_halt_state(&self) -> State<Halt<&Q>>

returns a wrapped instance of the halt state containing a reference to its inner value.

pub const fn as_mut_halt_state(&mut self) -> State<Halt<&mut Q>>

returns a wrapped instance of the halt state containing a mutable reference to its inner value.

pub const fn as_state(&self) -> State<&Q>

returns a wrapped reference to the inner value

pub const fn as_mut_state(&mut self) -> State<&mut Q>

returns a wrapped mutable reference to the inner value

pub const fn get(&self) -> &Q

returns a reference to the internal state

pub const fn get_mut(&mut self) -> &mut Q

returns a mutable reference to the internal state

pub const fn replace(&mut self, state: Q) -> Q

replace the inner value of the halt state with the given state.

pub fn set(&mut self, state: Q)

update the current inner state without affecting the status of the state.

impl<'a, Q, H> Halt<&'a Q, &'a H>

where Q: RawState, H: RawState,

pub fn cloned(self) -> Halt<Q, H>

where Q: Clone, H: Clone,

consumes the current instance of the halt state to create another with cloned inner values.

pub fn copied(self) -> Halt<Q, H>

where Q: Copy, H: Copy,

consumes the current instance of the halt state to create another with copied inner values.

Note: This method does not mutate the specified variant.

impl<'a, Q, H> Halt<&'a mut Q, &'a mut H>

where Q: RawState, H: RawState,

pub fn cloned(self) -> Halt<Q, H>

where Q: Clone, H: Clone,

consumes the current instance of the halt state to create another with cloned inner values.

pub fn copied(self) -> Halt<Q, H>

where Q: Copy, H: Copy,

consumes the current instance of the halt state to create another with copied inner values.

Trait Implementations

impl<Q> AsMut<Q> for Halt<Q>

where Q: RawState,

fn as_mut(&mut self) -> &mut Q

Converts this type into a mutable reference of the (usually inferred) input type.

impl<Q> AsRef<Q> for Halt<Q>

where Q: RawState,

fn as_ref(&self) -> &Q

Converts this type into a shared reference of the (usually inferred) input type.

impl<Q, H> Clone for Halt<Q, H>

where Q: Clone + RawState, H: Clone + RawState,

fn clone(&self) -> Halt<Q, H>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Q, H> Debug for Halt<Q, H>

where Q: Debug + RawState, H: Debug + RawState,

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

Formats the value using the given formatter.

impl<Q> Default for Halt<Q>

where Q: Default + RawState,

fn default() -> Halt<Q>

Returns the “default value” for a type.

impl<Q> Deref for Halt<Q>

where Q: RawState,

type Target = Q

The resulting type after dereferencing.

fn deref(&self) -> &<Halt<Q> as Deref>::Target

Dereferences the value.

impl<Q> DerefMut for Halt<Q>

where Q: RawState,

fn deref_mut(&mut self) -> &mut <Halt<Q> as Deref>::Target

Mutably dereferences the value.

impl<Q, H> EnumCount for Halt<Q, H>

where Q: RawState, H: RawState,

const COUNT: usize = 2usize

impl<Q> From<State<Q>> for Halt<Q>

where Q: RawState,

fn from(_: State<Q>) -> Halt<Q>

Converts to this type from the input type.

impl<Q, H> Halting for Halt<Q, H>

where Q: RawState, H: RawState,

fn is_halted(&self) -> bool

returns true if the current state is considered to be halted, otherwise false.

impl<Q, H> Hash for Halt<Q, H>

where Q: Hash + RawState, H: Hash + RawState,

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<Q, H> Ord for Halt<Q, H>

where Q: Ord + RawState, H: Ord + RawState,

fn cmp(&self, other: &Halt<Q, H>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<Q, H> PartialEq for Halt<Q, H>

where Q: PartialEq + RawState, H: PartialEq + RawState,

fn eq(&self, other: &Halt<Q, H>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Q, H> PartialOrd for Halt<Q, H>

where Q: PartialOrd + RawState, H: PartialOrd + RawState,

fn partial_cmp(&self, other: &Halt<Q, H>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<Q, H> Copy for Halt<Q, H>

where Q: Copy + RawState, H: Copy + RawState,

impl<Q, H> Eq for Halt<Q, H>

where Q: Eq + RawState, H: Eq + RawState,

impl<Q, H> RawState for Halt<Q, H>

where Q: RawState, H: RawState,

impl<Q, H> StructuralPartialEq for Halt<Q, H>

where Q: RawState, H: RawState,