Enum Interval

pub enum Interval<A, C> {
    Lower {
        below: A,
        class: C,
    },
    Range {
        from: A,
        below: A,
        class: C,
    },
    Upper {
        from: A,
        class: C,
    },
    Infinite {
        class: C,
    },
}

An interval represents a mapping from a range of values of type A, to a class, C.

Examples

use oner_quantize::Interval;
let interval = Interval::lower(100, "true");
assert_eq!(interval.matches(25), true);
assert_eq!(interval.matches(100), false);
assert_eq!(interval.matches(125), false);

Variants

Lower

A lower bound, such as < 100

Fields

below: A

class: C

Range

A half-open exclusive range, such as >= 100 and < 200 aka [100,200)

Fields

from: A

below: A

class: C

Upper

An upper range, such as >= 200

Fields

from: A

class: C

Infinite

The interval that covers all values

Fields

class: C

Implementations

impl<A, C> Interval<A, C>

where A: PartialOrd + Copy, C: Copy,

pub fn lower(below: A, class: C) -> Self

pub fn range(from: A, below: A, class: C) -> Self

pub fn upper(from: A, class: C) -> Self

pub fn matches(&self, value: A) -> bool

Does the given value fall inside this interval?

pub fn class(&self) -> &C

The class that this interval predicts.

Trait Implementations

impl<A: Clone, C: Clone> Clone for Interval<A, C>

fn clone(&self) -> Interval<A, C>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug, C: Debug> Debug for Interval<A, C>

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

Formats the value using the given formatter.

impl<A: PartialEq, C: PartialEq> PartialEq for Interval<A, C>

fn eq(&self, other: &Interval<A, C>) -> 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<A: Copy, C: Copy> Copy for Interval<A, C>

impl<A, C> StructuralPartialEq for Interval<A, C>