Struct Head 

#[repr(C)]
pub struct Head<Q, A> {
    pub state: State<Q>,
    pub symbol: A,
}

The Head of a Turing machine is defined to be a two-tuple consisting of a state and a symbol. Our implementation is generic over both the state and symbol types, allowing for flexibility in their representation(s).

Fields

state: State<Q>

symbol: A

Implementations

impl<Q, A> Head<Q, A>

where Q: RawState,

The core implementation of the Head providing fundamental methods for its manipulation, including various constructors, accessors, and mutators as well as convienience methods for converting between representations.

pub const fn new(state: Q, symbol: A) -> Head<Q, A>

initialize a new instance of the Head given some state and symbol

pub fn from_state(state: Q) -> Head<Q, A>

where A: Default,

returns a new instance of the head using the given state and a default symbol

pub fn from_symbol(symbol: A) -> Head<Q, A>

where Q: Default,

returns a new instance of the head using the given symbol and a default state

pub fn from_tail(_: Tail<Q, A>) -> Head<Q, A>

create an instance of the Head from a given Tail

pub fn from_tuple(_: (State<Q>, A)) -> Head<Q, A>

Create a new instance from a 2-tuple: (state, symbol)

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

returns a reference to the current state

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

returns a mutable reference to the current State

pub const fn symbol(&self) -> &A

returns a reference to the current symbol

pub const fn symbol_mut(&mut self) -> &mut A

returns a mutable reference to the current symbol

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

updates the current state

pub fn set_symbol(&mut self, symbol: A)

updates the current symbol

pub fn with_state<Q2>(self, state: Q2) -> Head<Q2, A>

consumes the current instance to create another instance with the given state

pub fn with_symbol<A2>(self, symbol: A2) -> Head<Q, A2>

consumes the current instance to create another instance with the given symbol

pub const fn replace(&mut self, state: State<Q>, symbol: A) -> Head<Q, A>

replaces the current values with the given state and symbol, returning the previous instance of the Head

pub const fn replace_state(&mut self, state: State<Q>) -> State<Q>

replace the current state with the given state, returning the previous state

pub const fn replace_symbol(&mut self, symbol: A) -> A

replace the current symbol with the given symbol, returning the previous symbol

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

swap the state and symbol of the current instance with another

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

swap the current state with another

pub const fn swap_symbol(&mut self, other: &mut A)

swap the current symbol with another

pub fn update(&mut self, state: Option<State<Q>>, symbol: Option<A>)

updates the current State and symbol

pub const fn as_tuple(&self) -> (&State<Q>, &A)

returns a reference to the current state and symbol returing a 2-tuple

pub const fn as_mut_tuple(&mut self) -> (&mut State<Q>, &mut A)

returns a mutable reference to the current state and symbol as a 2-tuple

pub fn into_tuple(self) -> (State<Q>, A)

Consumes the head and returns the current state and symbol as a 2-tuple

pub fn into_rule_with_tail(self, tail: Tail<Q, A>) -> Rule<Q, A>

where Q: RawState,

associates the given tail with the current head, returning a new Rule

pub fn read_tape<T>(self, tape: &[T]) -> Option<&<A as SliceIndex<[T]>>::Output>

where A: SliceIndex<[T]>,

tries reading the given tape using the head as its coordinates.

pub const fn view(&self) -> Head<&Q, &A>

returns a new head with immutable references to the current state and symbol

pub const fn view_mut(&mut self) -> Head<&mut Q, &mut A>

returns a new head with mutable references to the current state and symbol

pub fn step<'a, Q2, B>( &'a mut self, tail: Tail<Q2, B>, ) -> HeadStep<'a, Q, A, Q2, B>

where Q2: RawState,

use the given Tail to initialize a new HeadStep instance for performing a step operation.

Note: this method is lazy, meaning that the actual step is not performed until an actionable method is called on the returned HeadStep instance.

impl<'a, Q, S> Head<&'a Q, &'a S>

where Q: RawState,

pub fn cloned(&self) -> Head<Q, S>

where Q: Clone, S: Clone,

returns a new Head with cloned elements

pub const fn copied(&self) -> Head<Q, S>

where Q: Copy, S: Copy,

