Struct glsp::Arr

pub struct Arr { /* fields omitted */ }

The arr primitive type.

Most of this type's methods belong to the deque abstract type, so they can be found in the traits DequeOps, DequeAccess, and DequeAccessRange.

New arrays can be constructed using the arr! macro or various toplevel functions, such as glsp::arr and glsp::arr_from_iter. Arrays are always stored on the garbage-collected heap, so they're normally represented by the type Root<Arr>.

Implementations

impl Arr

pub fn shallow_clone(&self) -> Root<Arr>

Creates a shallow copy of an array.

Equivalent to (clone ar).

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

Recursively copies an array and all of its contents.

Equivalent to (deep-clone ar).

pub fn try_eq(&self, other: &Arr) -> Result<bool, GError>

Equivalent to (eq? self other).

Note that, because this method may need to invoke an op-eq? method when one of its elements is an object or an RData, it can potentially fail.

The same is true for PartialEq comparisons between arrays using Rust's == operator. In that case, if an error occurs, the operator will panic.

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

Creates an indexing iterator for this collection.

Equivalent to [ar iter].

impl Arr

pub fn is_representable(&self) -> bool

Returns true if this array can be losslessly converted to text.

pub fn check_representability(&self) -> Result<(), &'static str>

Returns Ok if this array can be losslessly converted to text.

pub fn is_serializable(&self) -> bool

Returns true if this array can be serialized and deserialized using Serde.

This method is only present when the "serde" feature is enabled.

pub fn check_serializability(&self) -> Result<(), &'static str>

Returns Ok if this array can be serialized and deserialized using Serde.

This method is only present when the "serde" feature is enabled.

Trait Implementations

impl Debug for Arr

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

Formats the value using the given formatter.

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

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

Accesses an element in the deque.

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

Mutates an element in the deque.

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

Inserts an element into the deque at the given index.

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

Deletes an element from the deque, without returning it.

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

Removes an element from the deque and returns it.

pub fn swap_remove<R>(&self, index: 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, index: 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 Arr where
    R: DequeRange<I> + Debug,
    I: DequeIndex, 

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

Removes multiple elements from the deque.

impl DequeOps for Arr

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 can_mutate(&self) -> bool

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

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 push<V>(&self, val: 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, val: 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_to_add: usize,
    end_to_add: usize,
    fill: V
) -> Result<(), GError> where
    V: IntoElement<Slot>, 

Increases the deque's size.

pub fn shrink(
    &self,
    start_to_remove: usize,
    end_to_remove: usize
) -> Result<(), GError>

Decreases the deque's size.

pub fn append(&self, other: &Arr) -> Result<(), GError>

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

pub fn prepend(&self, other: &Arr) -> 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 swap<I1, I2>(&self, index1: I1, index2: I2) -> Result<(), GError> where
    I1: DequeIndex,
    I2: DequeIndex, 

Swaps two of the deque's elements.

pub fn capacity(&self) -> usize

Returns the deque's storage capacity.

pub fn len(&self) -> usize

Returns the deque's length.

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 contains<V>(&self, x: V) -> Result<bool, GError> where
    V: IntoElement<Slot>, 

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

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

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 Display for Arr

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

Formats the value using the given formatter.

impl Eq for Arr

impl Hash for Arr

pub fn hash<H>(&self, state: &mut H) where
    H: Hasher, 

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<'a> IntoIterator for &'a Arr

type Item = Val

The type of the elements being iterated over.

type IntoIter = IterDeque<'a, Arr>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> IterDeque<'a, Arr>

Creates an iterator from a value.

impl PartialEq<Arr> for Arr

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialOrd<Arr> for Arr

pub fn partial_cmp(&self, other: &Arr) -> Option<Ordering>

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

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

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

#[must_use]pub fn le(&self, other: &Rhs) -> bool

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

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

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

#[must_use]pub 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 Serialize for Arr

pub fn serialize<S>(
    &self,
    s: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl Splay for Arr

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