locspan

https://docs.rs/locspan/0.9.2/locspan/
Admin
locspan is a Rust library that provides essential types and traits for locating syntax elements in...
Tokens:9,432
Snippets:146
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Span::new

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Creates a new Span with the specified start and end byte positions. If the end position is less than the start position, the start position is used as the end position.

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

Creates a new `Span` by providing the index of its starting byte (included) and ending byte (excluded).
If the `end` position is lower than the `start` position, then the `start` position is used as ending position instead.
```

--------------------------------

### Create a new Span

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Creates a new Span with specified start and end byte positions. If the end position is less than the start, the start position is used as the end.

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

--------------------------------

### Index<Span> for String

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Allows indexing a `String` with a `Span` to get a string slice.

```APIDOC
### impl Index<Span> for String

#### type Output = str

The returned type after indexing.

#### fn index(&self, span: Span) -> &str

Performs the indexing (`container[index]`) operation.
```

--------------------------------

### Index<Span> for str

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Allows indexing a string slice (`str`) with a `Span` to get a string slice.

```APIDOC
### impl Index<Span> for str

#### type Output = str

The returned type after indexing.

#### fn index(&self, span: Span) -> &str

Performs the indexing (`container[index]`) operation.
```

--------------------------------

### Get the next empty Span

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Returns a new, empty span that starts immediately after the end of the current span.

```rust
pub fn next(&self) -> Self
```

--------------------------------

### Get the size of a Span in bytes

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Calculates and returns the size of the span in bytes.

```rust
pub fn len(&self) -> usize
```

--------------------------------

### IndexMut<Span> for String

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Allows mutable indexing of a `String` with a `Span` to get a mutable string slice.

```APIDOC
### impl IndexMut<Span> for String

#### fn index_mut(&mut self, span: Span) -> &mut str

Performs the mutable indexing (`container[index]`) operation.
```

--------------------------------

### Index String with Span

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Allows indexing a String using a Span to get a string slice corresponding to that byte range.

```rust
type Output = str
```

```rust
fn index(&self, span: Span) -> &str
```

--------------------------------

### Span::next

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Returns the next span, which is an empty span starting at the end of the current span.

```APIDOC
### pub fn next(&self) -> Self

Return the “next” span: the empty span starting at the end of this one.
```

--------------------------------

### Get the byte range of a Span

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Returns the standard Rust Range<usize> representation of the span.

```rust
pub fn range(&self) -> Range<usize>
```

--------------------------------

### TypeId

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Gets the TypeId of the Location struct.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`

### Parameters
None

### Returns
`TypeId`
```

--------------------------------

### Span::clear

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Clears the span by setting its start position to its end position.

```APIDOC
### pub fn clear(&mut self)

Clear the span by moving its start position to its end position.
```

--------------------------------

### IndexMut<Span> for str

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Allows mutable indexing of a string slice (`str`) with a `Span` to get a mutable string slice.

```APIDOC
### impl IndexMut<Span> for str

#### fn index_mut(&mut self, span: Span) -> &mut str

Performs the mutable indexing (`container[index]`) operation.
```

--------------------------------

### Span::is_empty

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Checks if the span is empty. Returns true if the start and end positions are equal.

```APIDOC
### pub fn is_empty(&self) -> bool

Checks if the span is empty.
Returns `true` if the start position is equal to the end position, and `false` otherwise. The end position can never be lower than the start position.
```

--------------------------------

### Span Struct Definition

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Defines the structure of a Span, including its start and end byte positions.

```APIDOC
## Struct Span

```rust
pub struct Span {
    pub start: usize,
    pub end: usize,
}
```

Range of bytes in a source file. This is very similar to the `Range<usize>` type unless it is not an iterator and implements the `Copy` trait.
```

--------------------------------

### Located Trait Implementor for Location<F>

Source: https://docs.rs/locspan/0.9.2/locspan/trait.Located.html

Example of implementing the Located trait for the Location<F> type itself. This indicates that a Location object is inherently 'located' within a file of type F.

```rust
impl<F> Located for Location<F> {
    type File = F;

