Trait ValidateFrom 

pub trait ValidateFrom<Raw>: Sized {
    type Context: ?Sized;
    type Error;

    // Required method
    fn validate_from_in_context(
        raw: Raw,
        ctx: &Self::Context,
    ) -> Result<Self, Self::Error>;

    // Provided method
    fn validate_from(raw: Raw) -> Result<Self, Self::Error>
       where Self::Context: From<()> { ... }
}

Target-side dual of Validate.

Unlike Validate, which forces a single validated output type, ValidateFrom allows the same type to be validated from multiple source types, since many domain types may arrive in various formats. This should not be abused to make a single raw value validate into multiple types, but I can’t force you.

Examples

use peer_pressure::ValidateFrom;

struct Email(String);

impl ValidateFrom<&str> for Email {
    type Context = ();
    type Error = &'static str;

    fn validate_from_in_context(raw: &str, _: &()) -> Result<Self, Self::Error> {
        if raw.contains('@') { Ok(Email(raw.to_string())) } else { Err("missing @") }
    }
}

assert!(Email::validate_from("alice@example.com").is_ok());
assert!(Email::validate_from("not-an-email").is_err());

Required Associated Types

type Context: ?Sized

Immutable context of the validation.

Use () for context-free checks.

type Error

Validation error

Required Methods

fn validate_from_in_context( raw: Raw, ctx: &Self::Context, ) -> Result<Self, Self::Error>

Validates raw in given context, returning either a valid Self or Error.

Provided Methods

fn validate_from(raw: Raw) -> Result<Self, Self::Error>

where Self::Context: From<()>,

Validates raw, returning either a valid Self or Error.

