udled-tokenizers 0.6.0

Tokenizers for udled
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

use udled::{
    tokenizers::or, AsBytes, AsChar, Buffer, Error, Item, Reader, Tokenizer, TokenizerExt,
};

/// Match 'true' or 'false'
#[derive(Debug, Clone, Copy, Default)]
pub struct Bool;

impl<'input, B> Tokenizer<'input, B> for Bool
where
    B: Buffer<'input>,
    B::Item: AsChar,
    B::Source: AsBytes<'input>,
{
    type Token = Item<bool>;

    fn to_token<'a>(&self, reader: &mut Reader<'_, 'input, B>) -> Result<Self::Token, Error> {
        let item = reader
            .parse(or(
                "true".map_ok(|m| m.map(|_| true)),
                "false".map_ok(|m| m.map(|_| false)),
            ))?
            .unify();

        Ok(item)
    }

    fn eat(&self, reader: &mut Reader<'_, 'input, B>) -> Result<(), Error> {
        reader.eat(or("true", "false"))
    }

    fn peek<'a>(&self, reader: &mut Reader<'_, 'input, B>) -> bool {
        reader.is(or("true", "false"))
    }
}

#[cfg(test)]
mod test {
    use udled::{Input, EOF};

    use super::Bool;

    #[test]
    fn bool() {
        let mut input = Input::new("true false");

        let (a, _, b) = input.parse((Bool, ' ', Bool)).unwrap();

        assert_eq!(a.value, true);
        assert_eq!(b.value, false);
        assert!(input.is(EOF))
    }
}