    // Required method
    fn location(&self) -> Location<&Self::File> {
        self
    }
}
```

--------------------------------

### Get Minimum of Two Locations

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Compares two Location values and returns the minimum. This requires the file type `F` to implement `Ord`.

```rust
fn min(self, other: Self) -> Self
where Self: Sized
```

--------------------------------

### Clear a Span

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Resets the span to an empty state by setting its start position equal to its end position.

```rust
pub fn clear(&mut self)
```

--------------------------------

### Mutable Index String with Span

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Allows mutable indexing of a String using a Span to get a mutable string slice corresponding to that byte range.

```rust
fn index_mut(&mut self, span: Span) -> &mut str
```

--------------------------------

### Check if a Span is empty

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Determines if the span is empty. A span is considered empty if its start and end positions are equal.

```rust
pub fn is_empty(&self) -> bool
```

--------------------------------

### Get Maximum of Two Locations

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Compares two Location values and returns the maximum. This requires the file type `F` to implement `Ord`.

```rust
fn max(self, other: Self) -> Self
where Self: Sized
```

--------------------------------

### Span::inter

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Computes the intersection of two spans. If they don't overlap, returns an empty span at the start of the more advanced span.

```APIDOC
### pub fn inter(&self, other: Self) -> Self

Computes the intersection of two spans.
If the two spans do not overlap, then the empty span located at the start of the most advanced span (maximum of the start of the two spans) is returned.
```

--------------------------------

### Get Location from Located Trait

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Returns a `Location<&Self::File>` from a type implementing the `Located` trait. This is a standard method for accessing location information.

```rust
fn location(&self) -> Location<&Self::File>
```

--------------------------------

### Span Struct Definition

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Defines the structure of a Span, which represents a range of bytes in a source file. It includes start and end byte indices.

```rust
pub struct Span {
    pub start: usize,
    pub end: usize,
}
```

--------------------------------

### Check if an index is within a Span

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Verifies if a given byte index falls within the boundaries of the span (inclusive of start, exclusive of end).

```rust
pub fn contains(&self, index: usize) -> bool
```

--------------------------------

### Compute the intersection of two Spans

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Calculates the overlapping portion between the current span and another span. If there is no overlap, an empty span is returned at the start of the more advanced span.

```rust
pub fn inter(&self, other: Self) -> Self
```

--------------------------------

### CloneToUninit

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Performs copy-assignment from self to an uninitialized destination. This is a nightly-only experimental API.

```APIDOC
## unsafe fn clone_to_uninit(&self, dest: *mut u8)

### Description
Performs copy-assignment from `self` to `dest`.

### Method
`clone_to_uninit`

### Parameters
- `dest` (*mut u8) - A mutable pointer to the uninitialized destination.

### Returns
None
```

--------------------------------

### TryFrom

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Attempts to convert a value into the Location struct, returning a Result.

```APIDOC
## type Error = Infallible

### Description
The type returned in the event of a conversion error.

## fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

### Description
Performs the conversion.

### Method
`try_from`

### Parameters
- `value` (U) - The value to convert.

### Returns
Result<T, <T as TryFrom<U>>::Error> - A Result indicating success or failure.
```

--------------------------------

### Location::into_file

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Consumes this location and returns the file.

```APIDOC
#### pub fn into_file(self) -> F

Consumes this location and returns the file.
```

--------------------------------

### TryInto

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Attempts to convert the Location struct into another type, returning a Result.

```APIDOC
## type Error = <U as TryFrom<T>>::Error

### Description
The type returned in the event of a conversion error.

## fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion.

### Method
`try_into`

### Parameters
None

### Returns
Result<U, <U as TryFrom<T>>::Error> - A Result indicating success or failure.
```

--------------------------------

### Location::as_ref

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Copies the span and borrows the file to create a new `Location<&F>`.

```APIDOC
#### pub fn as_ref(&self) -> Location<&F>

Copies the span and borrows the file to create a new `Location<&F>`.
```

--------------------------------

### Into

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Converts the Location struct into another type.

```APIDOC
## fn into(self) -> U

### Description
Calls `U::from(self)`.
That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

### Method
`into`

### Parameters
None

### Returns
U - The converted value.
```

--------------------------------

### Partial Compare Locations

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Returns an `Option<Ordering>` between two Location values if one exists. This requires the file type `F` to implement `PartialOrd`.

```rust
fn partial_cmp(&self, other: &Location<F>) -> Option<Ordering>
```

--------------------------------

### Span Partial Ordering Methods

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Methods for partial ordering comparisons between Span instances.

```APIDOC
## fn partial_cmp(&self, other: &Span) -> Option<Ordering>

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

