Enum normalize_interval::bound::Bound

pub enum Bound<T> {
    Include(T),
    Exclude(T),
    Infinite,
}

Determines the type of an Interval's boundary point.

Variants

Include(T)

The bound includes the point.

Exclude(T)

The bound excludes the point.

Infinite

The bound does not exist.

Implementations

impl<T> Bound<T> where
    T: PartialOrd + PartialEq + Clone, 

pub fn is_finite(&self) -> bool

Returns true if the bound is an Include or Exclude value.

Example

let x: Bound<i32> = Bound::Include(15);
assert_eq!(x.is_finite(), true);

let x: Bound<i32> = Bound::Infinite;
assert_eq!(x.is_finite(), false);

pub fn is_inclusive(&self) -> bool

Returns true if the bound is an Include value.

Example

let x: Bound<i32> = Bound::Include(15);
assert_eq!(x.is_inclusive(), true);

let x: Bound<i32> = Bound::Exclude(15);
assert_eq!(x.is_inclusive(), false);

pub fn is_exclusive(&self) -> bool

Returns true if the bound is an Exclude value.

Example

let x: Bound<i32> = Bound::Exclude(15);
assert_eq!(x.is_exclusive(), true);

let x: Bound<i32> = Bound::Include(15);
assert_eq!(x.is_exclusive(), false);

pub fn as_ref(&self) -> Option<&T>

Returns a reference to the contained point, or None if the bound is Infinite.

Example

let x: Bound<i32> = Bound::Exclude(34);

assert_eq!(x.as_ref(), Some(&34));

pub fn as_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the contained point, or None if the bound is Infinite.

Example

let mut x: Bound<i32> = Bound::Exclude(34);

assert_eq!(x.as_mut(), Some(&mut 34));

pub fn unwrap(self) -> T

Moves the value out of the Bound<T> if it is Include or Exclude.

In general, because this function may panic, its use is discouraged. Instead, prefer to use pattern matching and handle the Infinite case explicitly.

Panics

Panics if the self value equals Infinite.

Examples

let x: Bound<i32> = Bound::Exclude(34);
assert_eq!(x.unwrap(), 34);

let x: Bound<i32> = Bound::Infinite;
assert_eq!(x.unwrap(), 34); // fails

pub fn unwrap_or(self, def: T) -> T

Returns the bound value or a default.

Example

assert_eq!(Bound::Exclude(34).unwrap_or(15), 34);
assert_eq!(Bound::Infinite.unwrap_or(15), 15);

pub fn unwrap_or_else<F: FnOnce() -> T>(self, f: F) -> T

Returns the bound value or computes it from a closure.

Example

let k = 10;
assert_eq!(Bound::Exclude(34).unwrap_or_else(|| 2 * k), 34);
assert_eq!(Bound::Infinite.unwrap_or_else(|| 2 * k), 20);

pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Bound<U>

Maps an Bound<T> to Bound<U> by applying a function to a contained value.

Example

let x: Bound<u32> = Bound::Include(10);
let y: Bound<usize> = x.map(|v| v as usize);

assert_eq!(y, Bound::Include(10usize));

pub fn map_or<U, F>(self, def: U, f: F) -> U where
    F: FnOnce(T) -> U, 

Applyies a function to a contained value (if finite) or returns a default value (if [Infinte]).

Example

assert_eq!(Bound::Include(10).map_or(6, |k| k * 2), 20);

pub fn map_or_else<U, D, F>(self, def: D, f: F) -> U where
    D: FnOnce() -> U,
    F: FnOnce(T) -> U, 

Applyies a function to a contained value (if finite) or returns a computed value (if [Infinte]).

Example

assert_eq!(Bound::Include(10).map_or_else(|| 6, |k| k * 2), 20);
assert_eq!(Bound::Infinite.map_or_else(|| 6, |k: u32| k * 2), 6);

pub fn transfer<B: Borrow<Self>, O>(from: B, to: O) -> Bound<O>

Constructs a new Bound by applyting the bound type to the given value.

Example

let x: Bound<i32> = Bound::transfer(Bound::Exclude(34), 18);

assert_eq!(x, Bound::Exclude(18));

Trait Implementations

impl<T: Clone> Clone for Bound<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy> Copy for Bound<T>

impl<T: Debug> Debug for Bound<T>

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

Formats the value using the given formatter.

impl<T> Default for Bound<T> where
    T: Default, 

fn default() -> Self

Returns the "default value" for a type.

impl<T: Eq> Eq for Bound<T>

impl<T> From<T> for Bound<T>

fn from(t: T) -> Self

Performs the conversion.

impl<T: Hash> Hash for Bound<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, 

Feeds a slice of this type into the given [Hasher].

impl<T: PartialEq> PartialEq<Bound<T>> for Bound<T>

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

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Bound<T>) -> bool

This method tests for !=.

impl<T> StructuralEq for Bound<T>

impl<T> StructuralPartialEq for Bound<T>