Enum un_algebra::tests::float::Bound

pub enum Bound<T> {
    Included(T),
    Excluded(T),
    Unbounded,
}

An endpoint of a range of keys.

Examples

Bounds are range endpoints:

use std::ops::Bound::*;
use std::ops::RangeBounds;

assert_eq!((..100).start_bound(), Unbounded);
assert_eq!((1..12).start_bound(), Included(&1));
assert_eq!((1..12).end_bound(), Excluded(&12));

Using a tuple of Bounds as an argument to BTreeMap::range. Note that in most cases, it's better to use range syntax (1..5) instead.

use std::collections::BTreeMap;
use std::ops::Bound::{Excluded, Included, Unbounded};

let mut map = BTreeMap::new();
map.insert(3, "a");
map.insert(5, "b");
map.insert(8, "c");

for (key, value) in map.range((Excluded(3), Included(8))) {
    println!("{}: {}", key, value);
}

assert_eq!(Some((&3, &"a")), map.range((Unbounded, Included(5))).next());

Variants

Included(T)

An inclusive bound.

Excluded(T)

An exclusive bound.

Unbounded

An infinite endpoint. Indicates that there is no bound in this direction.

Trait Implementations

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

fn hash<__HT>(&self, state: &mut __HT) where
    __HT: Hasher, 

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> Eq for Bound<T> where
    T: Eq, 

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

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> Debug for Bound<T> where
    T: Debug, 

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

Formats the value using the given formatter.

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

impl<T> PartialEq<Bound<T>> for Bound<T> where
    T: PartialEq<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<A> Arbitrary for Bound<A> where
    A: Arbitrary, 

type Parameters = <A as Arbitrary>::Parameters

The type of parameters that [arbitrary_with] accepts for configuration of the generated [Strategy]. Parameters must implement [Default].

type Strategy = TupleUnion<((u32, Map<Arc<<A as Arbitrary>::Strategy>, fn(<Arc<<A as Arbitrary>::Strategy> as Strategy>::Value) -> Bound<A>>), (u32, Map<Arc<<A as Arbitrary>::Strategy>, fn(<Arc<<A as Arbitrary>::Strategy> as Strategy>::Value) -> Bound<A>>), (u32, LazyJust<Bound<A>, fn() -> Bound<A>>))>

The type of [Strategy] used to generate values of type Self.

fn arbitrary_with(
    args: <Bound<A> as Arbitrary>::Parameters
) -> <Bound<A> as Arbitrary>::Strategy

Generates a [Strategy] for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a [Strategy] for producing arbitrary values of type the implementing type (Self).

impl<A> ArbitraryF1<A> for Bound<A> where
    A: 'static + Debug, 

type Parameters = ()

The type of parameters that [lift1_with] accepts for configuration of the lifted and generated [Strategy]. Parameters must implement [Default].

fn lift1_with<S>(
    base: S,
    _args: <Bound<A> as ArbitraryF1<A>>::Parameters
) -> BoxedStrategy<Bound<A>> where
    S: Strategy<Value = A> + 'static, 

Lifts a given [Strategy] to a new [Strategy] for the (presumably) bigger type. This is useful for lifting a Strategy for SomeType to a container such as Vec of SomeType. The composite strategy is passed the arguments given in args.

fn lift1<AS>(base: AS) -> BoxedStrategy<Self> where
    AS: Strategy<Value = A> + 'static, 

Lifts a given [Strategy] to a new [Strategy] for the (presumably) bigger type. This is useful for lifting a Strategy for SomeType to a container such as Vec<SomeType>.