### Method
`partial_cmp`

### Parameters
- **other** (`&Span`) - The other Span to compare against.
```

```APIDOC
## fn lt(&self, other: &Rhs) -> bool

### Description
Tests less than (for `self` and `other`) and is used by the `<` operator.

### Method
`lt`

### Parameters
- **other** (`&Rhs`) - The other value to compare against.
```

```APIDOC
## fn le(&self, other: &Rhs) -> bool

### Description
Tests less than or equal to (for `self` and `other`) and is used by the `<=` operator.

### Method
`le`

### Parameters
- **other** (`&Rhs`) - The other value to compare against.
```

```APIDOC
## fn gt(&self, other: &Rhs) -> bool

### Description
Tests greater than (for `self` and `other`) and is used by the `>` operator.

### Method
`gt`

### Parameters
- **other** (`&Rhs`) - The other value to compare against.
```

```APIDOC
## fn ge(&self, other: &Rhs) -> bool

### Description
Tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator.

### Method
`ge`

### Parameters
- **other** (`&Rhs`) - The other value to compare against.
```

--------------------------------

### Location::new

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Creates a new location referring to the given span in the given file.

```APIDOC
### impl<F> Location<F>

#### pub fn new(file: F, span: Span) -> Self

Creates a new location referring to the given `span` in the given `file`.
```

--------------------------------

### Compare Locations for Ordering

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Compares two Location values and returns an `Ordering`. This requires the file type `F` to implement `Ord`.

```rust
fn cmp(&self, other: &Location<F>) -> Ordering
```

--------------------------------

### Check Location Equality

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Tests if two Location values are equal. This requires the file type `F` to implement `PartialEq`.

```rust
fn eq(&self, other: &Location<F>) -> bool
```

--------------------------------

### Convert Location File Type

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Converts the location to a new Location with a different file type, provided the original file type implements `Into<NewType>`. This is useful for type conversions.

```rust
pub fn cast<G>(self) -> Location<G>
where F: Into<G>
```

--------------------------------

### PartialOrd for Location

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Provides partial ordering comparison for the Location struct.

```APIDOC
### impl<F: PartialOrd> PartialOrd for Location<F>

#### fn partial_cmp(&self, other: &Location<F>) -> Option<Ordering>

This method returns an ordering between `self` and `other` values if one exists. Read more
1.0.0 · Source
#### fn lt(&self, other: &Rhs) -> bool

Tests less than (for `self` and `other`) and is used by the `<` operator. Read more
1.0.0 · Source
#### fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for `self` and `other`) and is used by the `<=` operator. Read more
1.0.0 · Source
#### fn gt(&self, other: &Rhs) -> bool

Tests greater than (for `self` and `other`) and is used by the `>` operator. Read more
1.0.0 · Source
#### fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for `self` and `other`) and is used by the `>=` operator. Read more
Source
```

--------------------------------

### Create New Location

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Creates a new location referring to the given span in the given file. This is the primary constructor for the Location struct.

```rust
pub fn new(file: F, span: Span) -> Self
```

--------------------------------

### Copy for Location

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Indicates that the Location struct is copyable.

```APIDOC
### impl<F: Copy> Copy for Location<F>
Source
```

--------------------------------

### impl<F> Located for Location<F>

Source: https://docs.rs/locspan/0.9.2/locspan/trait.Located.html

This implementation shows how the `Location` type itself implements the `Located` trait, allowing nested locations to be queried.

```APIDOC
## impl<F> Located for Location<F>

### Associated Types
#### type File = F

### Methods
#### fn location(&self) -> Location<&Self::File>
Returns the location of the `Location` itself.
```

--------------------------------

### From

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Converts a value into the Location struct.

```APIDOC
## fn from(t: T) -> T

### Description
Returns the argument unchanged.

### Method
`from`

### Parameters
- `t` (T) - The value to convert.

### Returns
T - The converted value.
```

--------------------------------

### Location::into_parts

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Consumes this location and returns a pair containing the file and span.

```APIDOC
#### pub fn into_parts(self) -> (F, Span)

