gdp_rs 0.1.1

A library for implementing Ghosts-of-departed-proofs pattern in rust
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! I define types to represent binary classified values of a subject type.
//!

use std::ops::Deref;

use either::Either;

use crate::{
    predicate::{PurePredicate, SyncEvaluablePredicate},
    Proven,
};

/// A trait for defining a binary classification over a subject type.
pub trait BinaryClassification<Subject> {
    /// Type of left class predicate.
    type LeftPredicate: BinaryClassPredicate<Subject, BinClassification = Self>;

    /// Type of right class predicate.
    type RightPredicate: BinaryClassPredicate<Subject, BinClassification = Self>;
}

/// A trait for defining predicate associated with a class in binary classification.
pub trait BinaryClassPredicate<Subject>: PurePredicate<Subject> {
    /// Type of classification, in which this predicate determines a class.
    type BinClassification: BinaryClassification<Subject>;
}

/// An enum for representing binary classified values of a subject type.
pub struct BinaryClassified<Subject, Cln>(
    pub Either<Proven<Subject, Cln::LeftPredicate>, Proven<Subject, Cln::RightPredicate>>,
)
where
    Cln: BinaryClassification<Subject>;

impl<Subject: Clone, Cln> Clone for BinaryClassified<Subject, Cln>
where
    Cln: BinaryClassification<Subject>,
{
    fn clone(&self) -> Self {
        Self(self.0.clone())
    }
}

impl<Subject: std::fmt::Debug, Cln> std::fmt::Debug for BinaryClassified<Subject, Cln>
where
    Cln: BinaryClassification<Subject>,
{
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_tuple("BinaryClassified").field(&self.0).finish()
    }
}

impl<Subject, Cln> BinaryClassified<Subject, Cln>
where
    Cln: BinaryClassification<Subject>,
{
    /// Get a new binary classified subject value.
    pub fn new(subject: Subject) -> Self
    where
        Cln::LeftPredicate: SyncEvaluablePredicate<Subject>,
    {
        Self(
            match Proven::<Subject, Cln::LeftPredicate>::try_new(subject) {
                Ok(left_proven) => Either::Left(left_proven),

                // # Safety:
                //
                // Safe, as PL and PR are binary opposite predicates.
                Err(err) => unsafe { Either::Right(Proven::new_unchecked(err.into_parts().0)) },
            },
        )
    }

    /// Get a reference to inner subject value.
    pub fn as_inner(&self) -> &Subject {
        match &self.0 {
            Either::Left(l) => l.as_ref(),
            Either::Right(r) => r.as_ref(),
        }
    }

    /// Convert into inner subject value.
    pub fn into_inner(self) -> Subject {
        match self.0 {
            Either::Left(l) => l.into_subject(),
            Either::Right(r) => r.into_subject(),
        }
    }

    /// Get if inner value is left classified.
    #[inline]
    pub fn is_left_classified(&self) -> bool {
        self.0.is_left()
    }

    /// Get if inner value is left classified.
    #[inline]
    pub fn is_right_classified(&self) -> bool {
        self.0.is_right()
    }

    /// Get as left classified value.
    pub fn as_left_classified(&self) -> Option<&Proven<Subject, Cln::LeftPredicate>> {
        match &self.0 {
            Either::Left(left) => Some(left),
            Either::Right(_) => None,
        }
    }

    /// Get as right classified value.
    pub fn as_right_classified(&self) -> Option<&Proven<Subject, Cln::RightPredicate>> {
        match &self.0 {
            Either::Left(_) => None,
            Either::Right(right) => Some(right),
        }
    }
}

impl<Subject, Cln> Deref for BinaryClassified<Subject, Cln>
where
    Cln: BinaryClassification<Subject>,
{
    type Target = Subject;

    #[inline]
    fn deref(&self) -> &Self::Target {
        self.as_inner()
    }
}

impl<Subject, Cln> AsRef<Subject> for BinaryClassified<Subject, Cln>
where
    Cln: BinaryClassification<Subject>,
{
    #[inline]
    fn as_ref(&self) -> &Subject {
        self.as_inner()
    }
}