unsynn 0.3.0

(Proc-macro) parsing made easy
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

//! For easier composition we define the [`Delimited`] type here which is a `T`
//! followed by a optional delimiting entity `D`. This is used by the
//! [`DelimitedVec`] type to parse a list of entities separated by a delimiter.

#![allow(clippy::module_name_repetitions)]

#[allow(clippy::wildcard_imports)]
use crate::*;

/// This is used when one wants to parse a list of entities separated by delimiters. The
/// delimiter is optional and can be `None` eg. when the entity is the last in the
/// list. Usually the delimiter will be some simple punctuation token, but it is not limited
/// to that.
#[derive(Clone)]
pub struct Delimited<T, D> {
    /// The parsed value
    pub value: T,
    /// The optional delimiter
    pub delimiter: Option<D>,
}

impl<T: Parse, D: Parse> Parser for Delimited<T, D> {
    fn parser(tokens: &mut TokenIter) -> Result<Self> {
        Ok(Self {
            value: T::parser(tokens)?,
            delimiter: Option::<D>::parser(tokens)?,
        })
    }
}

impl<T: ToTokens, D: ToTokens> ToTokens for Delimited<T, D> {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        self.value.to_tokens(tokens);
        self.delimiter.to_tokens(tokens);
    }
}

#[mutants::skip]
impl<T: std::fmt::Debug, D: std::fmt::Debug> std::fmt::Debug for Delimited<T, D> {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct(&format!(
            "Delimited<{}, {}>",
            std::any::type_name::<T>(),
            std::any::type_name::<D>()
        ))
        .field("value", &self.value)
        .field("delimiter", &self.delimiter)
        .finish()
    }
}

/// `T` followed by an optional `,`
pub type CommaDelimited<T> = Delimited<T, Comma>;
/// `T` followed by an optional `:`
pub type ColonDelimited<T> = Delimited<T, Colon>;
/// `T` followed by an optional `;`
pub type SemicolonDelimited<T> = Delimited<T, Semicolon>;
/// `T` followed by an optional `.`
pub type DotDelimited<T> = Delimited<T, Dot>;
/// `T` followed by an optional `::`
pub type PathSepDelimited<T> = Delimited<T, PathSep>;