Consumes this location and returns a pair containing the file and span.
```

--------------------------------

### Borrow

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Provides immutable borrowing capabilities for the Location struct.

```APIDOC
## fn borrow(&self) -> &T

### Description
Immutably borrows from an owned value.

### Method
`borrow`

### Parameters
None

### Returns
`&T` - An immutable reference to the borrowed value.
```

--------------------------------

### PartialEq for Location

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Provides partial equality comparison for the Location struct.

```APIDOC
### impl<F: PartialEq> PartialEq for Location<F>

#### fn eq(&self, other: &Location<F>) -> bool

Tests for `self` and `other` values to be equal, and is used by `==`.
1.0.0 · Source
#### fn ne(&self, other: &Rhs) -> bool

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

--------------------------------

### From<Span> for Range<usize>

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Converts a `Span` into a `Range<usize>`.

```APIDOC
### impl From<Span> for Range<usize>

#### fn from(span: Span) -> Self

Converts to this type from the input type.
```

--------------------------------

### Span Equality Methods

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Methods for testing equality between Span instances.

```APIDOC
## fn eq(&self, other: &Span) -> bool

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

### Method
`eq`

### Parameters
- **other** (`&Span`) - The other Span to compare against.
```

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

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

### Method
`ne`

### Parameters
- **other** (`&Rhs`) - The other value to compare against.
```

--------------------------------

### Test Location Less Than or Equal To

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Tests if the first Location is less than or equal to the second. This requires the file type `F` to implement `PartialOrd`.

```rust
fn le(&self, other: &Rhs) -> bool
```

--------------------------------

### Copy Span from source

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Performs copy-assignment from a source Span.

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

--------------------------------

### Span Comparison Methods

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Methods for comparing Span instances with other Spans.

```APIDOC
## fn cmp(&self, other: &Span) -> Ordering

### Description
This method returns an `Ordering` between `self` and `other`.

### Method
`cmp`

### Parameters
- **other** (`&Span`) - The other Span to compare against.
```

```APIDOC
## fn max(self, other: Self) -> Self

### Description
Compares and returns the maximum of two values.

### Method
`max`

### Parameters
- **other** (`Self`) - The other Span to compare.
```

```APIDOC
## fn min(self, other: Self) -> Self

### Description
Compares and returns the minimum of two values.

### Method
`min`

### Parameters
- **other** (`Self`) - The other Span to compare.
```

```APIDOC
## fn clamp(self, min: Self, max: Self) -> Self

### Description
Restrict a value to a certain interval.

### Method
`clamp`

### Parameters
- **min** (`Self`) - The minimum bound.
- **max** (`Self`) - The maximum bound.
```

--------------------------------

### Borrow Location as Reference

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Copies the span and borrows the file to create a new `Location<&F>`. This is useful for inspecting the location without consuming it or taking ownership of the file identifier.

```rust
pub fn as_ref(&self) -> Location<&F>
```

--------------------------------

### BorrowMut

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Provides mutable borrowing capabilities for the Location struct.

```APIDOC
## fn borrow_mut(&mut self) -> &mut T

### Description
Mutably borrows from an owned value.

### Method
`borrow_mut`

### Parameters
None

### Returns
`&mut T` - A mutable reference to the borrowed value.
```

--------------------------------

### MaybeSpanned

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Provides optional span information for the Location struct.

```APIDOC
## fn optional_span(&self) -> Option<Span>

### Description
Returns an optional span for the struct.

### Method
`optional_span`

### Parameters
None

### Returns
Option<Span> - An optional span.
```

--------------------------------

### Clone Borrowed File in Location

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Clones the borrowed file identifier to return a new `Location<F>`. This is useful when you have a `Location<&F>` and need an owned `Location<F>`.

```rust
pub fn cloned(&self) -> Location<F>
```

--------------------------------

### Clone for Location

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Provides cloning functionality for the Location struct.

```APIDOC
### impl<F: Clone> Clone for Location<F>

#### fn clone(&self) -> Location<F>

Returns a duplicate of the value. Read more
1.0.0 · Source
#### fn clone_from(&mut self, source: &Self)

