kamo 0.9.4

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
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

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

use super::SequenceError;

/// Creates a parser that parses `prefix` followed by `element`. The parser will
/// return the result of `element`.
///
/// # Examples
///
/// ```rust
/// # use kamo::{Position, parser::{
/// #     prelude::*, CharacterError, SequenceError, code, Input, Span
/// # }};
/// let mut parser = preceded(char('('), tag("let"));
///
/// assert_eq!(parser(Input::new("(let")), Ok(("let", Input::new(""))));
/// assert_eq!(parser(Input::new(")let")), Err(ParseError::new(
///     Position::new(0, 1, 1),
///     code::ERR_PRECEDED,
///     SequenceError::Preceded
/// )));
/// assert_eq!(parser(Input::new("(abc")), Err(ParseError::new(
///     Position::new(1, 1, 2),
///     code::ERR_TAG,
///     CharacterError::Tag("let")
/// )));
/// 
/// let error = parser(Input::new("(")).expect_err("error output");
/// 
/// assert!(error.is_eof());
/// assert_eq!(error, ParseError::new(
///     Position::new(1, 1, 2),
///     code::ERR_TAG,
///     CharacterError::Tag("let")
/// ));
/// 
/// let error = parser(Input::new("")).expect_err("error output");
/// 
/// assert!(error.is_eof());
/// assert_eq!(error, ParseError::new(
///     Position::new(0, 1, 1),
///     code::ERR_PRECEDED,
///     CharacterError::Char('(')
/// ));
/// ```
pub fn preceded<'a, 'b, F1, F2, O1, O2>(
    mut prefix: F1,
    mut element: F2,
) -> impl FnMut(Input<'a>) -> ParseResult<'a, O2>
where
    O1: 'b,
    O2: 'b,
    F1: Parser<'a, 'b, O1>,
    F2: Parser<'a, 'b, O2>,
{
    move |input| {
        let (_, cursor) = prefix.parse(input).map_err(|mut err| {
            err.push(
                Span::new(input.position(), err.span().end()),
                code::ERR_PRECEDED,
                SequenceError::Preceded,
            );
            err
        })?;
        element.parse(cursor)
    }
}

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

    use crate::{
        parser::{character::CharacterError, prelude::*, ParseError},
        Position,
    };

    #[test]
    fn preceded_success() {
        let (output, input) =
            preceded(char('('), tag("let"))(Input::new("(let")).expect("valid output");

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

    #[test]
    fn preceded_failure() {
        let error =
            preceded(char('('), tag("let"))(Input::new(")let")).expect_err("invalid output");

        assert_eq!(
            error,
            ParseError::new(
                Position::new(0, 1, 1),
                code::ERR_PRECEDED,
                SequenceError::Preceded
            )
        );

        let error =
            preceded(char('('), tag("let"))(Input::new("(abc")).expect_err("invalid output");

        assert_eq!(
            error,
            ParseError::new(
                Position::new(1, 1, 2),
                code::ERR_TAG,
                CharacterError::Tag("let")
            )
        );

        let error = preceded(char('('), tag("let"))(Input::new("(")).expect_err("invalid output");

        assert!(error.is_eof());
        assert_eq!(
            error,
            ParseError::eof(Position::new(1, 1, 2)).and(
                Position::new(1, 1, 2),
                code::ERR_TAG,
                CharacterError::Tag("let")
            )
        );
    }
}