Struct ByteRange 

#[non_exhaustive]
#[repr(C)]
pub struct ByteRange {
    pub tag: u32,
    pub start: u32,
    pub end: u32,
}

A tagged, half-open byte range [start, end).

tag is a producer-chosen 32-bit identifier - a matching dialect can pass a pattern_id, a decoder can pass an encoding ID, an AST-span emitter can pass a node kind, a taint-source locator can pass a source index. The producer decides what it means; the type carries no domain assumption.

The struct is deliberately #[repr(C)] so FFI and backend marshalling share one layout, and #[non_exhaustive] so future fields (capture groups, confidence, …) can be added without breaking the API.

Examples

use vyre_primitives::range::ByteRange;

let r = ByteRange::new(7, 10, 20);
assert_eq!(r.tag, 7);
assert_eq!(r.start, 10);
assert_eq!(r.end, 20);
assert_eq!(r.len(), 10);

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

tag: u32

Producer-chosen 32-bit identifier. Not interpreted by this crate.

start: u32

Inclusive byte start offset.

end: u32

Exclusive byte end offset.

Implementations

impl ByteRange

pub const fn new(tag: u32, start: u32, end: u32) -> Self

Construct a range. end MUST be >= start; the assertion catches reversed ranges in both debug and release so producers hit the bug at the call site instead of downstream.

AUDIT_2026-04-24 F-RANGE-01: promoted debug_assert! to assert! so release builds can’t silently accept a reversed range (which used to cascade into len() returning 0 and every range-containment predicate answering the wrong way).

pub const fn len(&self) -> u32

Length of the range in bytes.

AUDIT_2026-04-24 F-RANGE-02: uses plain subtraction so any reversed range triggers a panic in release. Prior saturating_sub hid producer bugs by returning 0 for ill-formed ranges; new()’s release-time assertion now prevents that state from reaching here in the first place, and the plain op gives a second fail-loud line of defense if a caller forged a ByteRange through the public fields.

pub const fn is_empty(&self) -> bool

True when the range has zero length.

pub const fn contains(&self, other: &ByteRange) -> bool

True when self contains other (both start and end).

pub const fn ends_before(&self, other: &ByteRange) -> bool

True when self ends at or before other starts (disjoint, self first). Mirrors the Before predicate surfaced by scanner dialects.

Trait Implementations

impl Clone for ByteRange

fn clone(&self) -> ByteRange

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ByteRange

impl Debug for ByteRange

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

Formats the value using the given formatter.

impl Eq for ByteRange

impl From<ByteRange> for Match

fn from(r: ByteRange) -> Self

Converts to this type from the input type.

impl From<Match> for ByteRange

fn from(m: Match) -> Self

Converts to this type from the input type.

impl Hash for ByteRange

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for ByteRange

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for ByteRange

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for ByteRange

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

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

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

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

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

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

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

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

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

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

impl StructuralPartialEq for ByteRange