pubgrub - v1.0.1

pubgrub/version_ranges

Version range primitives and operations.

Ranges are represented as sorted, non-overlapping intervals and carry a compare function used for ordering.

Types

Bound

</>

A range bound: unbounded, inclusive, or exclusive.

pub type Bound(a) {
  Unbounded
  Included(a)
  Excluded(a)
}

Constructors 

  • Unbounded
  • Included(a)
  • Excluded(a)

Compare

</>

A comparison function for values of type a.

pub type Compare(a) =
  fn(a, a) -> order.Order

Interval

</>

An interval is a pair of start/end bounds.

pub type Interval(a) =
  #(Bound(a), Bound(a))

Ranges

</>

A set of disjoint, ordered intervals.

pub type Ranges(a) {
  Ranges(
    segments: List(#(Bound(a), Bound(a))),
    compare: fn(a, a) -> order.Order,
  )
}

Constructors

Values

between

</> 
pub fn between(
  compare: fn(a, a) -> order.Order,
  lower: a,
  upper: a,
) -> Ranges(a)

Range bounded by [lower, upper).

compare

</> 
pub fn compare(ranges: Ranges(a)) -> fn(a, a) -> order.Order

Extract the compare function carried by a range set.

complement

</> 
pub fn complement(ranges: Ranges(a)) -> Ranges(a)

Complement of a range set.

contains

</> 
pub fn contains(ranges: Ranges(a), value: a) -> Bool

Check if a value is included in the range set.

empty

</> 
pub fn empty(compare: fn(a, a) -> order.Order) -> Ranges(a)

The empty range set.

equal

</> 
pub fn equal(left: Ranges(a), right: Ranges(a)) -> Bool

Check whether two range sets have identical intervals.

from_range_bounds

</> 
pub fn from_range_bounds(
  compare: fn(a, a) -> order.Order,
  start: a,
  end: a,
) -> Ranges(a)

Alias for between.

full

</> 
pub fn full(compare: fn(a, a) -> order.Order) -> Ranges(a)

The full range set.

higher_than

</> 
pub fn higher_than(
  compare: fn(a, a) -> order.Order,
  value: a,
) -> Ranges(a)

Values greater than or equal to value.

intersection

</> 
pub fn intersection(
  left: Ranges(a),
  right: Ranges(a),
) -> Ranges(a)

Intersection of two range sets.

is_disjoint

</> 
pub fn is_disjoint(left: Ranges(a), right: Ranges(a)) -> Bool

True if two range sets do not overlap.

is_empty

</> 
pub fn is_empty(ranges: Ranges(a)) -> Bool

True if the range set has no intervals.

is_full

</> 
pub fn is_full(ranges: Ranges(a)) -> Bool

True when the range spans all values.

lower_than

</> 
pub fn lower_than(
  compare: fn(a, a) -> order.Order,
  value: a,
) -> Ranges(a)

Values less than or equal to value.

singleton

</> 
pub fn singleton(
  compare: fn(a, a) -> order.Order,
  value: a,
) -> Ranges(a)

A single-value range.

strictly_higher_than

</> 
pub fn strictly_higher_than(
  compare: fn(a, a) -> order.Order,
  value: a,
) -> Ranges(a)

Values strictly greater than value.

strictly_lower_than

</> 
pub fn strictly_lower_than(
  compare: fn(a, a) -> order.Order,
  value: a,
) -> Ranges(a)

Values strictly less than value.

subset_of

</> 
pub fn subset_of(subset: Ranges(a), container: Ranges(a)) -> Bool

True if subset is fully contained in container.

to_string

</> 
pub fn to_string(
  ranges: Ranges(a),
  value_to_string: fn(a) -> String,
) -> String

Render a range set using a value formatter.

union

</> 
pub fn union(left: Ranges(a), right: Ranges(a)) -> Ranges(a)

Union of two range sets.

✨ Search Document