Struct Actor

pub struct Actor<Q, A> { /* private fields */ }

An Actor is an implementation of a Turing machine with a moving head (TMH).

The model contains the following components:

• alpha: the input alphabet
• head: the head of the tape

Implementations

impl<Q, A> Actor<Q, A>

where Q: RawState,

pub fn new( alpha: impl IntoIterator<Item = A>, state: State<Q>, symbol: usize, ) -> Self

pub fn from_state(state: State<Q>) -> Self

Constructs a new Actor with the given state; assumes the tape is empty and the head is located at 0.

pub const fn head(&self) -> &Head<Q, usize>

returns an immutable reference to the head of the tape

pub const fn head_mut(&mut self) -> &mut Head<Q, usize>

returns a mutable reference to the head of the tape

pub const fn tape(&self) -> &Vec<A>

returns an immutable reference to the tape

pub const fn tape_mut(&mut self) -> &mut Vec<A>

returns a mutable reference of the tape

pub fn set_head(&mut self, head: Head<Q, usize>) -> &mut Self

update the current head and return a mutable reference to the actor

pub fn set_position(&mut self, symbol: usize) -> &mut Self

updates the current position of the head and returns a mutable reference to the actor

pub fn set_state(&mut self, state: State<Q>) -> &mut Self

updates the current state of the head and returns a mutable reference to the actor

pub fn set_tape(&mut self, tape: Vec<A>) -> &mut Self

update the current tape and return a mutable reference to the actor

pub fn with_head(self, head: Head<Q, usize>) -> Self

Consumes the current instance and returns a new instance with the given head

pub fn with_position(self, symbol: usize) -> Self

Consumes the current instance and returns a new instance with the given position

pub fn with_state(self, state: State<Q>) -> Self

Consumes the current instance and returns a new instance with the given state

pub fn with_tape<I>(self, alpha: I) -> Self

where I: IntoIterator<Item = A>,

Consumes the current instance and returns a new instance with the given alphabet

pub fn head_ref(&self) -> Head<&Q, usize>

returns an instance of the Head with an immutable reference to the state’s inner value

pub fn position(&self) -> usize

returns the current position of the head on the tape

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

returns an instance of the state with an immutable reference to the inner value

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

returns an instance of the state with a mutable reference to the inner value

pub fn execute(self, program: RuleSet<Q, A>) -> Executor<Q, A>

Executes the given program; the method is lazy, meaning it will not compute immediately but will return an Executor that is better suited for managing the runtime.

pub fn is_empty(&self) -> bool

Checks if the tape is empty

pub fn is_halted(&self) -> bool

where Q: 'static,

Checks if the tape is halted

pub fn len(&self) -> usize

returns the length of the tape

pub fn read(&self) -> Result<Head<&Q, &A>>

Reads the current symbol at the head of the tape

pub fn write(&mut self, value: A)

Writes the given symbol to the tape

Trait Implementations

impl<Q: Clone, A: Clone> Clone for Actor<Q, A>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Q, S> Debug for Actor<Q, S>

where Q: RawState, S: Debug,

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

Formats the value using the given formatter.

impl<Q: Default, A: Default> Default for Actor<Q, A>

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

Returns the “default value” for a type.

impl<Q, S> Display for Actor<Q, S>

where Q: RawState, S: Display,

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

Formats the value using the given formatter.

impl<Q, S> Handle<(Direction, Head<Q, S>)> for Actor<Q, S>

where Q: RawState + Clone + PartialEq, S: Symbolic,

type Output = Head<Q, usize>

fn handle(&mut self, (direction, _): (Direction, Head<Q, S>)) -> Self::Output

impl<Q, S> Handle<(Direction, State<Q>, S)> for Actor<Q, S>

where Q: RawState + Clone + PartialEq, S: Symbolic,

type Output = Head<Q, usize>

fn handle( &mut self, (direction, state, symbol): (Direction, State<Q>, S), ) -> Self::Output

impl<Q, S> Handle<Tail<Q, S>> for Actor<Q, S>

where Q: RawState + Clone + PartialEq, S: Symbolic,

type Output = Head<Q, usize>

fn handle(&mut self, _: Tail<Q, S>) -> Self::Output

impl<Q: Hash, A: Hash> Hash for Actor<Q, A>

fn hash<__H: Hasher>(&self, state: &mut __H)

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: PartialEq, A: PartialEq> PartialEq for Actor<Q, A>

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

fn partial_cmp(&self, other: &Actor<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: Eq, A: Eq> Eq for Actor<Q, A>

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