Performs copy-assignment from `source`. Read more
Source
```

--------------------------------

### Test Location Greater Than or Equal To

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Tests if the first Location is greater than or equal to the second. This requires the file type `F` to implement `PartialOrd`.

```rust
fn ge(&self, other: &Rhs) -> bool
```

--------------------------------

### Test Location Less Than

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Tests if the first Location is less than the second. This requires the file type `F` to implement `PartialOrd`.

```rust
fn lt(&self, other: &Rhs) -> bool
```

--------------------------------

### Location<&F>::cloned

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Clones the borrowed file to return a new `Location<F>`.

```APIDOC
### impl<F: Clone> Location<&F>

#### pub fn cloned(&self) -> Location<F>

Clones the borrowed file to return a new `Location<F>`.
```

--------------------------------

### Extract File from Location

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Consumes this location and returns only the file identifier. Use this when you only need the file and the span is no longer required.

```rust
pub fn into_file(self) -> F
```

--------------------------------

### From<usize> for Span

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Converts a `usize` into a `Span`.

```APIDOC
### impl From<usize> for Span

#### fn from(pos: usize) -> Self

Converts to this type from the input type.
```

--------------------------------

### Eq for Location

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Indicates that the Location struct implements the Eq trait for total equality.

```APIDOC
### impl<F: Eq> Eq for Location<F>
Source
```

--------------------------------

### Span::append

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Extends the current span to include another span in-place.

```APIDOC
### pub fn append(&mut self, other: Self)

Extend this span to include `other`.
This is the _in-place_ version of `union`.
```

--------------------------------

### Generic Trait Implementations

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Common trait implementations applicable to Span.

```APIDOC
## fn type_id(&self) -> TypeId

### Description
Gets the `TypeId` of `self`.

### Method
`type_id`
```

```APIDOC
## fn borrow(&self) -> &T

### Description
Immutably borrows from an owned value.

### Method
`borrow`
```

```APIDOC
## unsafe fn clone_to_uninit(&self, dest: *mut u8)

### Description
Performs copy-assignment from `self` to `dest`. This is a nightly-only experimental API.

### Method
`clone_to_uninit`

### Parameters
- **dest** (`*mut u8`) - A mutable pointer to the destination memory.
```

```APIDOC
## fn from(t: T) -> T

### Description
Returns the argument unchanged.

### Method
`from`

### Parameters
- **t** (`T`) - The value to convert.
```

```APIDOC
## fn into(self) -> U

### Description
Calls `U::from(self)`. That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

### Method
`into`
```

```APIDOC
## fn to_owned(&self) -> T

### Description
Creates owned data from borrowed data, usually by cloning.

### Method
`to_owned`
```

```APIDOC
## fn clone_into(&self, target: &mut T)

### Description
Uses borrowed data to replace owned data, usually by cloning.

### Method
`clone_into`

### Parameters
- **target** (`&mut T`) - A mutable reference to the target to clone into.
```

```APIDOC
## fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

### Description
Performs the conversion.

### Method
`try_from`

### Parameters
- **value** (`U`) - The value to convert.
```

```APIDOC
## fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion.

### Method
`try_into`
```

--------------------------------

### StructuralPartialEq for Location

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Indicates structural partial equality for the Location struct.

```APIDOC
### impl<F> StructuralPartialEq for Location<F>
Source
```

--------------------------------

### Location::cast

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Converts the location, requiring the file type `F` to be convertible into `G`.

```APIDOC
#### pub fn cast<G>(self) -> Location<G>
where F: Into<G>,
Converts the location.
```

--------------------------------

### Check Location Inequality

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Tests if two Location values are not equal. This is the default implementation for `!=`.

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

--------------------------------

### Hash for Location

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Provides hashing capabilities for the Location struct.

```APIDOC
### impl<F: Hash> Hash for Location<F>

#### fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given `Hasher`. Read more
1.3.0 · Source
#### fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher,
Self: Sized,
Feeds a slice of this type into the given `Hasher`. Read more
Source
```

--------------------------------

### Format Span for Debug

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Formats the Span for debugging output using the given formatter.

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

--------------------------------

### Location::map

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Maps the file identifier using a provided function.

```APIDOC
#### pub fn map<G>(self, f: impl FnOnce(F) -> G) -> Location<G>

Maps the file identifier.
```

--------------------------------

### Location Struct Definition

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Defines the structure of the Location, which holds a file identifier and a span.

```APIDOC
## Struct Location

