Struct glsp::Str

pub struct Str { /* fields omitted */ }

The str 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 strings can be constructed using the str! macro or various toplevel functions, such as glsp::str and glsp::str_from_iter. Strings are always stored on the garbage-collected heap, so they're normally represented by the type Root<Str>.

Implementations

impl Str

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

Creates a new string with a copy of this string's contents.

Equivalent to (clone st).

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

Creates an indexing iterator for this collection.

Equivalent to [st iter].

pub fn push_rust_str(&self, s: &str) -> Result<(), GError>

Pushes all of the characters from a &str to the end of this string.

Trait Implementations

impl Debug for Str

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

Formats the value using the given formatter.

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

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

Accesses an element in the deque.

pub fn set<C>(&self, index: I, ch: C) -> Result<(), GError> where
    C: IntoElement<char>, 

Mutates an element in the deque.

pub fn insert<C>(&self, index: I, ch: C) -> Result<(), GError> where
    C: IntoElement<char>, 

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<char>, 

Removes an element from the deque and returns it.

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

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<char>, 

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

impl<I, R> DequeAccessRange<I, R> for Str 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 Str

type Element = char

type Item = char

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(&char, &char) -> 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<C>(&self, ch: C) -> Result<(), GError> where
    C: IntoElement<char>, 

Pushes an element to the end of the deque.

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

Pops an element from the end of the deque.

pub fn push_start<C>(&self, ch: C) -> Result<(), GError> where
    C: IntoElement<char>, 

Pushes an element to the beginning of the deque.

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

Pops an element from the beginning of the deque.

pub fn grow<C>(
    &self,
    start_to_add: usize,
    end_to_add: usize,
    fill: C
) -> Result<(), GError> where
    C: IntoElement<char>, 

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: &Str) -> Result<(), GError>

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

pub fn prepend(&self, other: &Str) -> Result<(), GError>

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

pub fn resize<C>(&self, new_len: usize, ch: C) -> Result<(), GError> where
    C: IntoElement<char>, 

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, i_index: I1, j_index: 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<C>(&self, ch: C) -> Result<bool, GError> where
    C: IntoElement<char>, 

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

pub fn extend<I, C>(&self, source: I) -> Result<(), GError> where
    C: IntoElement<char>,
    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 Display for Str

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

Formats the value using the given formatter.

impl Eq for Str

impl Hash for Str

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 Str

type Item = char

The type of the elements being iterated over.

type IntoIter = IterDeque<'a, Str>

Which kind of iterator are we turning this into?

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

Creates an iterator from a value.

impl Ord for Str

pub fn cmp(&self, other: &Str) -> Ordering

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq<Str> for Str

pub fn eq(&self, other: &Str) -> 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<Str> for Str

pub fn partial_cmp(&self, other: &Str) -> 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 Str

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 Str

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

impl<'a> ToSym for Str

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