returns a new Head with copied elements

impl<'a, Q, S> Head<&'a mut Q, &'a mut S>

where Q: RawState,

pub fn cloned(&self) -> Head<Q, S>

where Q: Clone, S: Clone,

returns a new Head with cloned elements

pub fn copied(&self) -> Head<Q, S>

where Q: Copy, S: Copy,

returns a new Head with copied elements

impl<Q> Head<Q, usize>

where Q: RawState,

pub fn load<A>( self, program: ProgramBase<Vec<Rule<Q, A>>, Q, A>, ) -> EngineBase<Head<Q, usize>, Q, A>

where Q: PartialEq, A: PartialEq,

load the head into an engine loaded with the given program

pub fn shift(self, direction: Direction) -> Head<Q, usize>

pub fn shift_inplace(&mut self, direction: Direction)

Trait Implementations

impl<Q, A, R, B> Add<Head<Q, A>> for Tail<R, B>

where Q: RawState, R: RawState,

type Output = Rule<Q, A, R, B>

The resulting type after applying the + operator.

fn add(self, rhs: Head<Q, A>) -> <Tail<R, B> as Add<Head<Q, A>>>::Output

Performs the + operation.

impl<Q, A, R, B> Add<Tail<R, B>> for Head<Q, A>

where Q: RawState, R: RawState,

type Output = Rule<Q, A, R, B>

The resulting type after applying the + operator.

fn add(self, rhs: Tail<R, B>) -> <Head<Q, A> as Add<Tail<R, B>>>::Output

Performs the + operation.

impl<Q, S> AsMut<Head<Q, S>> for Rule<Q, S>

where Q: RawState,

fn as_mut(&mut self) -> &mut Head<Q, S>

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

impl<Q, S> AsRef<Head<Q, S>> for Rule<Q, S>

where Q: RawState,

fn as_ref(&self) -> &Head<Q, S>

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

impl<Q, S> Borrow<Head<Q, S>> for Rule<Q, S>

where Q: RawState,

fn borrow(&self) -> &Head<Q, S>

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, S> BorrowMut<Head<Q, S>> for Rule<Q, S>

where Q: RawState,

fn borrow_mut(&mut self) -> &mut Head<Q, S>

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> Clone for Head<Q, A>

where Q: Clone, A: Clone,

fn clone(&self) -> Head<Q, A>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Q, A> Debug for Head<Q, A>

where Q: Debug, A: Debug,

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

Formats the value using the given formatter.

impl<Q, A> Default for Head<Q, A>

where Q: Default, A: Default,

fn default() -> Head<Q, A>

Returns the “default value” for a type.

impl<Q, A> Display for Head<Q, A>

where Q: Display, A: Display,

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

Formats the value using the given formatter.

impl<Q, A> Driver<Q, A> for Head<Q, usize>

where Q: RawState, Head<Q, usize>: for<'a> Read<&'a mut [A], Output = &'a A>,

fn current_position(&self) -> usize

returns the current position of the driver.

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

returns a view of the current state of the driver.

impl<Q, S> From<(Q, S)> for Head<Q, S>

fn from(_: (Q, S)) -> Head<Q, S>

Converts to this type from the input type.

impl<Q, S> From<(State<Q>, S)> for Head<Q, S>

fn from(_: (State<Q>, S)) -> Head<Q, S>

Converts to this type from the input type.

impl<Q, S> From<S> for Head<Q, S>

where Q: Default,

fn from(symbol: S) -> Head<Q, S>

Converts to this type from the input type.

impl<Q, A> Hash for Head<Q, A>

where Q: Hash, A: Hash,

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, A> HeadRepr for Head<Q, A>

where Q: RawState,

fn new(state: Q, symbol: A) -> Head<Q, A>

creates a new head from the given state and symbol

fn from_state(state: Self::State) -> Self

where Self::Symbol: Default,

create a new head from the given state, using a default symbol

fn from_symbol(symbol: Self::Symbol) -> Self

where Self::State: Default,

create a new head from the given symbol, using a default state

impl<Q, A> Index<Head<Q, A>> for InstructionSet<Q, A>

where Q: RawState + PartialEq, A: PartialEq,