```rust
pub struct Location<F> {
    pub file: F,
    pub span: Span,
}
```

Syntax element location. Provides a file identifier (of type `F`) and a `Span` in this file.
```

--------------------------------

### Map File Identifier in Location

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Maps the file identifier within the Location using a provided closure. This allows transforming the file type without changing the span.

```rust
pub fn map<G>(self, f: impl FnOnce(F) -> G) -> Location<G>
```

--------------------------------

### Location::with

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Appends `span` to the location span, and returns itself.

```APIDOC
#### pub fn with(self, span: Span) -> Self

Append `span` to the location span, and returns itself.
```

--------------------------------

### Ord for Location

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Provides ordering capabilities for the Location struct.

```APIDOC
### impl<F: Ord> Ord for Location<F>

#### fn cmp(&self, other: &Location<F>) -> Ordering

This method returns an `Ordering` between `self` and `other`. Read more
1.21.0 · Source
#### fn max(self, other: Self) -> Self
where Self: Sized,
Compares and returns the maximum of two values. Read more
1.21.0 · Source
#### fn min(self, other: Self) -> Self
where Self: Sized,
Compares and returns the minimum of two values. Read more
1.50.0 · Source
#### fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized,
Restrict a value to a certain interval. Read more
Source
```

--------------------------------

### MaybeLocated

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Provides optional location information for the Location struct.

```APIDOC
## type File = <T as Located>::File

### Description
The file associated with the location.

## fn optional_location(&self) -> Option<Location<&<T as MaybeLocated>::File>>

### Description
Returns an optional location for the struct.

### Method
`optional_location`

### Parameters
None

### Returns
Option<Location<&<T as MaybeLocated>::File>> - An optional location.
```

--------------------------------

### Location::into_span

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Consumes this location and returns the span.

```APIDOC
#### pub fn into_span(self) -> Span

Consumes this location and returns the span.
```

--------------------------------

### Clone Location

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Returns a duplicate of the Location value. This requires the file type `F` to implement `Clone`.

```rust
fn clone(&self) -> Location<F>
```

--------------------------------

### Located for Location

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Implementation of the `Located` trait for the Location struct.

```APIDOC
### impl<F> Located for Location<F>

#### type File = F
Source
#### fn location(&self) -> Location<&Self::File>
Source
```

--------------------------------

### From<Range<usize>> for Span

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Converts a `Range<usize>` into a `Span`.

```APIDOC
### impl From<Range<usize>> for Span

#### fn from(range: Range<usize>) -> Self

Converts to this type from the input type.
```

--------------------------------

### Test Location Greater Than

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Tests if the first Location is greater than the second. This requires the file type `F` to implement `PartialOrd`.

```rust
fn gt(&self, other: &Rhs) -> bool
```

--------------------------------

### Span::push

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Extends the span by pushing a specified number of bytes to its end.

```APIDOC
### pub fn push(&mut self, count: usize)

Push `count` bytes to the span.
Move its end position by `count`.
```

--------------------------------

### Optional Span from Span

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Returns an Option containing the Span itself, indicating that a span is always present.

```rust
fn optional_span(&self) -> Option<Span>
```

--------------------------------

### Debug for Location

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Provides debugging capabilities for the Location struct.

```APIDOC
### impl<F: Debug> Debug for Location<F>

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

Formats the value using the given formatter. Read more
Source
```

--------------------------------

### Iterate over a reference to Span

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Provides an iterator over the byte indices within a Span, treating the Span as a Range<usize>.

```rust
type Item = usize
```

```rust
type IntoIter = Range<usize>
```

```rust
fn into_iter(self) -> Self::IntoIter
```

--------------------------------

### Define Location Struct

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Defines the Location struct which holds a file identifier and a span.

```rust
pub struct Location<F> {
    pub file: F,
    pub span: Span,
}
```

--------------------------------

### Extract Span from Location

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Consumes this location and returns only the span. Use this when you only need the span and the file identifier is no longer required.

```rust
pub fn into_span(self) -> Span
```

--------------------------------

### Location::until

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Sets the end of the location span to `end`, and returns itself.

```APIDOC
### impl<F> Location<F>

#### pub fn until(self, end: usize) -> Self

