Struct State 

#[repr(transparent)]
pub struct State<Q = bool>(pub Q)
where
    Q: ?Sized;

The State wrapper is a generic container used to denote objects being used as a state in a Turing machine, finite-state machine, or similar computational model.

Tuple Fields

0: Q

Implementations

impl<Q> State<Q>

pub const fn new(state: Q) -> State<Q>

a constructor method for the State type.

pub fn init<F>(f: F) -> State<Q>

where F: FnOnce() -> Q,

create a new state by invoking the given function and capturing its output.

pub fn one() -> State<Q>

where Q: One,

returns a new state with a value of one.

pub fn zero() -> State<Q>

where Q: Zero,

returns a new state with a value of zero.

pub const fn as_ptr(&self) -> *const Q

returns a new instance of state with a raw pointer to the inner value.

pub const fn as_mut_ptr(&mut self) -> *mut Q

returns a new instance of state with a mutable raw pointer to the inner value.

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

returns an immutable reference to the inner value of the state.

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

returns a mutable reference to the inner value of the state.

pub fn value(self) -> Q

consumes and returns the inner value of the state.

pub unsafe fn cast<R>(self) -> State<R>

Casts the state to a new type, returning a new instance of State.

Safety

The method is marked unsafe because there are no guarantees that the inner type Q can be safely interpreted as type R. The caller must ensure that the cast is valid to avoid undefined behavior.

pub fn map<R, F>(self, f: F) -> State<R>

where F: FnOnce(Q) -> R,

State::map applies the given function onto the inner value of the state, returning a new state with the result.

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

where Q: Default,

reset the state back to its logical default, returning the previous value.

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

update the current value of the object with the given state.

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

replace the inner value of the state with the given state,

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

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

pub fn take(&mut self) -> Q

where Q: Default,

take the inner value of the state, leaving the logical default in its place

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

where Q: RawState,

converts the current reference into a haltable state initialized with the current state

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

where Q: RawState,

consumes the wrapper to create another, haltable state that is initialized with the current state

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

where Q: RawState,

consumes the current state, returning a new one with a Halt variant initialized with the current value.

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

returns a state with an owned inner value.

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

returns a state with a mutable reference to the inner value.

pub fn get_inner_type_name(&self) -> &'static str

returns the name of the generic inner type, Q.

pub const fn get_inner_type_id(&self) -> TypeId

where Q: 'static,

returns the type id of the generic inner type, Q.

impl<Q> State<Q>

Additional implementations for the State type enabled whenever the alloc feature is toggled.

pub fn boxed(self) -> State<Box<Q>>

returns a new state with a boxed inner value.

pub fn as_any(&self) -> State<Box<dyn Any>>

where Q: Clone + 'static,

Converts the inner type into a boxed “any” state, returning a new instance of state

pub fn into_any(self) -> State<Box<dyn Any>>

where Q: 'static,

Converts the inner type into a boxed “any” state, returning a new instance of state

pub fn shared(self) -> State<Arc<Q>>

convert the state into another instance by wrapping the inner value with an Arc.

pub fn to_shared(&self) -> State<Arc<Q>>

where Q: Clone,

returns a shared reference to the state.

impl<Q> State<&Q>

pub fn cloned(&self) -> State<Q>

where Q: Clone,

Clones the internal state and returning a new instance of State

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

where Q: Copy,

Copies the internal state and returning a new instance of State

impl<Q> State<&mut Q>

pub fn cloned(&self) -> State<Q>

where Q: Clone,

Clones the internal state and returning a new instance of State

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

where Q: Copy,

Copies the internal state and returning a new instance of State

impl<Q> State<*const Q>

pub fn from_ptr(ptr: *const Q) -> State<*const Q>

Creates a new instance of state with a raw pointer to the inner value.

impl<Q> State<*mut Q>

pub fn from_mut_ptr(ptr: *mut Q) -> State<*mut Q>

Creates a new instance of state with a mutable raw pointer to the inner value.

impl<Q> State<MaybeUninit<Q>>

pub const fn initialized(value: Q) -> State<MaybeUninit<Q>>

Creates a new instance of state with an initialized inner value.

pub const fn uninit() -> State<MaybeUninit<Q>>

Creates a new instance of state with an uninitialized inner value.

pub unsafe fn assume_init(self) -> State<Q>