Available only for types with context-free validation (ie. for which Context = ()).

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<Ctx: ?Sized, Err, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, RA, RB, RC, RD, RE, RF, RG, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ> ValidateFrom<(RA, RB, RC, RD, RE, RF, RG, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ)> for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where A: ValidateFrom<RA, Context = Ctx, Error = Err>, B: ValidateFrom<RB, Context = Ctx, Error = Err>, C: ValidateFrom<RC, Context = Ctx, Error = Err>, D: ValidateFrom<RD, Context = Ctx, Error = Err>, E: ValidateFrom<RE, Context = Ctx, Error = Err>, F: ValidateFrom<RF, Context = Ctx, Error = Err>, G: ValidateFrom<RG, Context = Ctx, Error = Err>, H: ValidateFrom<RH, Context = Ctx, Error = Err>, I: ValidateFrom<RI, Context = Ctx, Error = Err>, J: ValidateFrom<RJ, Context = Ctx, Error = Err>, K: ValidateFrom<RK, Context = Ctx, Error = Err>, L: ValidateFrom<RL, Context = Ctx, Error = Err>, M: ValidateFrom<RM, Context = Ctx, Error = Err>, N: ValidateFrom<RN, Context = Ctx, Error = Err>, O: ValidateFrom<RO, Context = Ctx, Error = Err>, P: ValidateFrom<RP, Context = Ctx, Error = Err>, Q: ValidateFrom<RQ, Context = Ctx, Error = Err>, R: ValidateFrom<RR, Context = Ctx, Error = Err>, S: ValidateFrom<RS, Context = Ctx, Error = Err>, T: ValidateFrom<RT, Context = Ctx, Error = Err>, U: ValidateFrom<RU, Context = Ctx, Error = Err>, V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RA, RB, RC, RD, RE, RF, RG, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, RB, RC, RD, RE, RF, RG, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ> ValidateFrom<(RB, RC, RD, RE, RF, RG, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ)> for (B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where B: ValidateFrom<RB, Context = Ctx, Error = Err>, C: ValidateFrom<RC, Context = Ctx, Error = Err>, D: ValidateFrom<RD, Context = Ctx, Error = Err>, E: ValidateFrom<RE, Context = Ctx, Error = Err>, F: ValidateFrom<RF, Context = Ctx, Error = Err>, G: ValidateFrom<RG, Context = Ctx, Error = Err>, H: ValidateFrom<RH, Context = Ctx, Error = Err>, I: ValidateFrom<RI, Context = Ctx, Error = Err>, J: ValidateFrom<RJ, Context = Ctx, Error = Err>, K: ValidateFrom<RK, Context = Ctx, Error = Err>, L: ValidateFrom<RL, Context = Ctx, Error = Err>, M: ValidateFrom<RM, Context = Ctx, Error = Err>, N: ValidateFrom<RN, Context = Ctx, Error = Err>, O: ValidateFrom<RO, Context = Ctx, Error = Err>, P: ValidateFrom<RP, Context = Ctx, Error = Err>, Q: ValidateFrom<RQ, Context = Ctx, Error = Err>, R: ValidateFrom<RR, Context = Ctx, Error = Err>, S: ValidateFrom<RS, Context = Ctx, Error = Err>, T: ValidateFrom<RT, Context = Ctx, Error = Err>, U: ValidateFrom<RU, Context = Ctx, Error = Err>, V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RB, RC, RD, RE, RF, RG, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, RC, RD, RE, RF, RG, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ> ValidateFrom<(RC, RD, RE, RF, RG, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ)> for (C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where C: ValidateFrom<RC, Context = Ctx, Error = Err>, D: ValidateFrom<RD, Context = Ctx, Error = Err>, E: ValidateFrom<RE, Context = Ctx, Error = Err>, F: ValidateFrom<RF, Context = Ctx, Error = Err>, G: ValidateFrom<RG, Context = Ctx, Error = Err>, H: ValidateFrom<RH, Context = Ctx, Error = Err>, I: ValidateFrom<RI, Context = Ctx, Error = Err>, J: ValidateFrom<RJ, Context = Ctx, Error = Err>, K: ValidateFrom<RK, Context = Ctx, Error = Err>, L: ValidateFrom<RL, Context = Ctx, Error = Err>, M: ValidateFrom<RM, Context = Ctx, Error = Err>, N: ValidateFrom<RN, Context = Ctx, Error = Err>, O: ValidateFrom<RO, Context = Ctx, Error = Err>, P: ValidateFrom<RP, Context = Ctx, Error = Err>, Q: ValidateFrom<RQ, Context = Ctx, Error = Err>, R: ValidateFrom<RR, Context = Ctx, Error = Err>, S: ValidateFrom<RS, Context = Ctx, Error = Err>, T: ValidateFrom<RT, Context = Ctx, Error = Err>, U: ValidateFrom<RU, Context = Ctx, Error = Err>, V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RC, RD, RE, RF, RG, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, RD, RE, RF, RG, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ> ValidateFrom<(RD, RE, RF, RG, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ)> for (D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where D: ValidateFrom<RD, Context = Ctx, Error = Err>, E: ValidateFrom<RE, Context = Ctx, Error = Err>, F: ValidateFrom<RF, Context = Ctx, Error = Err>, G: ValidateFrom<RG, Context = Ctx, Error = Err>, H: ValidateFrom<RH, Context = Ctx, Error = Err>, I: ValidateFrom<RI, Context = Ctx, Error = Err>, J: ValidateFrom<RJ, Context = Ctx, Error = Err>, K: ValidateFrom<RK, Context = Ctx, Error = Err>, L: ValidateFrom<RL, Context = Ctx, Error = Err>, M: ValidateFrom<RM, Context = Ctx, Error = Err>, N: ValidateFrom<RN, Context = Ctx, Error = Err>, O: ValidateFrom<RO, Context = Ctx, Error = Err>, P: ValidateFrom<RP, Context = Ctx, Error = Err>, Q: ValidateFrom<RQ, Context = Ctx, Error = Err>, R: ValidateFrom<RR, Context = Ctx, Error = Err>, S: ValidateFrom<RS, Context = Ctx, Error = Err>, T: ValidateFrom<RT, Context = Ctx, Error = Err>, U: ValidateFrom<RU, Context = Ctx, Error = Err>, V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RD, RE, RF, RG, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, RE, RF, RG, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ> ValidateFrom<(RE, RF, RG, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ)> for (E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where E: ValidateFrom<RE, Context = Ctx, Error = Err>, F: ValidateFrom<RF, Context = Ctx, Error = Err>, G: ValidateFrom<RG, Context = Ctx, Error = Err>, H: ValidateFrom<RH, Context = Ctx, Error = Err>, I: ValidateFrom<RI, Context = Ctx, Error = Err>, J: ValidateFrom<RJ, Context = Ctx, Error = Err>, K: ValidateFrom<RK, Context = Ctx, Error = Err>, L: ValidateFrom<RL, Context = Ctx, Error = Err>, M: ValidateFrom<RM, Context = Ctx, Error = Err>, N: ValidateFrom<RN, Context = Ctx, Error = Err>, O: ValidateFrom<RO, Context = Ctx, Error = Err>, P: ValidateFrom<RP, Context = Ctx, Error = Err>, Q: ValidateFrom<RQ, Context = Ctx, Error = Err>, R: ValidateFrom<RR, Context = Ctx, Error = Err>, S: ValidateFrom<RS, Context = Ctx, Error = Err>, T: ValidateFrom<RT, Context = Ctx, Error = Err>, U: ValidateFrom<RU, Context = Ctx, Error = Err>, V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RE, RF, RG, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, RF, RG, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ> ValidateFrom<(RF, RG, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ)> for (F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where F: ValidateFrom<RF, Context = Ctx, Error = Err>, G: ValidateFrom<RG, Context = Ctx, Error = Err>, H: ValidateFrom<RH, Context = Ctx, Error = Err>, I: ValidateFrom<RI, Context = Ctx, Error = Err>, J: ValidateFrom<RJ, Context = Ctx, Error = Err>, K: ValidateFrom<RK, Context = Ctx, Error = Err>, L: ValidateFrom<RL, Context = Ctx, Error = Err>, M: ValidateFrom<RM, Context = Ctx, Error = Err>, N: ValidateFrom<RN, Context = Ctx, Error = Err>, O: ValidateFrom<RO, Context = Ctx, Error = Err>, P: ValidateFrom<RP, Context = Ctx, Error = Err>, Q: ValidateFrom<RQ, Context = Ctx, Error = Err>, R: ValidateFrom<RR, Context = Ctx, Error = Err>, S: ValidateFrom<RS, Context = Ctx, Error = Err>, T: ValidateFrom<RT, Context = Ctx, Error = Err>, U: ValidateFrom<RU, Context = Ctx, Error = Err>, V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RF, RG, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, RG, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ> ValidateFrom<(RG, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ)> for (G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where G: ValidateFrom<RG, Context = Ctx, Error = Err>, H: ValidateFrom<RH, Context = Ctx, Error = Err>, I: ValidateFrom<RI, Context = Ctx, Error = Err>, J: ValidateFrom<RJ, Context = Ctx, Error = Err>, K: ValidateFrom<RK, Context = Ctx, Error = Err>, L: ValidateFrom<RL, Context = Ctx, Error = Err>, M: ValidateFrom<RM, Context = Ctx, Error = Err>, N: ValidateFrom<RN, Context = Ctx, Error = Err>, O: ValidateFrom<RO, Context = Ctx, Error = Err>, P: ValidateFrom<RP, Context = Ctx, Error = Err>, Q: ValidateFrom<RQ, Context = Ctx, Error = Err>, R: ValidateFrom<RR, Context = Ctx, Error = Err>, S: ValidateFrom<RS, Context = Ctx, Error = Err>, T: ValidateFrom<RT, Context = Ctx, Error = Err>, U: ValidateFrom<RU, Context = Ctx, Error = Err>, V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RG, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ> ValidateFrom<(RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ)> for (H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where H: ValidateFrom<RH, Context = Ctx, Error = Err>, I: ValidateFrom<RI, Context = Ctx, Error = Err>, J: ValidateFrom<RJ, Context = Ctx, Error = Err>, K: ValidateFrom<RK, Context = Ctx, Error = Err>, L: ValidateFrom<RL, Context = Ctx, Error = Err>, M: ValidateFrom<RM, Context = Ctx, Error = Err>, N: ValidateFrom<RN, Context = Ctx, Error = Err>, O: ValidateFrom<RO, Context = Ctx, Error = Err>, P: ValidateFrom<RP, Context = Ctx, Error = Err>, Q: ValidateFrom<RQ, Context = Ctx, Error = Err>, R: ValidateFrom<RR, Context = Ctx, Error = Err>, S: ValidateFrom<RS, Context = Ctx, Error = Err>, T: ValidateFrom<RT, Context = Ctx, Error = Err>, U: ValidateFrom<RU, Context = Ctx, Error = Err>, V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RH, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ> ValidateFrom<(RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ)> for (I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where I: ValidateFrom<RI, Context = Ctx, Error = Err>, J: ValidateFrom<RJ, Context = Ctx, Error = Err>, K: ValidateFrom<RK, Context = Ctx, Error = Err>, L: ValidateFrom<RL, Context = Ctx, Error = Err>, M: ValidateFrom<RM, Context = Ctx, Error = Err>, N: ValidateFrom<RN, Context = Ctx, Error = Err>, O: ValidateFrom<RO, Context = Ctx, Error = Err>, P: ValidateFrom<RP, Context = Ctx, Error = Err>, Q: ValidateFrom<RQ, Context = Ctx, Error = Err>, R: ValidateFrom<RR, Context = Ctx, Error = Err>, S: ValidateFrom<RS, Context = Ctx, Error = Err>, T: ValidateFrom<RT, Context = Ctx, Error = Err>, U: ValidateFrom<RU, Context = Ctx, Error = Err>, V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RI, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ> ValidateFrom<(RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ)> for (J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where J: ValidateFrom<RJ, Context = Ctx, Error = Err>, K: ValidateFrom<RK, Context = Ctx, Error = Err>, L: ValidateFrom<RL, Context = Ctx, Error = Err>, M: ValidateFrom<RM, Context = Ctx, Error = Err>, N: ValidateFrom<RN, Context = Ctx, Error = Err>, O: ValidateFrom<RO, Context = Ctx, Error = Err>, P: ValidateFrom<RP, Context = Ctx, Error = Err>, Q: ValidateFrom<RQ, Context = Ctx, Error = Err>, R: ValidateFrom<RR, Context = Ctx, Error = Err>, S: ValidateFrom<RS, Context = Ctx, Error = Err>, T: ValidateFrom<RT, Context = Ctx, Error = Err>, U: ValidateFrom<RU, Context = Ctx, Error = Err>, V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RJ, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ> ValidateFrom<(RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ)> for (K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where K: ValidateFrom<RK, Context = Ctx, Error = Err>, L: ValidateFrom<RL, Context = Ctx, Error = Err>, M: ValidateFrom<RM, Context = Ctx, Error = Err>, N: ValidateFrom<RN, Context = Ctx, Error = Err>, O: ValidateFrom<RO, Context = Ctx, Error = Err>, P: ValidateFrom<RP, Context = Ctx, Error = Err>, Q: ValidateFrom<RQ, Context = Ctx, Error = Err>, R: ValidateFrom<RR, Context = Ctx, Error = Err>, S: ValidateFrom<RS, Context = Ctx, Error = Err>, T: ValidateFrom<RT, Context = Ctx, Error = Err>, U: ValidateFrom<RU, Context = Ctx, Error = Err>, V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RK, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ> ValidateFrom<(RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ)> for (L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where L: ValidateFrom<RL, Context = Ctx, Error = Err>, M: ValidateFrom<RM, Context = Ctx, Error = Err>, N: ValidateFrom<RN, Context = Ctx, Error = Err>, O: ValidateFrom<RO, Context = Ctx, Error = Err>, P: ValidateFrom<RP, Context = Ctx, Error = Err>, Q: ValidateFrom<RQ, Context = Ctx, Error = Err>, R: ValidateFrom<RR, Context = Ctx, Error = Err>, S: ValidateFrom<RS, Context = Ctx, Error = Err>, T: ValidateFrom<RT, Context = Ctx, Error = Err>, U: ValidateFrom<RU, Context = Ctx, Error = Err>, V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RL, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ> ValidateFrom<(RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ)> for (M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where M: ValidateFrom<RM, Context = Ctx, Error = Err>, N: ValidateFrom<RN, Context = Ctx, Error = Err>, O: ValidateFrom<RO, Context = Ctx, Error = Err>, P: ValidateFrom<RP, Context = Ctx, Error = Err>, Q: ValidateFrom<RQ, Context = Ctx, Error = Err>, R: ValidateFrom<RR, Context = Ctx, Error = Err>, S: ValidateFrom<RS, Context = Ctx, Error = Err>, T: ValidateFrom<RT, Context = Ctx, Error = Err>, U: ValidateFrom<RU, Context = Ctx, Error = Err>, V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RM, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ> ValidateFrom<(RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ)> for (N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

where N: ValidateFrom<RN, Context = Ctx, Error = Err>, O: ValidateFrom<RO, Context = Ctx, Error = Err>, P: ValidateFrom<RP, Context = Ctx, Error = Err>, Q: ValidateFrom<RQ, Context = Ctx, Error = Err>, R: ValidateFrom<RR, Context = Ctx, Error = Err>, S: ValidateFrom<RS, Context = Ctx, Error = Err>, T: ValidateFrom<RT, Context = Ctx, Error = Err>, U: ValidateFrom<RU, Context = Ctx, Error = Err>, V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RN, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, O, P, Q, R, S, T, U, V, W, X, Y, Z, RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ> ValidateFrom<(RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ)> for (O, P, Q, R, S, T, U, V, W, X, Y, Z)

where O: ValidateFrom<RO, Context = Ctx, Error = Err>, P: ValidateFrom<RP, Context = Ctx, Error = Err>, Q: ValidateFrom<RQ, Context = Ctx, Error = Err>, R: ValidateFrom<RR, Context = Ctx, Error = Err>, S: ValidateFrom<RS, Context = Ctx, Error = Err>, T: ValidateFrom<RT, Context = Ctx, Error = Err>, U: ValidateFrom<RU, Context = Ctx, Error = Err>, V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RO, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, P, Q, R, S, T, U, V, W, X, Y, Z, RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ> ValidateFrom<(RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ)> for (P, Q, R, S, T, U, V, W, X, Y, Z)

where P: ValidateFrom<RP, Context = Ctx, Error = Err>, Q: ValidateFrom<RQ, Context = Ctx, Error = Err>, R: ValidateFrom<RR, Context = Ctx, Error = Err>, S: ValidateFrom<RS, Context = Ctx, Error = Err>, T: ValidateFrom<RT, Context = Ctx, Error = Err>, U: ValidateFrom<RU, Context = Ctx, Error = Err>, V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RP, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, Q, R, S, T, U, V, W, X, Y, Z, RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ> ValidateFrom<(RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ)> for (Q, R, S, T, U, V, W, X, Y, Z)

where Q: ValidateFrom<RQ, Context = Ctx, Error = Err>, R: ValidateFrom<RR, Context = Ctx, Error = Err>, S: ValidateFrom<RS, Context = Ctx, Error = Err>, T: ValidateFrom<RT, Context = Ctx, Error = Err>, U: ValidateFrom<RU, Context = Ctx, Error = Err>, V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RQ, RR, RS, RT, RU, RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, R, S, T, U, V, W, X, Y, Z, RR, RS, RT, RU, RV, RW, RX, RY, RZ> ValidateFrom<(RR, RS, RT, RU, RV, RW, RX, RY, RZ)> for (R, S, T, U, V, W, X, Y, Z)

where R: ValidateFrom<RR, Context = Ctx, Error = Err>, S: ValidateFrom<RS, Context = Ctx, Error = Err>, T: ValidateFrom<RT, Context = Ctx, Error = Err>, U: ValidateFrom<RU, Context = Ctx, Error = Err>, V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RR, RS, RT, RU, RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, S, T, U, V, W, X, Y, Z, RS, RT, RU, RV, RW, RX, RY, RZ> ValidateFrom<(RS, RT, RU, RV, RW, RX, RY, RZ)> for (S, T, U, V, W, X, Y, Z)

where S: ValidateFrom<RS, Context = Ctx, Error = Err>, T: ValidateFrom<RT, Context = Ctx, Error = Err>, U: ValidateFrom<RU, Context = Ctx, Error = Err>, V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RS, RT, RU, RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, T, U, V, W, X, Y, Z, RT, RU, RV, RW, RX, RY, RZ> ValidateFrom<(RT, RU, RV, RW, RX, RY, RZ)> for (T, U, V, W, X, Y, Z)

where T: ValidateFrom<RT, Context = Ctx, Error = Err>, U: ValidateFrom<RU, Context = Ctx, Error = Err>, V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RT, RU, RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, U, V, W, X, Y, Z, RU, RV, RW, RX, RY, RZ> ValidateFrom<(RU, RV, RW, RX, RY, RZ)> for (U, V, W, X, Y, Z)

where U: ValidateFrom<RU, Context = Ctx, Error = Err>, V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RU, RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, V, W, X, Y, Z, RV, RW, RX, RY, RZ> ValidateFrom<(RV, RW, RX, RY, RZ)> for (V, W, X, Y, Z)

where V: ValidateFrom<RV, Context = Ctx, Error = Err>, W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RV, RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, W, X, Y, Z, RW, RX, RY, RZ> ValidateFrom<(RW, RX, RY, RZ)> for (W, X, Y, Z)

where W: ValidateFrom<RW, Context = Ctx, Error = Err>, X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RW, RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, X, Y, Z, RX, RY, RZ> ValidateFrom<(RX, RY, RZ)> for (X, Y, Z)

where X: ValidateFrom<RX, Context = Ctx, Error = Err>, Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RX, RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

impl<Ctx: ?Sized, Err, Y, Z, RY, RZ> ValidateFrom<(RY, RZ)> for (Y, Z)

where Y: ValidateFrom<RY, Context = Ctx, Error = Err>, Z: ValidateFrom<RZ, Context = Ctx, Error = Err>,

type Context = Ctx

type Error = Err

fn validate_from_in_context( raw: (RY, RZ), ctx: &Self::Context, ) -> Result<Self, Self::Error>

Implementors

impl<T: Valid, R: Into<T>> ValidateFrom<R> for T

type Context = ()

type Error = !