Struct refinement::Refinement

pub struct Refinement<T, P>(_, _);

A Refinement type ensures all values of a particular type satisfy a Predicate.

Use as_inner/to_inner to access the underlying value or into_inner to unwrap the value.

Refinement also implements many common standard library traits if the underlying value also implements them.

Examples

use refinement::{Predicate, Refinement};

struct LessThanTen;

impl Predicate<i32> for LessThanTen {
    fn test(x: &i32) -> bool {
        *x < 10
    }
}

type LessThanTenInt = Refinement<i32, LessThanTen>;

let x = LessThanTenInt::new(5);
assert!(x.is_some());

let y = LessThanTenInt::new(11);
assert!(y.is_none());

Implementations

impl<T, P> Refinement<T, P> where
    P: Predicate<T>, 

pub fn new(x: T) -> Option<Self>

Create a refined value from the underlying type T.

Returns x under the refinement type if x satisfies P, otherwise returns None.

Examples

use refinement::{Predicate, Refinement};

struct NonEmpty;

impl Predicate<String> for NonEmpty {
    fn test(x: &String) -> bool {
       !x.is_empty()
    }
}

type NonEmptyString = Refinement<String, NonEmpty>;

let s1 = NonEmptyString::new(String::from("Hello"));
assert!(s1.is_some());

let s2 = NonEmptyString::new(String::from(""));
assert!(s2.is_none());

pub fn into_inner(self) -> T

Unwrap the underlying value, consuming self.

Examples

use refinement::{Predicate, Refinement};

struct ThreeDigit;

impl Predicate<String> for ThreeDigit {
    fn test(x: &String) -> bool {
       x.chars().count() == 3 && x.chars().filter(|c| c.is_ascii_digit()).count() == 3
    }
}

type ThreeDigitString = Refinement<String, ThreeDigit>;

let s = ThreeDigitString::new(String::from("123"));

assert_eq!(String::from("123"), s.unwrap().into_inner());

impl<T, P> Refinement<T, P> where
    T: Clone,
    P: Predicate<T>, 

pub fn to_inner(&self) -> T

Retrieve the underlying value without consuming self.

Examples

use refinement::{Predicate, Refinement};

struct ThreeDigit;

impl Predicate<String> for ThreeDigit {
    fn test(x: &String) -> bool {
       x.chars().count() == 3 && x.chars().filter(|c| c.is_ascii_digit()).count() == 3
    }
}

type ThreeDigitString = Refinement<String, ThreeDigit>;

let s = ThreeDigitString::new(String::from("123"));

assert_eq!(String::from("123"), s.unwrap().to_inner());

impl<T, P> Refinement<T, P> where
    T: Copy,
    P: Predicate<T>, 

pub fn as_inner(&self) -> T

Retrieve the underlying value for Copy types without consuming self.

Examples

use refinement::{Predicate, Refinement};

struct LessThanTen;

impl Predicate<i32> for LessThanTen {
    fn test(x: &i32) -> bool {
        *x < 10
    }
}

type LessThanTenInt = Refinement<i32, LessThanTen>;

let x = LessThanTenInt::new(5);
assert_eq!(5, x.unwrap().as_inner());

Trait Implementations

impl<T, P> Add<Refinement<T, P>> for Refinement<T, P> where
    T: Add<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the + operator.

pub fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<T, P> Add<T> for Refinement<T, P> where
    T: Add<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the + operator.

pub fn add(self, rhs: T) -> Self::Output

Performs the + operation.

impl<T, P> AsRef<T> for Refinement<T, P> where
    P: Predicate<T>, 

pub fn as_ref(&self) -> &T

Performs the conversion.

impl<T, P> BitAnd<Refinement<T, P>> for Refinement<T, P> where
    T: BitAnd<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the & operator.

pub fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl<T, P> BitAnd<T> for Refinement<T, P> where
    T: BitAnd<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the & operator.

pub fn bitand(self, rhs: T) -> Self::Output

Performs the & operation.

impl<T, P> BitOr<Refinement<T, P>> for Refinement<T, P> where
    T: BitOr<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the | operator.

pub fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl<T, P> BitOr<T> for Refinement<T, P> where
    T: BitOr<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the | operator.

pub fn bitor(self, rhs: T) -> Self::Output

Performs the | operation.

impl<T, P> BitXor<Refinement<T, P>> for Refinement<T, P> where
    T: BitXor<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the ^ operator.

pub fn bitxor(self, rhs: Self) -> Self::Output

Performs the ^ operation.

impl<T, P> BitXor<T> for Refinement<T, P> where
    T: BitXor<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the ^ operator.

pub fn bitxor(self, rhs: T) -> Self::Output

Performs the ^ operation.

impl<T, P> Borrow<T> for Refinement<T, P> where
    P: Predicate<T>, 

