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
118
119
120
121
122
123
124
125
126
127

use super::{super::normal::*, iterator::*};

use kutil::std::collections::*;

//
// KeyValuePairIteratorForVariantIterator
//

/// A [KeyValuePairIterator] for an [Iterator] of [Variant].
///
/// The items are expected to be [List](super::super::normal::List) of length 2 (key-value pairs).
///
/// Keeps track of keys and will report errors if it encounters duplicates.
pub struct KeyValuePairIteratorForVariantIterator<'own, InnerT, AnnotatedT> {
    /// Inner.
    pub inner: InnerT,

    /// Accumulated keys.
    pub keys: FastHashSet<&'own Variant<AnnotatedT>>,
}

impl<'own, InnerT, AnnotatedT> KeyValuePairIteratorForVariantIterator<'own, InnerT, AnnotatedT> {
    /// Constructor.
    pub fn new(inner: InnerT) -> Self {
        Self { inner, keys: FastHashSet::default() }
    }

    /// Constructor.
    pub fn new_for<IterableT>(iterable: IterableT) -> Self
    where
        IterableT: IntoIterator<IntoIter = InnerT>,
    {
        Self::new(iterable.into_iter())
    }
}

impl<'own, InnerT, AnnotatedT> KeyValuePairIterator<AnnotatedT>
    for KeyValuePairIteratorForVariantIterator<'own, InnerT, AnnotatedT>
where
    InnerT: Iterator<Item = &'own Variant<AnnotatedT>>,
    AnnotatedT: Default,
{
    fn next(
        &mut self,
    ) -> Result<
        Option<(&'own Variant<AnnotatedT>, &'own Variant<AnnotatedT>)>,
        (MalformedError<AnnotatedT>, &Variant<AnnotatedT>),
    > {
        if let Some(item) = self.inner.next() {
            if let Some((key, value)) = item.to_pair() {
                if self.keys.contains(key) {
                    return Err((MalformedError::new("key-value pair".into(), "key is not unique".into()), key));
                } else {
                    self.keys.insert(key);
                    return Ok(Some((key, value)));
                }
            }

            return Err((MalformedError::new("key-value pair".into(), "is not list of length 2".into()), item));
        }

        Ok(None)
    }
}

//
// IntoKeyValuePairIteratorForVariantIterator
//

/// An [IntoKeyValuePairIterator] for an [Iterator] of [Variant].
///
/// The items are expected to be [List](super::super::normal::List) of length 2 (key-value pairs).
///
/// Keeps track of keys and will report errors if it encounters duplicates.
pub struct IntoKeyValuePairIteratorForVariantIterator<InnerT, AnnotatedT> {
    /// Inner.
    pub inner: InnerT,

    /// Accumulated keys.
    pub keys: FastHashSet<Variant<AnnotatedT>>,
}

impl<InnerT, AnnotatedT> IntoKeyValuePairIteratorForVariantIterator<InnerT, AnnotatedT> {
    /// Constructor.
    pub fn new(inner: InnerT) -> Self {
        Self { inner, keys: FastHashSet::default() }
    }

    /// Constructor.
    pub fn new_for<IterableT>(iterable: IterableT) -> Self
    where
        IterableT: IntoIterator<IntoIter = InnerT>,
    {
        Self::new(iterable.into_iter())
    }
}

impl<InnerT, AnnotatedT> IntoKeyValuePairIterator<AnnotatedT>
    for IntoKeyValuePairIteratorForVariantIterator<InnerT, AnnotatedT>
where
    InnerT: Iterator<Item = Variant<AnnotatedT>>,
    AnnotatedT: Clone + Default,
{
    fn next(
        &mut self,
    ) -> Result<Option<(Variant<AnnotatedT>, Variant<AnnotatedT>)>, (MalformedError<AnnotatedT>, Variant<AnnotatedT>)>
    {
        if let Some(item) = self.inner.next() {
            if let Variant::List(list) = &item
                && list.inner.len() == 2
            {
                let (key, value) = item.into_pair().expect("list of length 2");
                if self.keys.contains(&key) {
                    return Err((MalformedError::new("key-value pair".into(), "key is not unique".into()), key));
                } else {
                    // TODO: any way we can test this without cloning?
                    self.keys.insert(key.clone());
                    return Ok(Some((key, value)));
                }
            }

            return Err((MalformedError::new("key-value pair".into(), "is not list of length 2".into()), item));
        }

        Ok(None)
    }
}