parsy 0.16.3

An easy-to-use, efficient parser combinators library
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

use std::{
    collections::{BTreeSet, HashSet},
    hash::Hash,
};

/// A container to collect values into
///
/// See [`collect`](`crate::ParserConstUtils::collect`)
pub trait Container<T> {
    /// Create a container
    fn create() -> Self;

    /// Create a container with the provided capacity reserved ahead-of-time
    fn with_capacity(size: usize) -> Self;

    /// Create a container from the provided iterator
    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self;

    /// Push a new value into the container
    fn push(&mut self, value: T);
}

impl<T> Container<T> for Vec<T> {
    fn create() -> Self {
        vec![]
    }

    fn with_capacity(size: usize) -> Self {
        Vec::with_capacity(size)
    }

    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
        iter.into_iter().collect()
    }

    fn push(&mut self, value: T) {
        Vec::push(self, value);
    }
}

impl<T: Eq + Hash> Container<T> for HashSet<T> {
    fn create() -> Self {
        HashSet::new()
    }

    fn with_capacity(size: usize) -> Self {
        HashSet::with_capacity(size)
    }

    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
        iter.into_iter().collect::<HashSet<_>>()
    }

    fn push(&mut self, value: T) {
        HashSet::insert(self, value);
    }
}

impl<T: Eq + Ord + Hash> Container<T> for BTreeSet<T> {
    fn create() -> Self {
        BTreeSet::new()
    }

    fn with_capacity(_: usize) -> Self {
        // It is not possible to create a BTreeSet with a provisioned storage
        BTreeSet::new()
    }

    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
        iter.into_iter().collect::<BTreeSet<_>>()
    }

    fn push(&mut self, value: T) {
        BTreeSet::insert(self, value);
    }
}

impl Container<char> for String {
    fn create() -> Self {
        String::new()
    }

    fn with_capacity(size: usize) -> Self {
        String::with_capacity(size)
    }

    fn from_iter<I: IntoIterator<Item = char>>(iter: I) -> Self {
        iter.into_iter().collect()
    }

    fn push(&mut self, value: char) {
        self.push(value)
    }
}

impl Container<String> for String {
    fn create() -> Self {
        String::new()
    }

    fn with_capacity(size: usize) -> Self {
        String::with_capacity(size)
    }

    fn from_iter<I: IntoIterator<Item = String>>(iter: I) -> Self {
        iter.into_iter().collect()
    }

    fn push(&mut self, value: String) {
        self.push_str(&value)
    }
}

/// A container that discards every value
///
/// Does not allocate any memory
#[derive(Clone, Copy)]
pub struct NoAllocContainer;

impl<T> Container<T> for NoAllocContainer {
    fn create() -> Self {
        Self
    }

    fn with_capacity(_: usize) -> Self {
        Self
    }

    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
        // Trigger the iterator to trigger panics etc.
        iter.into_iter().count();
        Self
    }

    fn push(&mut self, _: T) {}
}