pub fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T: Clone, P: Clone> Clone for Refinement<T, P>

pub fn clone(&self) -> Refinement<T, P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy, P: Copy> Copy for Refinement<T, P>

impl<T: Debug, P: Debug> Debug for Refinement<T, P>

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

Formats the value using the given formatter.

impl<T, P> Display for Refinement<T, P> where
    T: Display,
    P: Predicate<T>, 

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

Formats the value using the given formatter.

impl<T, P> Div<Refinement<T, P>> for Refinement<T, P> where
    T: Div<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the / operator.

pub fn div(self, rhs: Self) -> Self::Output

Performs the / operation.

impl<T, P> Div<T> for Refinement<T, P> where
    T: Div<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the / operator.

pub fn div(self, rhs: T) -> Self::Output

Performs the / operation.

impl<T: Eq, P: Eq> Eq for Refinement<T, P>

impl<T: Hash, P: Hash> Hash for Refinement<T, P>

pub fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<T, P, I> Index<I> for Refinement<T, P> where
    T: Index<I>,
    P: Predicate<T>, 

type Output = T::Output

The returned type after indexing.

pub fn index(&self, index: I) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, P> Mul<Refinement<T, P>> for Refinement<T, P> where
    T: Mul<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the * operator.

pub fn mul(self, rhs: Self) -> Self::Output

Performs the * operation.

impl<T, P> Mul<T> for Refinement<T, P> where
    T: Mul<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the * operator.

pub fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T, P> Neg for Refinement<T, P> where
    T: Neg<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the - operator.

pub fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T, P> Not for Refinement<T, P> where
    T: Not<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the ! operator.

pub fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T: Ord, P: Ord> Ord for Refinement<T, P>

pub fn cmp(&self, other: &Refinement<T, P>) -> Ordering

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<T: PartialEq, P: PartialEq> PartialEq<Refinement<T, P>> for Refinement<T, P>

pub fn eq(&self, other: &Refinement<T, P>) -> bool

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

pub fn ne(&self, other: &Refinement<T, P>) -> bool

This method tests for !=.

impl<T: PartialOrd, P: PartialOrd> PartialOrd<Refinement<T, P>> for Refinement<T, P>

pub fn partial_cmp(&self, other: &Refinement<T, P>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

pub fn lt(&self, other: &Refinement<T, P>) -> bool

This method tests less than (for self and other) and is used by the < operator.

pub fn le(&self, other: &Refinement<T, P>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

pub fn gt(&self, other: &Refinement<T, P>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

pub fn ge(&self, other: &Refinement<T, P>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, P, B> RangeBounds<B> for Refinement<T, P> where
    T: RangeBounds<B>,
    P: Predicate<T>, 

pub fn start_bound(&self) -> Bound<&B>

Start index bound.

pub fn end_bound(&self) -> Bound<&B>

End index bound.

pub fn assert_len(self, len: usize) -> Range<usize> where
    Self: RangeBounds<usize>, 

🔬 This is a nightly-only experimental API. (range_bounds_assert_len)

Performs bounds-checking of this range.

pub fn contains<U>(&self, item: &U) -> bool where
    T: PartialOrd<U>,
    U: PartialOrd<T> + ?Sized, 

Returns true if item is contained in the range.

impl<T, P> Rem<Refinement<T, P>> for Refinement<T, P> where
    T: Rem<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the % operator.

pub fn rem(self, rhs: Self) -> Self::Output

Performs the % operation.

impl<T, P> Rem<T> for Refinement<T, P> where
    T: Rem<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the % operator.

pub fn rem(self, rhs: T) -> Self::Output

Performs the % operation.

impl<T, P> Shl<Refinement<T, P>> for Refinement<T, P> where
    T: Shl<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the << operator.

pub fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<T, P> Shl<T> for Refinement<T, P> where
    T: Shl<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the << operator.

pub fn shl(self, rhs: T) -> Self::Output

Performs the << operation.

impl<T, P> Shr<Refinement<T, P>> for Refinement<T, P> where
    T: Shr<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the >> operator.

pub fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<T, P> Shr<T> for Refinement<T, P> where
    T: Shr<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the >> operator.

pub fn shr(self, rhs: T) -> Self::Output

Performs the >> operation.

impl<T, P> StructuralEq for Refinement<T, P>

impl<T, P> StructuralPartialEq for Refinement<T, P>

impl<T, P> Sub<Refinement<T, P>> for Refinement<T, P> where
    T: Sub<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the - operator.

pub fn sub(self, rhs: Self) -> Self::Output

Performs the - operation.

impl<T, P> Sub<T> for Refinement<T, P> where
    T: Sub<Output = T>,
    P: Predicate<T>, 

type Output = Option<Self>

The resulting type after applying the - operator.

pub fn sub(self, rhs: T) -> Self::Output

Performs the - operation.