validatus 0.0.6

Validator types, returns multiple tolerable errors at once
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

use super::*;
use alloc::vec;
use core::convert::Infallible;

use core::ops::{ControlFlow, FromResidual, Try};

impl<T, F, E> FromResidual<Result<Infallible, E>> for Validation<T, F>
where
    F: From<E>,
{
    fn from_residual(residual: Result<Infallible, E>) -> Self {
        match residual {
            Ok(_) => unreachable!(),
            Err(e) => Failure { fatal: e.into(), diagnostics: vec![] },
        }
    }
}

impl<T, E, A> FromResidual<Validation<A, E>> for Validation<T, E> {
    fn from_residual(residual: Validation<A, E>) -> Self {
        match residual {
            Success { .. } => unreachable!(),
            Failure { fatal, diagnostics } => Failure { fatal, diagnostics },
        }
    }
}

impl<T, F> Try for Validation<T, F> {
    type Output = T;
    type Residual = Validation<T, F>;

    fn from_output(output: Self::Output) -> Self {
        Success { value: output, diagnostics: vec![] }
    }

    fn branch(self) -> ControlFlow<Self::Residual, Self::Output> {
        match self {
            Success { value, diagnostics: _ } => ControlFlow::Continue(value),
            Failure { fatal, diagnostics } => ControlFlow::Break(Failure { fatal, diagnostics }),
        }
    }
}