Sets the end of the location span to `end`, and returns itself.
```

--------------------------------

### Hash Slice of Locations

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Feeds a slice of Location values into a given Hasher. This requires the file type `F` to implement `Hash`.

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

--------------------------------

### Hash Span

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Feeds the Span's data into a Hasher for hashing purposes.

```rust
fn hash<__H: Hasher>(&self, state: &mut __H)
```

--------------------------------

### Convert Range to Span

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Converts a standard Rust Range<usize> into a Span.

```rust
fn from(range: Range<usize>) -> Self
```

--------------------------------

### ToOwned

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Converts borrowed data into owned data.

```APIDOC
## type Owned = T

### Description
The resulting type after obtaining ownership.

## fn to_owned(&self) -> T

### Description
Creates owned data from borrowed data, usually by cloning.

### Method
`to_owned`

### Parameters
None

### Returns
T - The owned data.

## fn clone_into(&self, target: &mut T)

### Description
Uses borrowed data to replace owned data, usually by cloning.

### Method
`clone_into`

### Parameters
- `target` (&mut T) - A mutable reference to the owned data to be replaced.

### Returns
None
```

--------------------------------

### Span::len

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Calculates the size of the span in bytes.

```APIDOC
### pub fn len(&self) -> usize

Size of the span in bytes.
```

--------------------------------

### Convert Span to Range

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Converts a Span into a standard Rust Range<usize>.

```rust
fn from(span: Span) -> Self
```

--------------------------------

### Located Trait Definition

Source: https://docs.rs/locspan/0.9.2/locspan/trait.Located.html

Defines the Located trait with an associated File type and a location method. Implement this trait for types that need to be associated with a source file location.

```rust
pub trait Located {
    type File;

    // Required method
    fn location(&self) -> Location<&Self::File>;
}
```

--------------------------------

### Clone a Span

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Returns a duplicate of the Span value.

```rust
fn clone(&self) -> Span
```

--------------------------------

### Deconstruct Location into Parts

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Consumes this location and returns a pair containing the file identifier and the span. Use this when you need both components and no longer need the Location struct itself.

```rust
pub fn into_parts(self) -> (F, Span)
```

--------------------------------

### Compute the union of two Spans

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Calculates the smallest span that encompasses both the current span and another provided span. If they don't overlap, the resulting span includes all positions between them.

```rust
pub fn union(&self, other: Self) -> Self
```

--------------------------------

### Spanned

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Provides span information for the Location struct.

```APIDOC
## fn span(&self) -> Span

### Description
Returns the span of the struct.

### Method
`span`

### Parameters
None

### Returns
Span - The span of the struct.
```

--------------------------------

### Hash slice of Spans

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Feeds a slice of Spans into a Hasher for hashing purposes.

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

--------------------------------

### Spanned Trait Implementation

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Implementation of the Spanned trait for Span.

```APIDOC
## fn span(&self) -> Span

### Description
Returns the Span itself.

### Method
`span`
```

--------------------------------

### Default Span value

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Returns the default value for a Span, which is an empty span at position 0.

```rust
fn default() -> Span
```

--------------------------------

### IntoIterator for &Span

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Provides an iterator over the byte indices within a borrowed `Span`.

```APIDOC
### impl IntoIterator for &Span

#### type Item = usize

The type of the elements being iterated over.

#### type IntoIter = Range<usize>

Which kind of iterator are we turning this into?

#### fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.
```

--------------------------------

### Located Trait

Source: https://docs.rs/locspan/0.9.2/locspan/trait.Located.html

The Located trait defines a contract for types that hold location information. It requires implementing types to provide an associated `File` type and a `location` method.

```APIDOC
## Trait Located

### Description
Value with a location.

### Associated Types
#### type File
Represents the file associated with the location.

### Methods
#### fn location(&self) -> Location<&Self::File>
Returns the location of the value.
```

--------------------------------

### Span::range

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Returns the byte range represented by the span.

```APIDOC
### pub fn range(&self) -> Range<usize>

Returns the range of bytes inside the span.
```

--------------------------------

### Convert usize to Span

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Converts a single byte position (usize) into a Span representing a single byte.

```rust
fn from(pos: usize) -> Self
```

--------------------------------

### IntoIterator for Span

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Provides an iterator over the byte indices within an owned `Span`.

```APIDOC
### impl IntoIterator for Span

