Struct refined_type::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().deref(), "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>>

Trait Implementations

impl<RULE> Clone for Refined<RULE>

where RULE: Rule + Clone, RULE::Item: Clone,

fn clone(&self) -> Refined<RULE>

Returns a copy of the value.

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

Performs copy-assignment from source.

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<RULE, T> Deref for Refined<RULE>

where RULE: Rule<Item = T>,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

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> PartialEq for Refined<RULE>

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

fn eq(&self, other: &Refined<RULE>) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<RULE> Eq for Refined<RULE>

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

impl<RULE> StructuralPartialEq for Refined<RULE>

where RULE: Rule,