Converts the state into a new instance of State with an initialized state.

Safety

This method is unsafe because it is up to the caller to ensure that the inner value is indeed initialized.

pub fn is_null(&self) -> bool

determines if the inner state is null; returns false if the inner state is not null.

pub fn write(&mut self, value: Q) -> &mut Q

Writes a value to the inner state.

impl State<()>

pub const fn empty() -> State<()>

Creates a new instance of State with an empty state.

impl State

pub const fn yes() -> State

Creates a new instance of State with an inner state of true.

pub const fn no() -> State

returns a new instance of State with an inner state of false.

pub fn is_true(&self) -> bool

returns true if the inner state is true, false otherwise.

pub fn is_false(&self) -> bool

returns true if the inner state is false, false otherwise.

impl State<Box<dyn Any>>

pub fn downcast<Q>(self) -> Result<State<Box<Q>>, StateError>

where Q: Any,

Attempts to downcast the state to a concrete type Q; returns an error if the state is not of type Q.

pub fn downcast_ref<Q>(&self) -> Option<State<&Q>>

where Q: Any,

Returns an immutable reference to the state if it is of type Q; returns None otherwise.

pub fn downcast_mut<Q>(&mut self) -> Option<State<&mut Q>>

where Q: Any,

Returns a mutable reference to the state if it is of type Q; returns None otherwise.

impl<Q> State<Option<Q>>

pub const fn none() -> State<Option<Q>>

Creates a new instance of state whose inner state is Option::None.

pub const fn some(value: Q) -> State<Option<Q>>

Creates a new instance of state whose inner state is Option::Some.

Trait Implementations

impl<'a, _A, _B, _C> Add<&'a State<_B>> for &'a State<_A>

where &'a _A: Add<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the + operator.

