utterance 0.1.1

A parser library for creating readable, natural-language-inspired domain-specific languages.
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

use std::fmt;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SpecialChar {
    LeftParen,
    RightParen,
    LeftBracket,
    RightBracket,
    LeftBrace,
    RightBrace,
    LessThan,
    GreaterThan,
    Slash,
    Backslash,
    Pipe,
    Ampersand,
    Asterisk,
    Plus,
    Minus,
    Equal,
    Percent,
    Dollar,
    Hash,
    At,
    Caret,
    Tilde,
    Underscore,
    Backtick,
    Quote,
    Apostrophe,
}

impl TryFrom<char> for SpecialChar {
    type Error = ();

    fn try_from(value: char) -> Result<Self, Self::Error> {
        match value {
            '(' => Ok(Self::LeftParen),
            ')' => Ok(Self::RightParen),
            '[' => Ok(Self::LeftBracket),
            ']' => Ok(Self::RightBracket),
            '{' => Ok(Self::LeftBrace),
            '}' => Ok(Self::RightBrace),
            '<' => Ok(Self::LessThan),
            '>' => Ok(Self::GreaterThan),
            '/' => Ok(Self::Slash),
            '\\' => Ok(Self::Backslash),
            '|' => Ok(Self::Pipe),
            '&' => Ok(Self::Ampersand),
            '*' => Ok(Self::Asterisk),
            '+' => Ok(Self::Plus),
            '-' => Ok(Self::Minus),
            '=' => Ok(Self::Equal),
            '%' => Ok(Self::Percent),
            '$' => Ok(Self::Dollar),
            '#' => Ok(Self::Hash),
            '@' => Ok(Self::At),
            '^' => Ok(Self::Caret),
            '~' => Ok(Self::Tilde),
            '_' => Ok(Self::Underscore),
            '`' => Ok(Self::Backtick),
            '"' => Ok(Self::Quote),
            '\'' => Ok(Self::Apostrophe),
            _ => Err(()),
        }
    }
}

impl SpecialChar {
    pub(crate) const fn as_str(&self) -> &'static str {
        match self {
            Self::LeftParen => "(",
            Self::RightParen => ")",
            Self::LeftBracket => "[",
            Self::RightBracket => "]",
            Self::LeftBrace => "{",
            Self::RightBrace => "}",
            Self::LessThan => "<",
            Self::GreaterThan => ">",
            Self::Slash => "/",
            Self::Backslash => "\\",
            Self::Pipe => "|",
            Self::Ampersand => "&",
            Self::Asterisk => "*",
            Self::Plus => "+",
            Self::Minus => "-",
            Self::Equal => "=",
            Self::Percent => "%",
            Self::Dollar => "$",
            Self::Hash => "#",
            Self::At => "@",
            Self::Caret => "^",
            Self::Tilde => "~",
            Self::Underscore => "_",
            Self::Backtick => "`",
            Self::Quote => "\"",
            Self::Apostrophe => "'",
        }
    }
}

impl fmt::Display for SpecialChar {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(self.as_str())
    }
}