parval 0.1.0

Validation pattern compatible with concurrency models
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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

#![feature(try_trait_v2, const_destruct)]
use std::{
    marker::Destruct,
    ops::{ControlFlow, FromResidual, Try},
};

#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
pub struct Validation<T, E, W> {
    pub warnings: Vec<W>,
    pub result: Result<T, Vec<E>>,
}

pub struct ValidationResidual<E, W> {
    warnings: Vec<W>,
    errors: Vec<E>,
}

impl<T, E, W> Validation<T, E, W> {
    pub fn ok(self) -> Option<T> {
        self.result.ok()
    }

    pub fn map<U, F>(self, f: F) -> Validation<U, E, W>
    where
        F: FnOnce(T) -> U + Destruct,
    {
        Validation {
            warnings: self.warnings,
            result: self.result.map(f),
        }
    }

    pub fn warn(&mut self, warning: W) -> &mut Self {
        self.warnings.push(warning);
        self
    }

    pub fn warns<I>(&mut self, warnings: I) -> &mut Self
    where
        I: Iterator<Item = W>,
    {
        for warning in warnings {
            self.warnings.push(warning);
        }

        self
    }
}

impl<T, E, W> Try for Validation<T, E, W> {
    type Output = T;

    type Residual = ValidationResidual<E, W>;

    fn branch(self) -> std::ops::ControlFlow<Self::Residual, Self::Output> {
        match self.result {
            Err(errors) => ControlFlow::Break(ValidationResidual {
                warnings: self.warnings,
                errors,
            }),
            Ok(value) => ControlFlow::Continue(value),
        }
    }

    fn from_output(output: Self::Output) -> Self {
        Self {
            warnings: Vec::new(),
            result: Ok(output),
        }
    }
}

impl<T, E, W> FromResidual for Validation<T, E, W> {
    fn from_residual(residual: <Self as Try>::Residual) -> Self {
        Self {
            warnings: residual.warnings,
            result: Err(residual.errors),
        }
    }
}