Struct type_rules::Valid

pub struct Valid<T: Validator>(_);

Valid is a wrapper for any type that implements Validator it permit to ensure at compile time that the inner type as been verified.

With the serde feature, Valid can be serialized and deserialized with validity check.

use type_rules::prelude::*;

#[derive(Validator)]
struct NewUser {
    #[rule(MinMaxLength(3, 50))]
    username: String,
    #[rule(MinMaxLength(8, 100))]
    password: String,
}

fn do_something(user: Valid<NewUser>) {
    // No need to check if user is valid
}

let new_user = NewUser {
    username: "example".to_string(),
    password: "OPw$5%hJJ".to_string(),
};
do_something(Valid::new(new_user).unwrap());

Implementations

impl<T: Validator> Valid<T>

pub fn new(val: T) -> Result<Self, String>

pub fn into_inner(self) -> T

Trait Implementations

impl<T: Debug + Validator> Debug for Valid<T>

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

Formats the value using the given formatter.

impl<T: Validator> Deref for Valid<T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<'a, T: Validator + Deserialize<'a>> Deserialize<'a> for Valid<T>

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where
    D: Deserializer<'a>, 

Deserialize this value from the given Serde deserializer.

impl<T: Validator + Display> Display for Valid<T>

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

Formats the value using the given formatter.

impl<T: Validator + Serialize> Serialize for Valid<T>

Available on crate feature serde only.

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

Serialize this value into the given Serde serializer.