type Output = Tail<Q, A>

The returned type after indexing.

fn index( &self, index: Head<Q, A>, ) -> &<InstructionSet<Q, A> as Index<Head<Q, A>>>::Output

Performs the indexing (container[index]) operation.

impl<Q, A> Ord for Head<Q, A>

where Q: Ord, A: Ord,

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

where State<Q>: PartialEq, Q: PartialEq, A: PartialEq,

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

where Q: PartialEq, A: PartialEq,

fn eq(&self, _: &(State<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, 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, S> PartialEq<Head<Q, S>> for Rule<Q, S>

where Q: RawState + PartialEq, S: PartialEq,

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

where Q: PartialEq, A: PartialEq,

fn eq(&self, other: &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> PartialOrd for Head<Q, A>

where Q: PartialOrd, A: PartialOrd,

fn partial_cmp(&self, other: &Head<Q, A>) -> 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, A> RawHead for Head<Q, A>

where Q: RawState,

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

returns an immutable reference to the state.

fn symbol(&self) -> &A

returns an immutable reference to the symbol.

type State = Q

type Symbol = A

impl<Q, A> RawHeadMut for Head<Q, A>

where Q: RawState,

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

returns a mutable reference to the state.

fn symbol_mut(&mut self) -> &mut A

returns a mutable reference to the symbol.

impl<'a, Q, A> Read<&'a [A]> for &Head<Q, usize>

where Q: RawState,

type Output = &'a A

type Error = Error

fn read( self, rhs: &'a [A], ) -> Result<<&Head<Q, usize> as Read<&'a [A]>>::Output, <&Head<Q, usize> as Read<&'a [A]>>::Error>

impl<'a, Q, A> Read<&'a [A]> for &mut Head<Q, usize>

where Q: RawState,

type Output = &'a A

type Error = Error

fn read( self, rhs: &'a [A], ) -> Result<<&mut Head<Q, usize> as Read<&'a [A]>>::Output, <&mut Head<Q, usize> as Read<&'a [A]>>::Error>

impl<'a, Q, A> Read<&'a [A]> for Head<Q, usize>

where Q: RawState,

type Output = &'a A

type Error = Error

fn read( self, rhs: &'a [A], ) -> Result<<Head<Q, usize> as Read<&'a [A]>>::Output, <Head<Q, usize> as Read<&'a [A]>>::Error>

impl<'a, Q, A> Read<&'a mut [A]> for &Head<Q, usize>

where Q: RawState,

type Error = Error

type Output = &'a A

fn read( self, rhs: &'a mut [A], ) -> Result<<&Head<Q, usize> as Read<&'a mut [A]>>::Output, <&Head<Q, usize> as Read<&'a mut [A]>>::Error>

impl<'a, Q, A> Read<&'a mut [A]> for &mut Head<Q, usize>

where Q: RawState,

type Error = Error

type Output = &'a A

fn read( self, rhs: &'a mut [A], ) -> Result<<&mut Head<Q, usize> as Read<&'a mut [A]>>::Output, <&mut Head<Q, usize> as Read<&'a mut [A]>>::Error>

impl<'a, Q, A> Read<&'a mut [A]> for Head<Q, usize>

where Q: RawState,

type Output = &'a A

type Error = Error

fn read( self, rhs: &'a mut [A], ) -> Result<<Head<Q, usize> as Read<&'a mut [A]>>::Output, <Head<Q, usize> as Read<&'a mut [A]>>::Error>

impl<Q, A, T> ReadBuf<T> for Head<Q, A>

where Q: RawState, A: Copy + SliceIndex<[T], Output = T>, <A as SliceIndex<[T]>>::Output: Clone,

type Buf<_T> = [_T]

type Output = <A as SliceIndex<[T]>>::Output

fn read( &mut self, rhs: &mut <Head<Q, A> as ReadBuf<T>>::Buf<T>, ) -> <Head<Q, A> as ReadBuf<T>>::Output

impl<Q, A> Copy for Head<Q, A>

where Q: Copy, A: Copy,

impl<Q, A> Eq for Head<Q, A>

where Q: Eq, A: Eq,

impl<Q, A> StructuralPartialEq for Head<Q, A>