Struct Range 

pub struct Range<T: PartialOrd> { /* private fields */ }

Inclusive [min, max] interval over a Rangeable type.

The constructor enforces min ≤ max, so a Range<T> value in hand is a proof that the contained pair is well-ordered; downstream consumers can read min / max without re-checking. The invariant is checked at runtime in debug builds via debug_assert!.

Construction sites in this crate (the Rangeable::range_across reduction) walk the input iterator and produce a Range directly; misuse — calling Range::new(b, a) with a < b — is a programmer error and panics in debug, sneaks through in release (the wrapped pair is then [max, min], so any caller reading min gets the larger value). External callers constructing a Range from external bounds should pre-sort.

Range<T> deliberately omits Ord / PartialOrd / Serialize / Deserialize:

• It is an in-memory aggregation result, not a wire-format boundary; the aggregate() dispatch destructures Range into the existing crate::ctprof_compare::Aggregated::OrdinalRange variant (which carries min: i64, max: i64), so the typed invariant is enforced at the reduction boundary and the untyped tuple shape continues to cross every serialized boundary downstream.
• Comparing two Range values to each other has no defined semantic — there is no obvious ordering on intervals — and adding derive(Ord) would bring std::cmp::Ord::min / std::cmp::Ord::max into scope on Range<T> and shadow the inherent accessors at every call site.

Heads-up for future contributors: if Ord/PartialOrd derives are ever added, expect breakage at every existing .min() / .max() call site — those resolve to the inherent methods today and will start resolving to the trait methods (different signature, different return type) the moment the derives are added.

Implementations

impl<T: PartialOrd> Range<T>

pub fn new(min: T, max: T) -> Self

Construct a Range from a (min, max) pair.

debug_assert!s that min ≤ max — the Rangeable reduction guarantees this by walking the input and tracking min and max separately, so the assertion never fires on internal call sites. External callers must pre-sort.

pub fn min(&self) -> &T

The lower bound of the interval.

pub fn max(&self) -> &T

The upper bound of the interval.

pub fn into_tuple(self) -> (T, T)

Consume the range and return the (min, max) tuple. Useful at boundaries where the caller has its own pair-shaped representation (e.g. the crate::ctprof_compare::Aggregated::OrdinalRange variant).

Trait Implementations

impl<T: Clone + PartialOrd> Clone for Range<T>

fn clone(&self) -> Range<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + PartialOrd> Debug for Range<T>

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

Formats the value using the given formatter.

impl<T: Hash + PartialOrd> Hash for Range<T>

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<T: PartialEq + PartialOrd> PartialEq for Range<T>

fn eq(&self, other: &Range<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: Copy + PartialOrd> Copy for Range<T>

impl<T: Eq + PartialOrd> Eq for Range<T>

impl<T: PartialOrd> StructuralPartialEq for Range<T>