fn add( self, rhs: &'a State<_B>, ) -> <&'a State<_A> as Add<&'a State<_B>>>::Output

Performs the + operation.

impl<'a, _A, _B, _C> Add<&'a State<_B>> for State<_A>

where _A: Add<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the + operator.

fn add(self, rhs: &'a State<_B>) -> <State<_A> as Add<&'a State<_B>>>::Output

Performs the + operation.

impl<'a, _A, _B, _C> Add<&'a mut State<_B>> for &'a mut State<_A>

where &'a mut _A: Add<&'a mut _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the + operator.

fn add( self, rhs: &'a mut State<_B>, ) -> <&'a mut State<_A> as Add<&'a mut State<_B>>>::Output

Performs the + operation.

impl<'a, _A, _B, _C> Add<&'a mut State<_B>> for State<_A>

where _A: Add<&'a mut _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the + operator.

fn add( self, rhs: &'a mut State<_B>, ) -> <State<_A> as Add<&'a mut State<_B>>>::Output

Performs the + operation.

impl<'a, _A, _B, _C> Add<State<_B>> for &'a State<_A>

where &'a _A: Add<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the + operator.

fn add(self, rhs: State<_B>) -> <&'a State<_A> as Add<State<_B>>>::Output

Performs the + operation.

impl<'a, _A, _B, _C> Add<State<_B>> for &'a mut State<_A>

where &'a mut _A: Add<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the + operator.

fn add(self, rhs: State<_B>) -> <&'a mut State<_A> as Add<State<_B>>>::Output

Performs the + operation.

impl<_A, _B, _C> Add<State<_B>> for State<_A>

where _A: Add<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the + operator.

fn add(self, rhs: State<_B>) -> <State<_A> as Add<State<_B>>>::Output

Performs the + operation.

impl<_A, _B> AddAssign<State<_B>> for State<_A>

where _A: AddAssign<_B>,

fn add_assign(&mut self, rhs: State<_B>)

Performs the += operation.

impl<Q> AsMut<Q> for State<Q>

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 State<Q>

fn as_ref(&self) -> &Q

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

impl<'a, _A, _B, _C> BitAnd<&'a State<_B>> for &'a State<_A>

where &'a _A: BitAnd<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the & operator.

fn bitand( self, rhs: &'a State<_B>, ) -> <&'a State<_A> as BitAnd<&'a State<_B>>>::Output

Performs the & operation.

impl<'a, _A, _B, _C> BitAnd<&'a State<_B>> for State<_A>

where _A: BitAnd<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the & operator.

fn bitand( self, rhs: &'a State<_B>, ) -> <State<_A> as BitAnd<&'a State<_B>>>::Output

Performs the & operation.

impl<'a, _A, _B, _C> BitAnd<&'a mut State<_B>> for &'a mut State<_A>

where &'a mut _A: BitAnd<&'a mut _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the & operator.

fn bitand( self, rhs: &'a mut State<_B>, ) -> <&'a mut State<_A> as BitAnd<&'a mut State<_B>>>::Output

Performs the & operation.

impl<'a, _A, _B, _C> BitAnd<&'a mut State<_B>> for State<_A>

where _A: BitAnd<&'a mut _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the & operator.

fn bitand( self, rhs: &'a mut State<_B>, ) -> <State<_A> as BitAnd<&'a mut State<_B>>>::Output

Performs the & operation.

impl<'a, _A, _B, _C> BitAnd<State<_B>> for &'a State<_A>

where &'a _A: BitAnd<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the & operator.

fn bitand(self, rhs: State<_B>) -> <&'a State<_A> as BitAnd<State<_B>>>::Output

Performs the & operation.

impl<'a, _A, _B, _C> BitAnd<State<_B>> for &'a mut State<_A>

where &'a mut _A: BitAnd<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the & operator.

fn bitand( self, rhs: State<_B>, ) -> <&'a mut State<_A> as BitAnd<State<_B>>>::Output

Performs the & operation.

impl<_A, _B, _C> BitAnd<State<_B>> for State<_A>

where _A: BitAnd<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the & operator.

fn bitand(self, rhs: State<_B>) -> <State<_A> as BitAnd<State<_B>>>::Output

Performs the & operation.

impl<_A, _B> BitAndAssign<State<_B>> for State<_A>

where _A: BitAndAssign<_B>,

fn bitand_assign(&mut self, rhs: State<_B>)

Performs the &= operation.

impl<'a, _A, _B, _C> BitOr<&'a State<_B>> for &'a State<_A>

where &'a _A: BitOr<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the | operator.

fn bitor( self, rhs: &'a State<_B>, ) -> <&'a State<_A> as BitOr<&'a State<_B>>>::Output

Performs the | operation.

impl<'a, _A, _B, _C> BitOr<&'a State<_B>> for State<_A>

where _A: BitOr<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the | operator.

fn bitor( self, rhs: &'a State<_B>, ) -> <State<_A> as BitOr<&'a State<_B>>>::Output

Performs the | operation.

impl<'a, _A, _B, _C> BitOr<&'a mut State<_B>> for &'a mut State<_A>

where &'a mut _A: BitOr<&'a mut _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the | operator.

fn bitor( self, rhs: &'a mut State<_B>, ) -> <&'a mut State<_A> as BitOr<&'a mut State<_B>>>::Output

Performs the | operation.

impl<'a, _A, _B, _C> BitOr<&'a mut State<_B>> for State<_A>

where _A: BitOr<&'a mut _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the | operator.

fn bitor( self, rhs: &'a mut State<_B>, ) -> <State<_A> as BitOr<&'a mut State<_B>>>::Output

Performs the | operation.

impl<'a, _A, _B, _C> BitOr<State<_B>> for &'a State<_A>

where &'a _A: BitOr<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the | operator.

fn bitor(self, rhs: State<_B>) -> <&'a State<_A> as BitOr<State<_B>>>::Output

Performs the | operation.

impl<'a, _A, _B, _C> BitOr<State<_B>> for &'a mut State<_A>

where &'a mut _A: BitOr<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the | operator.

fn bitor( self, rhs: State<_B>, ) -> <&'a mut State<_A> as BitOr<State<_B>>>::Output

Performs the | operation.

impl<_A, _B, _C> BitOr<State<_B>> for State<_A>

where _A: BitOr<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the | operator.

fn bitor(self, rhs: State<_B>) -> <State<_A> as BitOr<State<_B>>>::Output

Performs the | operation.

impl<_A, _B> BitOrAssign<State<_B>> for State<_A>

where _A: BitOrAssign<_B>,

fn bitor_assign(&mut self, rhs: State<_B>)

Performs the |= operation.

impl<'a, _A, _B, _C> BitXor<&'a State<_B>> for &'a State<_A>

where &'a _A: BitXor<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the ^ operator.

fn bitxor( self, rhs: &'a State<_B>, ) -> <&'a State<_A> as BitXor<&'a State<_B>>>::Output

Performs the ^ operation.

impl<'a, _A, _B, _C> BitXor<&'a State<_B>> for State<_A>

where _A: BitXor<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the ^ operator.

fn bitxor( self, rhs: &'a State<_B>, ) -> <State<_A> as BitXor<&'a State<_B>>>::Output

Performs the ^ operation.

impl<'a, _A, _B, _C> BitXor<&'a mut State<_B>> for &'a mut State<_A>

where &'a mut _A: BitXor<&'a mut _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the ^ operator.

fn bitxor( self, rhs: &'a mut State<_B>, ) -> <&'a mut State<_A> as BitXor<&'a mut State<_B>>>::Output

Performs the ^ operation.

impl<'a, _A, _B, _C> BitXor<&'a mut State<_B>> for State<_A>

where _A: BitXor<&'a mut _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the ^ operator.

fn bitxor( self, rhs: &'a mut State<_B>, ) -> <State<_A> as BitXor<&'a mut State<_B>>>::Output

Performs the ^ operation.

impl<'a, _A, _B, _C> BitXor<State<_B>> for &'a State<_A>

where &'a _A: BitXor<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: State<_B>) -> <&'a State<_A> as BitXor<State<_B>>>::Output

Performs the ^ operation.

impl<'a, _A, _B, _C> BitXor<State<_B>> for &'a mut State<_A>

where &'a mut _A: BitXor<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the ^ operator.

fn bitxor( self, rhs: State<_B>, ) -> <&'a mut State<_A> as BitXor<State<_B>>>::Output

Performs the ^ operation.

impl<_A, _B, _C> BitXor<State<_B>> for State<_A>

where _A: BitXor<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: State<_B>) -> <State<_A> as BitXor<State<_B>>>::Output

Performs the ^ operation.

impl<_A, _B> BitXorAssign<State<_B>> for State<_A>

where _A: BitXorAssign<_B>,

fn bitxor_assign(&mut self, rhs: State<_B>)

Performs the ^= operation.

impl<Q> Borrow<Q> for State<Q>

fn borrow(&self) -> &Q

Immutably borrows from an owned value.

impl<Q, A> Borrow<State<Q>> for Head<Q, A>

where Q: RawState,

fn borrow(&self) -> &State<Q>

Immutably borrows from an owned value.

impl<Q, A> Borrow<State<Q>> for Tail<Q, A>

where Q: RawState,

fn borrow(&self) -> &State<Q>

Immutably borrows from an owned value.

impl<Q> BorrowMut<Q> for State<Q>

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

Mutably borrows from an owned value.

impl<Q, A> BorrowMut<State<Q>> for Head<Q, A>

where Q: RawState,

fn borrow_mut(&mut self) -> &mut State<Q>

Mutably borrows from an owned value.

impl<Q, A> BorrowMut<State<Q>> for Tail<Q, A>

where Q: RawState,

fn borrow_mut(&mut self) -> &mut State<Q>

Mutably borrows from an owned value.

impl<Q> Clone for State<Q>

where Q: Clone + ?Sized,

fn clone(&self) -> State<Q>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Debug for State<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<Q> Default for State<Q>

where Q: Default + ?Sized,

fn default() -> State<Q>

Returns the “default value” for a type.

impl<Q> Deref for State<Q>

type Target = Q

The resulting type after dereferencing.

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

Dereferences the value.

impl<Q> DerefMut for State<Q>

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

Mutably dereferences the value.

impl<T> Display for State<T>

where T: Display,

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

Formats the value using the given formatter.

impl<'a, _A, _B, _C> Div<&'a State<_B>> for &'a State<_A>

where &'a _A: Div<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the / operator.

fn div( self, rhs: &'a State<_B>, ) -> <&'a State<_A> as Div<&'a State<_B>>>::Output

Performs the / operation.

impl<'a, _A, _B, _C> Div<&'a State<_B>> for State<_A>

where _A: Div<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the / operator.

fn div(self, rhs: &'a State<_B>) -> <State<_A> as Div<&'a State<_B>>>::Output

Performs the / operation.

impl<'a, _A, _B, _C> Div<&'a mut State<_B>> for &'a mut State<_A>

where &'a mut _A: Div<&'a mut _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the / operator.

fn div( self, rhs: &'a mut State<_B>, ) -> <&'a mut State<_A> as Div<&'a mut State<_B>>>::Output

Performs the / operation.

impl<'a, _A, _B, _C> Div<&'a mut State<_B>> for State<_A>

where _A: Div<&'a mut _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the / operator.

fn div( self, rhs: &'a mut State<_B>, ) -> <State<_A> as Div<&'a mut State<_B>>>::Output

Performs the / operation.

impl<'a, _A, _B, _C> Div<State<_B>> for &'a State<_A>

where &'a _A: Div<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the / operator.

fn div(self, rhs: State<_B>) -> <&'a State<_A> as Div<State<_B>>>::Output

Performs the / operation.

impl<'a, _A, _B, _C> Div<State<_B>> for &'a mut State<_A>

where &'a mut _A: Div<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the / operator.

fn div(self, rhs: State<_B>) -> <&'a mut State<_A> as Div<State<_B>>>::Output

Performs the / operation.

impl<_A, _B, _C> Div<State<_B>> for State<_A>

where _A: Div<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the / operator.

fn div(self, rhs: State<_B>) -> <State<_A> as Div<State<_B>>>::Output

Performs the / operation.

impl<_A, _B> DivAssign<State<_B>> for State<_A>

where _A: DivAssign<_B>,

fn div_assign(&mut self, rhs: State<_B>)

Performs the /= operation.

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

fn from(state: Q) -> State<Q>

Converts to this type from the input type.

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> Halting for State<Q>

where Q: Halting,

fn is_halted(&self) -> bool

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

impl<Q> Hash for State<Q>

where Q: Hash + ?Sized,

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<T> LowerExp for State<T>

where T: LowerExp,

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

Formats the value using the given formatter.

impl<T> LowerHex for State<T>

where T: LowerHex,

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

Formats the value using the given formatter.

impl<'a, _A, _B, _C> Mul<&'a State<_B>> for &'a State<_A>

where &'a _A: Mul<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a State<_B>, ) -> <&'a State<_A> as Mul<&'a State<_B>>>::Output

Performs the * operation.

impl<'a, _A, _B, _C> Mul<&'a State<_B>> for State<_A>

where _A: Mul<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a State<_B>) -> <State<_A> as Mul<&'a State<_B>>>::Output

Performs the * operation.

impl<'a, _A, _B, _C> Mul<&'a mut State<_B>> for &'a mut State<_A>

where &'a mut _A: Mul<&'a mut _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a mut State<_B>, ) -> <&'a mut State<_A> as Mul<&'a mut State<_B>>>::Output

Performs the * operation.

impl<'a, _A, _B, _C> Mul<&'a mut State<_B>> for State<_A>

where _A: Mul<&'a mut _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the * operator.

fn mul( self, rhs: &'a mut State<_B>, ) -> <State<_A> as Mul<&'a mut State<_B>>>::Output

Performs the * operation.

impl<'a, _A, _B, _C> Mul<State<_B>> for &'a State<_A>

where &'a _A: Mul<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the * operator.

fn mul(self, rhs: State<_B>) -> <&'a State<_A> as Mul<State<_B>>>::Output

Performs the * operation.

impl<'a, _A, _B, _C> Mul<State<_B>> for &'a mut State<_A>

where &'a mut _A: Mul<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the * operator.

fn mul(self, rhs: State<_B>) -> <&'a mut State<_A> as Mul<State<_B>>>::Output

Performs the * operation.

impl<_A, _B, _C> Mul<State<_B>> for State<_A>

where _A: Mul<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the * operator.

fn mul(self, rhs: State<_B>) -> <State<_A> as Mul<State<_B>>>::Output

Performs the * operation.

impl<_A, _B> MulAssign<State<_B>> for State<_A>

where _A: MulAssign<_B>,

fn mul_assign(&mut self, rhs: State<_B>)

Performs the *= operation.

impl<'a, _A, _B> Neg for &'a State<_A>

where &'a _A: Neg<Output = _B>,

type Output = State<_B>

The resulting type after applying the - operator.

fn neg(self) -> <&'a State<_A> as Neg>::Output

Performs the unary - operation.

impl<'a, _A, _B> Neg for &'a mut State<_A>

where &'a mut _A: Neg<Output = _B>,

type Output = State<_B>

The resulting type after applying the - operator.

fn neg(self) -> <&'a mut State<_A> as Neg>::Output

Performs the unary - operation.

impl<_A, _B> Neg for State<_A>

where _A: Neg<Output = _B>,

type Output = State<_B>

The resulting type after applying the - operator.

fn neg(self) -> <State<_A> as Neg>::Output

Performs the unary - operation.

impl<'a, _A, _B> Not for &'a State<_A>

where &'a _A: Not<Output = _B>,

type Output = State<_B>

The resulting type after applying the ! operator.

fn not(self) -> <&'a State<_A> as Not>::Output

Performs the unary ! operation.

impl<'a, _A, _B> Not for &'a mut State<_A>

where &'a mut _A: Not<Output = _B>,

type Output = State<_B>

The resulting type after applying the ! operator.

fn not(self) -> <&'a mut State<_A> as Not>::Output

Performs the unary ! operation.

impl<_A, _B> Not for State<_A>

where _A: Not<Output = _B>,

type Output = State<_B>

The resulting type after applying the ! operator.

fn not(self) -> <State<_A> as Not>::Output

Performs the unary ! operation.

impl<Q> Num for State<Q>

where Q: Num,

type FromStrRadixErr = <Q as Num>::FromStrRadixErr

fn from_str_radix( str: &str, radix: u32, ) -> Result<State<Q>, <State<Q> as Num>::FromStrRadixErr>

Convert from a string and radix (typically 2..=36).

impl<T> Octal for State<T>

where T: Octal,

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

Formats the value using the given formatter.

impl<Q> One for State<Q>

where Q: PartialEq + One,

fn one() -> State<Q>

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

impl<Q> Ord for State<Q>

where Q: Ord + ?Sized,

fn cmp(&self, other: &State<Q>) -> 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<'a, Q> PartialEq<&'a Q> for State<Q>

where Q: PartialEq,

fn eq(&self, other: &&'a Q) -> 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<'a, Q> PartialEq<&'a mut Q> for State<Q>

where Q: PartialEq,

fn eq(&self, other: &&'a mut Q) -> 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, A> PartialEq<Head<Q, A>> for State<&Q>

where Q: PartialEq,

fn eq(&self, head: &Head<Q, A>) -> 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, A> PartialEq<Head<Q, A>> for State<Q>

where Q: PartialEq,

fn eq(&self, head: &Head<Q, A>) -> 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> PartialEq<Q> for State<Q>

where Q: PartialEq,

fn eq(&self, other: &Q) -> 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<'a, Q, A> PartialEq<State<&'a Q>> for Head<Q, A>

where Q: PartialEq,

fn eq(&self, state: &State<&'a Q>) -> 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, A> PartialEq<State<Q>> for Head<Q, A>

where Q: PartialEq,

fn eq(&self, state: &State<Q>) -> 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> PartialEq for State<Q>

where Q: PartialEq + ?Sized,

fn eq(&self, other: &State<Q>) -> 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<'a, Q> PartialOrd<&'a Q> for State<Q>

where Q: PartialOrd,

fn partial_cmp(&self, other: &&'a Q) -> 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<'a, Q> PartialOrd<&'a mut Q> for State<Q>

where Q: PartialOrd,

fn partial_cmp(&self, other: &&'a mut Q) -> 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> PartialOrd<Q> for State<Q>

where Q: PartialOrd,

fn partial_cmp(&self, other: &Q) -> 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> PartialOrd for State<Q>

where Q: PartialOrd + ?Sized,

fn partial_cmp(&self, other: &State<Q>) -> 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<'a, _A, _B, _C> Rem<&'a State<_B>> for &'a State<_A>

where &'a _A: Rem<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the % operator.

fn rem( self, rhs: &'a State<_B>, ) -> <&'a State<_A> as Rem<&'a State<_B>>>::Output

Performs the % operation.

impl<'a, _A, _B, _C> Rem<&'a State<_B>> for State<_A>

where _A: Rem<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the % operator.

fn rem(self, rhs: &'a State<_B>) -> <State<_A> as Rem<&'a State<_B>>>::Output

Performs the % operation.

impl<'a, _A, _B, _C> Rem<&'a mut State<_B>> for &'a mut State<_A>

where &'a mut _A: Rem<&'a mut _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the % operator.

fn rem( self, rhs: &'a mut State<_B>, ) -> <&'a mut State<_A> as Rem<&'a mut State<_B>>>::Output

Performs the % operation.

impl<'a, _A, _B, _C> Rem<&'a mut State<_B>> for State<_A>

where _A: Rem<&'a mut _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the % operator.

fn rem( self, rhs: &'a mut State<_B>, ) -> <State<_A> as Rem<&'a mut State<_B>>>::Output

Performs the % operation.

impl<'a, _A, _B, _C> Rem<State<_B>> for &'a State<_A>

where &'a _A: Rem<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the % operator.

fn rem(self, rhs: State<_B>) -> <&'a State<_A> as Rem<State<_B>>>::Output

Performs the % operation.

impl<'a, _A, _B, _C> Rem<State<_B>> for &'a mut State<_A>

where &'a mut _A: Rem<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the % operator.

fn rem(self, rhs: State<_B>) -> <&'a mut State<_A> as Rem<State<_B>>>::Output

Performs the % operation.

impl<_A, _B, _C> Rem<State<_B>> for State<_A>

where _A: Rem<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the % operator.

fn rem(self, rhs: State<_B>) -> <State<_A> as Rem<State<_B>>>::Output

Performs the % operation.

impl<_A, _B> RemAssign<State<_B>> for State<_A>

where _A: RemAssign<_B>,

fn rem_assign(&mut self, rhs: State<_B>)

Performs the %= operation.

impl<'a, _A, _B, _C> Shl<&'a State<_B>> for &'a State<_A>

where &'a _A: Shl<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the << operator.

fn shl( self, rhs: &'a State<_B>, ) -> <&'a State<_A> as Shl<&'a State<_B>>>::Output

Performs the << operation.

impl<'a, _A, _B, _C> Shl<&'a State<_B>> for State<_A>

where _A: Shl<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the << operator.

fn shl(self, rhs: &'a State<_B>) -> <State<_A> as Shl<&'a State<_B>>>::Output

Performs the << operation.

impl<'a, _A, _B, _C> Shl<&'a mut State<_B>> for &'a mut State<_A>

where &'a mut _A: Shl<&'a mut _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the << operator.

fn shl( self, rhs: &'a mut State<_B>, ) -> <&'a mut State<_A> as Shl<&'a mut State<_B>>>::Output

Performs the << operation.

impl<'a, _A, _B, _C> Shl<&'a mut State<_B>> for State<_A>

where _A: Shl<&'a mut _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the << operator.

fn shl( self, rhs: &'a mut State<_B>, ) -> <State<_A> as Shl<&'a mut State<_B>>>::Output

Performs the << operation.

impl<'a, _A, _B, _C> Shl<State<_B>> for &'a State<_A>

where &'a _A: Shl<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the << operator.

fn shl(self, rhs: State<_B>) -> <&'a State<_A> as Shl<State<_B>>>::Output

Performs the << operation.

impl<'a, _A, _B, _C> Shl<State<_B>> for &'a mut State<_A>

where &'a mut _A: Shl<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the << operator.

fn shl(self, rhs: State<_B>) -> <&'a mut State<_A> as Shl<State<_B>>>::Output

Performs the << operation.

impl<_A, _B, _C> Shl<State<_B>> for State<_A>

where _A: Shl<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the << operator.

fn shl(self, rhs: State<_B>) -> <State<_A> as Shl<State<_B>>>::Output

Performs the << operation.

impl<_A, _B> ShlAssign<State<_B>> for State<_A>

where _A: ShlAssign<_B>,

fn shl_assign(&mut self, rhs: State<_B>)

Performs the <<= operation.

impl<'a, _A, _B, _C> Shr<&'a State<_B>> for &'a State<_A>

where &'a _A: Shr<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the >> operator.

fn shr( self, rhs: &'a State<_B>, ) -> <&'a State<_A> as Shr<&'a State<_B>>>::Output

Performs the >> operation.

impl<'a, _A, _B, _C> Shr<&'a State<_B>> for State<_A>

where _A: Shr<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the >> operator.

fn shr(self, rhs: &'a State<_B>) -> <State<_A> as Shr<&'a State<_B>>>::Output

Performs the >> operation.

impl<'a, _A, _B, _C> Shr<&'a mut State<_B>> for &'a mut State<_A>

where &'a mut _A: Shr<&'a mut _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the >> operator.

fn shr( self, rhs: &'a mut State<_B>, ) -> <&'a mut State<_A> as Shr<&'a mut State<_B>>>::Output

Performs the >> operation.

impl<'a, _A, _B, _C> Shr<&'a mut State<_B>> for State<_A>

where _A: Shr<&'a mut _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the >> operator.

fn shr( self, rhs: &'a mut State<_B>, ) -> <State<_A> as Shr<&'a mut State<_B>>>::Output

Performs the >> operation.

impl<'a, _A, _B, _C> Shr<State<_B>> for &'a State<_A>

where &'a _A: Shr<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the >> operator.

fn shr(self, rhs: State<_B>) -> <&'a State<_A> as Shr<State<_B>>>::Output

Performs the >> operation.

impl<'a, _A, _B, _C> Shr<State<_B>> for &'a mut State<_A>

where &'a mut _A: Shr<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the >> operator.

fn shr(self, rhs: State<_B>) -> <&'a mut State<_A> as Shr<State<_B>>>::Output

Performs the >> operation.

impl<_A, _B, _C> Shr<State<_B>> for State<_A>

where _A: Shr<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the >> operator.

fn shr(self, rhs: State<_B>) -> <State<_A> as Shr<State<_B>>>::Output

Performs the >> operation.

impl<_A, _B> ShrAssign<State<_B>> for State<_A>

where _A: ShrAssign<_B>,

fn shr_assign(&mut self, rhs: State<_B>)

Performs the >>= operation.

impl<'a, _A, _B, _C> Sub<&'a State<_B>> for &'a State<_A>

where &'a _A: Sub<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a State<_B>, ) -> <&'a State<_A> as Sub<&'a State<_B>>>::Output

Performs the - operation.

impl<'a, _A, _B, _C> Sub<&'a State<_B>> for State<_A>

where _A: Sub<&'a _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a State<_B>) -> <State<_A> as Sub<&'a State<_B>>>::Output

Performs the - operation.

impl<'a, _A, _B, _C> Sub<&'a mut State<_B>> for &'a mut State<_A>

where &'a mut _A: Sub<&'a mut _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a mut State<_B>, ) -> <&'a mut State<_A> as Sub<&'a mut State<_B>>>::Output

Performs the - operation.

impl<'a, _A, _B, _C> Sub<&'a mut State<_B>> for State<_A>

where _A: Sub<&'a mut _B, Output = _C>,

type Output = State<_C>

The resulting type after applying the - operator.

fn sub( self, rhs: &'a mut State<_B>, ) -> <State<_A> as Sub<&'a mut State<_B>>>::Output

Performs the - operation.

impl<'a, _A, _B, _C> Sub<State<_B>> for &'a State<_A>

where &'a _A: Sub<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the - operator.

fn sub(self, rhs: State<_B>) -> <&'a State<_A> as Sub<State<_B>>>::Output

Performs the - operation.

impl<'a, _A, _B, _C> Sub<State<_B>> for &'a mut State<_A>

where &'a mut _A: Sub<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the - operator.

fn sub(self, rhs: State<_B>) -> <&'a mut State<_A> as Sub<State<_B>>>::Output

Performs the - operation.

impl<_A, _B, _C> Sub<State<_B>> for State<_A>

where _A: Sub<_B, Output = _C>,

type Output = State<_C>

The resulting type after applying the - operator.

fn sub(self, rhs: State<_B>) -> <State<_A> as Sub<State<_B>>>::Output

Performs the - operation.

impl<_A, _B> SubAssign<State<_B>> for State<_A>

where _A: SubAssign<_B>,

fn sub_assign(&mut self, rhs: State<_B>)

Performs the -= operation.

impl<T> UpperExp for State<T>

where T: UpperExp,

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

Formats the value using the given formatter.

impl<T> UpperHex for State<T>

where T: UpperHex,

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

Formats the value using the given formatter.

impl<Q> Zero for State<Q>

where Q: Zero,

fn zero() -> State<Q>

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<Q> Copy for State<Q>

where Q: Copy + ?Sized,

impl<Q> Eq for State<Q>

where Q: Eq + ?Sized,

impl<Q> Send for State<Q>

where Q: Send,

impl<Q> StructuralPartialEq for State<Q>

where Q: ?Sized,

impl<Q> Sync for State<Q>

where Q: Sync,