Enum Bound 

pub enum Bound {
    Pct(f64),
    Frac(f64),
    Ord(u64),
    Star,
    Fill,
    StarSplit(u64),
    StarShaped(Vec<f64>),
    Gap(Box<Bound>),
}

One numeric boundary or list token inside a partition spec. The forms are distinguished syntactically at parse time:

• Trailing % → Bound::Pct
• Decimal in [0.0, 1.0] → Bound::Frac
• Bare integer → Bound::Ord
• Literal * (or *%) → Bound::Star
• Literal ... → Bound::Fill
• */N (bare integer N) → Bound::StarSplit

Bound::Pct and Bound::Frac are equivalent at resolve time (the latter is just the former divided by 100); both require a base extent. Bound::Ord is already absolute.

The tail tokens (Star, Fill, StarSplit, StarShaped) are valid only inside a Form 2 delta list and at most one per list. Star absorbs the remainder as a single partition; Fill repeats the preceding delta until the extent is used up; StarSplit(n) divides the remainder into n equal partitions; StarShaped(weights) divides it by recipe weights. Fill, StarSplit, and StarShaped must be the final entry; Star may sit anywhere in the list. Gap wraps a sized bound and consumes extent without emitting a partition.

Variants

Pct(f64)

Percentage of the cursor’s base extent, [0.0, 100.0].

Frac(f64)

Fraction of the cursor’s base extent, [0.0, 1.0]. Equivalent to Pct(value * 100).

Ord(u64)

Absolute cursor ordinal (already in ordinal space).

Star

Remainder marker — absorbs whatever’s needed for the containing delta list to span the cursor’s full extent, as one partition.

Fill

Fill marker (...) — repeats the preceding delta until the extent is used up. A final chunk smaller than the repeated delta is emitted truncated, never dropped.

StarSplit(u64)

Remainder split (*/N) — divides whatever’s left after the other deltas into N partitions whose sizes differ by at most one ordinal.

StarShaped(Vec<f64>)

Recipe-shaped remainder (*/fib:5, */ratios:1,3, …) — divides whatever’s left by the recipe’s normalised weights (stored summing to 100).

Gap(Box<Bound>)

Gap (~10%, ~1000) — consumes the wrapped sized bound’s extent without emitting a partition. The walk stays contiguous; the emitted partition set skips this range. Parse guarantees the inner bound is sized (Pct / Frac / Ord).

Implementations

impl Bound

pub fn resolve_against(&self, base_start: u64, base_end: u64) -> Option<u64>

Resolve this bound to an absolute ordinal in [base_start, base_end] against a known extent. Returns None for the tail tokens and gaps — their resolution depends on list context and is the caller’s responsibility.

pub fn is_tail(&self) -> bool

True for the tail tokens that consume the unallocated remainder of the extent rather than naming a fixed size.

pub fn is_sized(&self) -> bool

True for the sized forms (Pct / Frac / Ord) that name a fixed amount of extent.

Trait Implementations

impl Clone for Bound

fn clone(&self) -> Bound

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Bound

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

Formats the value using the given formatter.

impl Display for Bound

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

Formats the value using the given formatter.

impl PartialEq for Bound

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Bound