Struct contained_turing::Tape

pub struct Tape<S: Symbolic = String>(_);

Implementations

impl<S: Symbolic> Tape<S>

pub fn new() -> Self

pub fn norm(iter: impl IntoIterator<Item = S>) -> Self

Creates a new tape from an iterator; preserves the original order.

pub fn std(iter: impl IntoIterator<Item = S>) -> Self

Creates a new tape from an iterator; the tape is reversed.

pub fn with_capacity(capacity: usize) -> Self

Creates a new tape with the specified capacity.

pub fn write(&mut self, index: usize, symbol: S)

Trait Implementations

impl<S: Symbolic> ArrayLike<S> for Tape<S>

fn append(&mut self, elem: &mut Self)

ArrayLike::append describes a method for appending another array to the end of the array

fn as_slice(&self) -> &[T]

fn capacity(&self) -> usize

The capacity of the array

fn clear(&mut self)

ArrayLike::clear describes a method for clearing the array

fn contains(&self, elem: &T) -> bool

ArrayLike::contains describes a method for checking if an element is present in the array

fn count(&self, elem: &T) -> usize

ArrayLike::count describes a method for counting the number of times an element appears in the array

fn dedup(&mut self)

ArrayLike::dedup describes a method for removing duplicate elements from the array

fn dedup_by<F>(&mut self, same_bucket: F)where F: FnMut(&mut T, &mut T) -> bool,

ArrayLike::dedup_by describes a method for removing duplicate elements from the array using a custom comparison function

fn dedup_by_key<F, K>(&mut self, key: F)where F: FnMut(&mut T) -> K, K: PartialEq<K>,

ArrayLike::dedup_by_key describes a method for removing duplicate elements from the array using a custom key extraction function

fn drain(&mut self, range: Range<usize>) -> Drain<'_, T, Global>

ArrayLike::drain describes a method for removing a range of elements from the array

fn filter(&self, predicate: impl Fn(&T) -> bool) -> Vec<T, Global>

ArrayLike::filter describes a method for filtering the array

fn first(&self) -> Option<&T>

ArrayLike::first describes a method for getting a reference to the first element in the array

fn get(&self, index: usize) -> Option<&T>

ArrayLike::get describes a method for getting a reference to an element at a specific position

fn get_mut(&mut self, index: usize) -> Option<&mut T>

ArrayLike::get_mut describes a method for getting a mutable reference to an element at a specific position

fn is_empty(&self) -> bool

ArrayLike::is_empty checks if the array is empty

fn last(&self) -> Option<&T>

ArrayLike::last describes a method for gettings the last element in the array

fn len(&self) -> usize

ArrayLike::len describes a method for getting the length of the array

fn pop(&mut self) -> Option<T>

ArrayLike::pop describes a method for removing the last element from the array

fn push(&mut self, elem: T)

ArrayLike::push describes a method for adding an element to the end of the array

fn remove(&mut self, index: usize) -> T

ArrayLike::remove describes a method for removing an element at a specific position

fn reverse(&mut self)

fn set(&mut self, index: usize, elem: T)

ArrayLike::set describes a method for setting the value of an element at a specific position

fn shrink_to(&mut self, min_capacity: usize)

ArrayLike::shrink_to describes a method for shrinking the capacity of the array to a specific minimum

fn shrink_to_fit(&mut self)

ArrayLike::shrink_to_fit describes a method for shrinking the capacity of the array to match its length

fn splice( &mut self, range: Range<usize>, replace_with: Vec<T, Global> ) -> Vec<T, Global>

ArrayLike::splice describes a method for removing a range of elements and replacing them with another array

fn split_off(&mut self, at: usize) -> Vec<T, Global>

ArrayLike::split_off describes a method for splitting the array into two at a specific position

fn swap_remove(&mut self, index: usize) -> T

ArrayLike::swap_remove describes a method for removing an element at a specific position and returning it, replacing it with the last element

fn truncate(&mut self, len: usize)

ArrayLike::truncate describes a method for truncating the array to a specific length

impl<S: Symbolic> AsMut<Vec<S, Global>> for Tape<S>

fn as_mut(&mut self) -> &mut Vec<S>

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

impl<S: Symbolic> AsRef<Vec<S, Global>> for Tape<S>

fn as_ref(&self) -> &Vec<S>

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

impl<S: Clone + Symbolic> Clone for Tape<S>

fn clone(&self) -> Tape<S>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: Debug + Symbolic> Debug for Tape<S>

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

Formats the value using the given formatter.

impl<S: Default + Symbolic> Default for Tape<S>

fn default() -> Tape<S>

Returns the “default value” for a type.

impl<'de, S> Deserialize<'de> for Tape<S>where S: Deserialize<'de> + Symbolic,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<S: Symbolic> Extend<S> for Tape<S>

fn extend<T: IntoIterator<Item = S>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<S: Symbolic> From<Tape<S>> for Driver<S>

fn from(tape: Tape<S>) -> Self

Converts to this type from the input type.

impl<S: Symbolic> From<Tape<S>> for Vec<S>

fn from(tape: Tape<S>) -> Vec<S>

Converts to this type from the input type.

impl<S: Symbolic> FromIterator<S> for Tape<S>

fn from_iter<T: IntoIterator<Item = S>>(iter: T) -> Self

Creates a value from an iterator.

impl<S: Hash + Symbolic> Hash for Tape<S>

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<S: Symbolic> Index<usize> for Tape<S>

type Output = S

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<S: Symbolic> IndexMut<usize> for Tape<S>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<S: Symbolic> Insert<usize, S> for Tape<S>

fn insert(&mut self, index: usize, elem: S)

impl<S: Symbolic> IntoIterator for Tape<S>

type Item = S

The type of the elements being iterated over.

type IntoIter = IntoIter<S, Global>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<S: Ord + Symbolic> Ord for Tape<S>

fn cmp(&self, other: &Tape<S>) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<S: PartialEq + Symbolic> PartialEq<Tape<S>> for Tape<S>

fn eq(&self, other: &Tape<S>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<S: PartialOrd + Symbolic> PartialOrd<Tape<S>> for Tape<S>

fn partial_cmp(&self, other: &Tape<S>) -> Option<Ordering>

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl<S> Serialize for Tape<S>where S: Serialize + Symbolic,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<S: Eq + Symbolic> Eq for Tape<S>

impl<S: Symbolic> Iterable<usize, S> for Tape<S>

impl<S: Symbolic> StructuralEq for Tape<S>

impl<S: Symbolic> StructuralPartialEq for Tape<S>