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

pub fn clone(&self) -> Deque

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Deque

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

Formats the value using the given formatter.

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

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

Accesses an element in the deque.

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

Mutates an element in the deque.

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

Inserts an element into the deque at the given index.

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

Deletes an element from the deque, without returning it.

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

Removes an element from the deque and returns it.

pub 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.

pub 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
    R: DequeRange<I> + Debug,
    I: DequeIndex, 

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

Removes multiple elements from the deque.

impl DequeOps for Deque

type Element = Slot

type Item = Val

pub fn freeze(&self)

Makes the deque immutable.

pub fn deep_freeze(&self)

Makes the deque and all of its contents immutable.

pub fn is_frozen(&self) -> bool

Returns true if the deque has been frozen.

pub fn is_deep_frozen(&self) -> bool

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

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

Sorts the deque, in place. Elements are compared using Val::partial_cmp. If the deque contains any two elements which are unordered relative to one another (for example, an integer and a symbol), an error may occur.

pub fn sort_by<F>(&self, f: F) -> Result<(), GError> where
    F: FnMut(&Val, &Val) -> Result<Ordering, GError>, 

Sorts the deque, in place, using the specified comparison function. If the comparison function returns an error, the sort_by call will return an error.

pub fn can_mutate(&self) -> bool

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

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

Swaps two of the deque's elements.

pub fn len(&self) -> usize

Returns the deque's length.

pub 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.

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

Pushes an element to the end of the deque.

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

Pops an element from the end of the deque.

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

Pushes an element to the beginning of the deque.

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

Pops an element from the beginning of the deque.

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

Increases the deque's size.

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

Decreases the deque's size.

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

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

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

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

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

Resizes the deque.

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

Rotates the deque to the left

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

Rotates the deque to the right.

pub fn capacity(&self) -> usize

Returns the deque's storage capacity.

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

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

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

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

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

Shrinks the capacity of the deque as much as possible.

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

Reduces the deque's length.

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

Removes all of the deque's elements.

pub 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.

pub fn is_empty(&self) -> bool

Returns true if the deque's length is 0.

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

Creates an infallible iterator over this deque.

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

Creates a converting iterator over this deque.

impl FromVal for Deque

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

impl<'a> IntoVal for &'a Deque

pub fn into_val(self) -> Result<Val, GError>

impl<'a> IntoVal for &'a mut Deque

pub fn into_val(self) -> Result<Val, GError>

impl IntoVal for Deque

pub fn into_val(self) -> Result<Val, GError>

impl PartialEq<Deque> for Deque

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

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

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

This method tests for !=.

impl Splay for Deque

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

impl StructuralPartialEq for Deque