#### type Item = usize

The type of the elements being iterated over.

#### type IntoIter = Range<usize>

Which kind of iterator are we turning this into?

#### fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.
```

--------------------------------

### Extend a Span by a byte count

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Increases the length of the span by pushing a specified number of bytes, moving its end position forward.

```rust
pub fn push(&mut self, count: usize)
```

--------------------------------

### Clamp Location within Bounds

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Restricts a Location value to be within a specified minimum and maximum range. This requires the file type `F` to implement `Ord`.

```rust
fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized
```

--------------------------------

### Set Location Span End

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Sets the end of the location's span to a specific `end` position and returns the modified location. This is useful for adjusting the span to a precise endpoint.

```rust
pub fn until(self, end: usize) -> Self
```

--------------------------------

### Span::contains

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Checks if a given byte index is within the span.

```APIDOC
### pub fn contains(&self, index: usize) -> bool

Checks if the given byte index if included in the span.
```

--------------------------------

### Append Span to Location

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Location.html

Appends a given `span` to the existing location's span and returns the modified location. This is useful for extending the location to cover additional code.

```rust
pub fn with(self, span: Span) -> Self
```

--------------------------------

### MaybeLocated Trait Definition

Source: https://docs.rs/locspan/0.9.2/locspan/trait.MaybeLocated.html

Defines the MaybeLocated trait with an associated File type and an optional_location method. Implement this trait for types that can optionally provide location information.

```rust
pub trait MaybeLocated {
    type File;

    // Required method
    fn optional_location(&self) -> Option<Location<&Self::File>>;
}
```

--------------------------------

### optional_span

Source: https://docs.rs/locspan/0.9.2/locspan/trait.MaybeSpanned.html

This method returns an optional span associated with the value. If the value has a span, it is returned as Some(Span); otherwise, None is returned.

```APIDOC
## fn optional_span(&self) -> Option<Span>

### Description
Returns an optional span associated with the value.

### Returns
- `Option<Span>`: `Some(Span)` if the value has a span, `None` otherwise.
```

--------------------------------

### Extend a Span in-place to include another Span

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Modifies the current span to include all bytes covered by another span. This is the mutable version of the `union` operation.

```rust
pub fn append(&mut self, other: Self)
```

--------------------------------

### Span::union

Source: https://docs.rs/locspan/0.9.2/locspan/struct.Span.html

Computes the union of two spans. If they don't overlap, the resulting span includes all positions between them.

```APIDOC
### pub fn union(&self, other: Self) -> Self

Computes the union of two spans.
If the two spans do not overlap, all the positions in between will be included in the resulting span.
```

--------------------------------

### MaybeLocated Trait Definition

Source: https://docs.rs/locspan/0.9.2/locspan/trait.MaybeLocated.html

Defines a trait for types that can optionally provide a location. This is useful for data that might not always have a file or span associated with it.

```APIDOC
## Trait MaybeLocated

Value with an optional location.

### Associated Types

#### type File

### Methods

#### fn optional_location(&self) -> Option<Location<&Self::File>>

Returns an `Option` containing a `Location` if the value has one, otherwise `None`.
```

--------------------------------

### MaybeSpanned Trait Definition

Source: https://docs.rs/locspan/0.9.2/locspan/trait.MaybeSpanned.html

Defines the MaybeSpanned trait with the required optional_span method. Implement this trait for types that may or may not have an associated span.

```rust
pub trait MaybeSpanned {
    // Required method
    fn optional_span(&self) -> Option<Span>;
}
```

--------------------------------

### Spanned Trait Definition

Source: https://docs.rs/locspan/0.9.2/locspan/trait.Spanned.html

Defines the Spanned trait with a required `span` method that returns a `Span`.

```APIDOC
## Trait Spanned

### Description
Value with a span.

### Required Methods

#### fn span(&self) -> Span

Returns the `Span` associated with the value.
```

--------------------------------

### Spanned Trait Definition

Source: https://docs.rs/locspan/0.9.2/locspan/trait.Spanned.html

Defines the Spanned trait, which requires a single method `span` that returns a `Span`. This trait is used to associate source code locations with values.

```rust
pub trait Spanned {
    // Required method
    fn span(&self) -> Span;
}
```
Tokens:
Raw