Struct Refined

pub struct Refined<RULE>
where
    RULE: Rule,
{ /* private fields */ }

Refined is a versatile type in ensuring that T satisfies the conditions of RULE (predicate type)

Example

use refined_type::rule::{NonEmptyString, NonEmptyStringRule};
use refined_type::Refined;

let non_empty_string_result = Refined::<NonEmptyStringRule>::new("Hello World".to_string());
assert_eq!(non_empty_string_result.unwrap().into_value(), "Hello World");

let empty_string_result = Refined::<NonEmptyStringRule>::new("".to_string());
assert!(empty_string_result.is_err())

Implementations

impl<RULE, T> Refined<RULE>

where RULE: Rule<Item = T>,

pub fn new(value: T) -> Result<Self, Error<T>>

pub fn unsafe_new(value: T) -> Self

where T: Debug,

pub fn value(&self) -> &RULE::Item

pub fn into_value(self) -> RULE::Item

impl<K, V, S> Refined<Not<EmptyRule<HashMap<K, V, S>>>>

pub fn into_iter(self) -> NonEmpty<IntoIter<K, V>>

pub fn iter(&self) -> NonEmpty<Iter<'_, K, V>>

pub fn hasher(&self) -> &S

pub fn capacity(&self) -> usize

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn keys(&self) -> Keys<'_, K, V>

pub fn into_keys(self) -> IntoKeys<K, V>

pub fn values(&self) -> Values<'_, K, V>

pub fn into_values(self) -> IntoValues<K, V>

impl<K, V, S> Refined<Not<EmptyRule<HashMap<K, V, S>>>>

where K: Eq + Hash, S: BuildHasher,

pub fn get<Q>(&self, k: &Q) -> Option<&V>

where K: Borrow<Q>, Q: Hash + Eq,

pub fn insert(self, k: K, v: V) -> Self

impl<T, S> Refined<Not<EmptyRule<HashSet<T, S>>>>

pub fn into_iter(self) -> NonEmpty<IntoIter<T>>

pub fn iter(&self) -> NonEmpty<Iter<'_, T>>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn capacity(&self) -> usize

pub fn hasher(&self) -> &S

impl<T, S> Refined<Not<EmptyRule<HashSet<T, S>>>>

where T: Eq + Hash, S: BuildHasher,

pub fn insert(self, value: T) -> Self

pub fn get<Q>(&self, value: &Q) -> Option<&T>

where T: Borrow<Q>, Q: Hash + Eq,

pub fn contains<Q>(&self, value: &Q) -> bool

where T: Borrow<Q>, Q: Hash + Eq,

pub fn difference<'a>( &'a self, other: &'a HashSet<T, S>, ) -> Difference<'a, T, S>

impl Refined<Not<EmptyRule<String>>>

pub fn insert(self, idx: usize, ch: char) -> Self

pub fn push(self, ch: char) -> Self

pub fn push_str(self, string: &str) -> Self

pub fn as_bytes(&self) -> NonEmptyVec<u8>

pub fn repeat(&self, n: usize) -> Self

pub fn to_ascii_lowercase(&self) -> Self

pub fn to_lowercase(&self) -> Self

pub fn to_ascii_uppercase(&self) -> Self

pub fn to_uppercase(&self) -> Self

pub fn capacity(&self) -> usize

pub fn len(&self) -> usize

impl<T> Refined<Not<EmptyRule<Vec<T>>>>

pub fn into_iter(self) -> NonEmpty<IntoIter<T>>

pub fn iter(&self) -> NonEmpty<Iter<'_, T>>

pub fn get(&self, index: usize) -> Option<&T>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn push(self, value: T) -> Self

impl<T> Refined<Not<EmptyRule<VecDeque<T>>>>

pub fn into_iter(self) -> NonEmpty<IntoIter<T>>

pub fn iter(&self) -> NonEmpty<Iter<'_, T>>

pub fn get(&self, index: usize) -> Option<&T>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn push_front(self, value: T) -> Self

pub fn push_back(self, value: T) -> Self

impl<I: Debug + ExactSizeIterator + EmptyDefinition> Refined<Not<EmptyRule<I>>>

pub fn map<B, F>(self, f: F) -> Refined<NonEmptyRule<Map<I, F>>>

where Self: Sized, F: FnMut(I::Item) -> B,

pub fn collect<B: Debug + FromIterator<I::Item> + EmptyDefinition>( self, ) -> NonEmpty<B>

where Self: Sized,

Trait Implementations

impl<RULE> Debug for Refined<RULE>

where RULE: Rule + Debug, RULE::Item: Debug,

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

Formats the value using the given formatter.

impl<'de, RULE, T> Deserialize<'de> for Refined<RULE>

where RULE: Rule<Item = T>, T: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<RULE, T> Display for Refined<RULE>

where RULE: Rule<Item = T>, T: Display,

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

Formats the value using the given formatter.

impl<RULE> Ord for Refined<RULE>

where RULE: Rule + Ord, RULE::Item: Ord,

fn cmp(&self, other: &Refined<RULE>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<RULE> PartialEq for Refined<RULE>

where RULE: Rule + PartialEq, RULE::Item: PartialEq,

fn eq(&self, other: &Refined<RULE>) -> 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<RULE> PartialOrd for Refined<RULE>

where RULE: Rule + PartialOrd, RULE::Item: PartialOrd,

fn partial_cmp(&self, other: &Refined<RULE>) -> Option<Ordering>

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

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

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

impl<RULE, T> Serialize for Refined<RULE>

where RULE: Rule<Item = T>, T: Serialize,

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<RULE> Eq for Refined<RULE>

where RULE: Rule + Eq, RULE::Item: Eq,

impl<RULE> StructuralPartialEq for Refined<RULE>

where RULE: Rule,