compris 0.0.11

Composite Primitive Schema (CPS) for 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

use super::super::annotate::*;

use {
    depiction::*,
    std::{cmp::*, fmt, hash::*, io},
};

//
// Null
//

/// Normal null variant.
///
/// [Annotations], if present, are *ignored* for the purposes of comparison and hashing.
#[derive(Clone, Debug)]
pub struct Null<AnnotatedT> {
    /// Annotated.
    pub annotated: AnnotatedT,
}

impl_annotated!(Null);

impl<AnnotatedT, NewAnnotatedT> IntoAnnotated<Null<NewAnnotatedT>> for Null<AnnotatedT>
where
    AnnotatedT: Annotated,
    NewAnnotatedT: Annotated + Default,
{
    fn into_annotated(self) -> Null<NewAnnotatedT> {
        if AnnotatedT::can_have_annotations()
            && NewAnnotatedT::can_have_annotations()
            && let Some(annotations) = self.annotated.annotations()
        {
            Null::default().with_annotations(annotations.clone())
        } else {
            Default::default()
        }
    }
}

impl<AnnotatedT> RemoveAnnotations<Null<WithoutAnnotations>> for Null<AnnotatedT> {
    fn remove_annotations(self) -> Null<WithoutAnnotations> {
        Default::default()
    }
}

impl<AnnotatedT> Depict for Null<AnnotatedT> {
    fn depict<WriteT>(&self, writer: &mut WriteT, context: &DepictionContext) -> io::Result<()>
    where
        WriteT: io::Write,
    {
        context.separate(writer)?;
        context.theme.write_symbol(writer, "Null")
    }
}

impl<AnnotatedT> Default for Null<AnnotatedT>
where
    AnnotatedT: Default,
{
    fn default() -> Self {
        Self { annotated: Default::default() }
    }
}

impl<AnnotatedT> fmt::Display for Null<AnnotatedT> {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt::Display::fmt("Null", formatter)
    }
}

// Basics

impl<AnnotatedT> PartialEq for Null<AnnotatedT> {
    fn eq(&self, _other: &Self) -> bool {
        true
    }
}

impl<AnnotatedT> Eq for Null<AnnotatedT> {}

impl<AnnotatedT> PartialOrd for Null<AnnotatedT> {
    fn partial_cmp(&self, _other: &Self) -> Option<Ordering> {
        Some(Ordering::Equal)
    }
}

impl<AnnotatedT> Ord for Null<AnnotatedT> {
    fn cmp(&self, _other: &Self) -> Ordering {
        Ordering::Equal
    }
}

impl<AnnotatedT> Hash for Null<AnnotatedT> {
    fn hash<HasherT>(&self, state: &mut HasherT)
    where
        HasherT: Hasher,
    {
        ().hash(state)
    }
}

// Conversions

impl<AnnotatedT> From<()> for Null<AnnotatedT>
where
    AnnotatedT: Default,
{
    fn from(_: ()) -> Self {
        Self::default()
    }
}

impl<AnnotatedT> From<Null<AnnotatedT>> for () {
    fn from(_: Null<AnnotatedT>) -> Self {
        ()
    }
}