kamo 0.9.0

A library to assist in the creation of an interpreter or compiler and its associated runtime.
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

use crate::parser::{Input, ParseResult, Parser};

/// Makes a parser optional.
/// 
/// If the parser succeeds, the output is wrapped in `Some`. If the parser fails
/// with a semantic or failure error, the error is returned. Otherwise, the
/// output is `None`.
///
/// # Examples
///
/// ```rust
/// # use kamo::parser::{prelude::*, Input};
/// let mut parser = opt(char('a'));
///
/// assert_eq!(parser.parse("abc".into()), Ok((Some('a'), Input::from("bc"))));
/// assert_eq!(parser.parse("bc".into()), Ok((None, Input::from("bc"))));
/// assert_eq!(parser.parse("".into()), Ok((None, Input::from(""))));
/// ```
pub fn opt<'a, 'b, O, F>(mut f: F) -> impl FnMut(Input<'a>) -> ParseResult<'a, Option<O>>
where
    O: 'b,
    F: Parser<'a, 'b, O>,
{
    move |input| match f.parse(input) {
        Ok((value, input)) => Ok((Some(value), input)),
        Err(err) => {
            if err.is_semantic() || err.is_failure() {
                Err(err)
            } else {
                Ok((None, input))
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    use crate::{parser::prelude::*, Position};

    #[test]
    fn opt_none() {
        let (output, input) = opt(tag("def"))(Input::new("abc")).expect("valid output");

        assert_eq!(output, None);
        assert_eq!(input, Input::from("abc"));
        assert_eq!(input.position(), Position::new(0, 1, 1));
        assert_eq!(input.current(), Some('a'));

        let (output, input) = opt(tag("def"))(Input::new("")).expect("valid output");

        assert_eq!(output, None);
        assert_eq!(input, Input::from(""));
        assert_eq!(input.position(), Position::new(0, 1, 1));
        assert_eq!(input.current(), None);
    }

    #[test]
    fn opt_some() {
        let (output, input) = opt(tag("def"))(Input::new("defabc")).expect("valid output");

        assert_eq!(output, Some("def"));
        assert_eq!(input, Input::from("abc"));
        assert_eq!(input.position(), Position::new(3, 1, 4));
        assert_eq!(input.current(), Some('a'));
    }
}