Struct Span 

pub struct Span<T> {
    pub start: usize,
    pub end: usize,
    /* private fields */
}

A window in a [T] sequence.

Note that the range covered by a Span is end-exclusive, meaning that the end index is not included in the range covered by the Span. If you’re familiar with the Rust range syntax, you could say the span covers the equivalent of start..end, not start..=end.

For a Span to be correct, its end index must be greater than or equal to its start index. Creating or using a Span which does not follow this rule may lead to unexpected behavior or panics.

Although specific to harper.js, this page may clear up any questions you have.

Fields

start: usize

The start index of the span.

end: usize

The end index of the span.

Note that Span represents an exclusive range. This means that a Span::new(0, 5) will cover the values 0, 1, 2, 3, 4; it will not cover the 5.

Implementations

impl<T> Span<T>

pub const ZERO: Self

A Span with a start and end index of 0.

pub fn new(start: usize, end: usize) -> Self

Creates a new Span with the provided start and end indices.

Panics

This will panic if start is greater than end.

pub fn new_with_len(start: usize, len: usize) -> Self

Creates a new Span from the provided start position and length.

pub const fn empty(pos: usize) -> Self

Creates a new empty Span with the provided position.

pub fn len(&self) -> usize

The length of the Span.

pub fn is_empty(&self) -> bool

Checks whether the Span is empty.

A Span is considered empty if it has a length of 0.

pub fn contains(&self, idx: usize) -> bool

Checks whether idx is within the range of the span.

pub fn overlaps_with(&self, other: Self) -> bool

Checks whether this span’s range overlaps with other.

pub fn try_get_content<'a>(&self, source: &'a [T]) -> Option<&'a [T]>

Get the associated content. Will return None if the span is non-empty and any aspect is invalid.

pub fn expand_to_include(&mut self, target: usize)

Expand the span by either modifying Self::start or Self::end to include the target index.

Does nothing if the span already includes the target.

pub fn get_content<'a>(&self, source: &'a [T]) -> &'a [T]

Get the associated content. Will panic if any aspect is invalid.

pub fn set_len(&mut self, length: usize)

Set the span’s length.

pub fn with_len(&self, length: usize) -> Self

Returns a copy of this Span with a new length.

pub fn push_by(&mut self, by: usize)

Add an amount to both Self::start and Self::end

pub fn pull_by(&mut self, by: usize)

Subtract an amount from both Self::start and Self::end

pub fn pushed_by(&self, by: usize) -> Self

Add an amount to a copy of both Self::start and Self::end

pub fn pulled_by(&self, by: usize) -> Option<Self>

Subtract an amount to a copy of both Self::start and Self::end

impl<T: Display + Debug> Span<T>

Additional functions for types that implement std::fmt::Debug and Display.

pub fn get_content_string(&self, source: &[T]) -> String

Gets the content of this Span<T> as a String.

impl Span<Token>

Functionality specific to Token spans.

pub fn to_char_span(&self, source_document_tokens: &[Token]) -> Span<char>

Converts the Span<Token> into a Span<char>.

This requires knowing the character spans of the tokens covered by this Span<Token>. Because of this, a reference to the source token sequence used to create this span is required.

Trait Implementations

impl<T> Clone for Span<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Span<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Span<T>

fn default() -> Span<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Span<T>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> From<Range<usize>> for Span<T>

fn from(value: Range<usize>) -> Self

Reinterprets the provided std::ops::Range as a Span.

impl<T> From<Span<T>> for Range<usize>

fn from(value: Span<T>) -> Self

Converts the Span to an std::ops::Range.

impl FromIterator<Span<char>> for Mask

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

Creates a value from an iterator.

impl<T> IntoIterator for Span<T>

fn into_iter(self) -> Self::IntoIter

Converts the Span into an iterator that yields the indices covered by its range.

Note that Span is half-open, meaning that the value Self::end will not be yielded by this iterator: it will stop at the index immediately preceding Self::end.

type Item = usize

The type of the elements being iterated over.

type IntoIter = Range<usize>

Which kind of iterator are we turning this into?

impl<T: PartialEq> PartialEq for Span<T>

fn eq(&self, other: &Span<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<T> Serialize for Span<T>

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> Copy for Span<T>

impl<T: Eq> Eq for Span<T>

impl<T> StructuralPartialEq for Span<T>