Enum glsp::Deque

pub enum Deque {
    Arr(Root<Arr>),
    Str(Root<Str>),
}

A type-erased deque.

Because this type implements the DequeOps trait, you can manipulate it directly, without needing to access the underlying Root<Arr> or Root<Str>.

Variants

Arr(Root<Arr>)

Str(Root<Str>)

Implementations

impl Deque

pub fn same(&self, other: &Deque) -> bool

Returns true if both deques share the same identity.

Equivalent to (same? deq other).

pub fn shallow_clone(&self) -> Deque

Creates a shallow copy of the deque.

Equivalent to (clone deq).

pub fn deep_clone(&self) -> Result<Deque, GError>

Recursively copies the deque and all of its contents.

Equivalent to (deep-clone deq).

pub fn access_giter(&self, giter: &Root<GIter>) -> Root<GIter>

Creates an indexing iterator for this collection.

Equivalent to [deq iter].

Trait Implementations

impl Clone for Deque

fn clone(&self) -> Deque

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Deque

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

Formats the value using the given formatter.

impl<I> DequeAccess<I> for Deque where
    I: DequeIndex, 

fn get<R>(&self, i: I) -> Result<R, GError> where
    R: FromElement<Slot>, 

Accesses an element in the deque.

fn set<V>(&self, i: I, v: V) -> Result<(), GError> where
    V: IntoElement<Slot>, 

Mutates an element in the deque.

fn insert<V>(&self, i: I, v: V) -> Result<(), GError> where
    V: IntoElement<Slot>, 

Inserts an element into the deque at the given index.

fn del(&self, i: I) -> Result<(), GError>

Deletes an element from the deque, without returning it.

fn remove<R>(&self, i: I) -> Result<R, GError> where
    R: FromElement<Slot>, 

Removes an element from the deque and returns it.

fn swap_remove<R>(&self, i: I) -> Result<R, GError> where
    R: FromElement<Slot>, 

Swaps an element with the last element, removes it, and returns it.

fn swap_remove_start<R>(&self, i: I) -> Result<R, GError> where
    R: FromElement<Slot>, 

Swaps an element with the first element, removes it, and returns it.

impl<I, R> DequeAccessRange<I, R> for Deque where
    I: DequeIndex,
    R: DequeRange<I> + Debug, 

fn del_slice(&self, r: R) -> Result<(), GError>

Removes multiple elements from the deque.

impl DequeOps for Deque

type Element = Slot

type Item = Val

fn freeze(&self)

Makes the deque immutable.

fn deep_freeze(&self)

Makes the deque and all of its contents immutable.

fn is_frozen(&self) -> bool

Returns true if the deque has been frozen.

fn is_deep_frozen(&self) -> bool

Returns true if the deque and all of its contents have been frozen.

fn can_mutate(&self) -> bool

Returns true if it's possible to mutate the deque without triggering an error.

fn swap<I1, I2>(&self, i: I1, j: I2) -> Result<(), GError> where
    I1: DequeIndex,
    I2: DequeIndex, 

Swaps two of the deque's elements.

fn len(&self) -> usize

Returns the deque's length.

fn contains<V>(&self, v: V) -> Result<bool, GError> where
    V: IntoElement<Slot>, 

Tests whether the deque contains an element which compares eq? to the argument.

fn push<V>(&self, v: V) -> Result<(), GError> where
    V: IntoElement<Slot>, 

Pushes an element to the end of the deque.

fn pop<R>(&self) -> Result<R, GError> where
    R: FromElement<Slot>, 

Pops an element from the end of the deque.

fn push_start<V>(&self, v: V) -> Result<(), GError> where
    V: IntoElement<Slot>, 

Pushes an element to the beginning of the deque.

fn pop_start<R>(&self) -> Result<R, GError> where
    R: FromElement<Slot>, 

Pops an element from the beginning of the deque.

fn grow<V>(&self, start: usize, end: usize, fill: V) -> Result<(), GError> where
    V: IntoElement<Slot>, 

Increases the deque's size.

fn shrink(&self, start: usize, end: usize) -> Result<(), GError>

Decreases the deque's size.

fn append(&self, _other: &Deque) -> Result<(), GError>

Pushes the contents of another deque onto the end of this one.

fn prepend(&self, _other: &Deque) -> Result<(), GError>

Pushes the contents of another deque onto the beginning of this one.

fn resize<V>(&self, new_len: usize, fill: V) -> Result<(), GError> where
    V: IntoElement<Slot>, 

Resizes the deque.

fn rotate_left(&self, mid: usize) -> Result<(), GError>

Rotates the deque to the left

fn rotate_right(&self, k: usize) -> Result<(), GError>

Rotates the deque to the right.

fn capacity(&self) -> usize

Returns the deque's storage capacity.

fn reserve_exact(&self, additional: usize) -> Result<(), GError>

Reserves enough space for exactly additional elements to be added to the deque.

fn reserve(&self, additional: usize) -> Result<(), GError>

Reserves enough space for at least additional elements to be added to the deque.

fn shrink_to_fit(&self) -> Result<(), GError>

Shrinks the capacity of the deque as much as possible.

fn truncate(&self, len: usize) -> Result<(), GError>

Reduces the deque's length.

fn clear(&self) -> Result<(), GError>

Removes all of the deque's elements.

fn extend<I, C>(&self, source: I) -> Result<(), GError> where
    C: IntoElement<Slot>,
    I: IntoIterator<Item = C>, 

Pushes the contents of an iterator onto the end of the deque.

fn is_empty(&self) -> bool

Returns true if the deque's length is 0.

fn iter(&'a self) -> IterDeque<'a, Self> where
    Self: DequeAccess<usize>, 

Creates an infallible iterator over this deque.

fn iter_to<R>(&'a self) -> IterDequeTo<'a, Self, R> where
    R: FromElement<Self::Element>,
    Self: DequeAccess<usize>, 

Creates a converting iterator over this deque.

impl FromVal for Deque

fn from_val(val: &Val) -> Result<Deque, GError>

fn from_slot(val: &Slot) -> Result<Deque, GError>

impl PartialEq<Deque> for Deque

fn eq(&self, other: &Deque) -> bool

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

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

This method tests for !=.

impl Splay for Deque

fn splay(&self, dst: &Arr) -> Result<(), GError>

impl StructuralPartialEq for Deque

impl ToVal for Deque

fn to_val(&self) -> Result<Val, GError>

fn to_slot(&self) -> Result<Slot, GError>