kamo 0.5.2

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

use std::fmt;

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

use super::{
    code::{self, Code},
    ParseError,
};

/// Add a context to the error with a message. The code is set to
/// [`ERR_CONTEXT`](super::code).
///
/// # Examples
///
/// ```rust
/// # use kamo::parser::{prelude::*, code, Input, Position};
/// let mut parser = context(tag("hello"), "Expected `hello`");
///
/// assert_eq!(parser.parse("hello world".into()),
///     Ok(("hello", Input::from(" world"))));
/// assert_eq!(parser.parse("world".into()), Err(ParseError::new(
///     Position::new(0, 1, 1),
///     code::ERR_CONTEXT,
///     "Expected `hello`"
/// )));
/// ```
pub fn context<'a, 'b, F, O, M>(mut f: F, msg: M) -> impl FnMut(Input<'a>) -> ParseResult<'a, O>
where
    O: 'b,
    F: Parser<'a, 'b, O> + 'b,
    M: fmt::Display,
{
    let msg = msg.to_string();

    move |input| {
        f.parse(input).map_err(|mut err| {
            err.push(
                Span::new(input.position(), err.span().end()),
                code::ERR_CONTEXT,
                msg.to_owned(),
            );
            err
        })
    }
}

/// Add a context to the error with a message and a custom code.
///
/// # Examples
///
/// ```rust
/// # use kamo::parser::{prelude::*, code, Input, Position};
/// let mut parser = context_as(tag("hello"), code::ERR_TAG, "Expected `hello`");
///
/// assert_eq!(parser.parse("hello world".into()),
///     Ok(("hello", Input::from(" world"))));
/// assert_eq!(parser.parse("world".into()), Err(ParseError::new(
///     Position::new(0, 1, 1),
///     code::ERR_TAG,
///     "Expected `hello`"
/// )));
pub fn context_as<'a, 'b, F, O, M>(
    mut f: F,
    code: Code,
    msg: M,
) -> impl FnMut(Input<'a>) -> ParseResult<'a, O>
where
    O: 'b,
    F: Parser<'a, 'b, O> + 'b,
    M: fmt::Display,
{
    let msg = msg.to_string();

    move |input| {
        f.parse(input).map_err(|mut err| {
            err.push(
                Span::new(input.position(), err.span().end()),
                code,
                msg.to_owned(),
            );
            err
        })
    }
}

/// Add a context to the error with a custom code and a custom message. The
/// message and code is generated by the closure.
///
/// # Examples
///
/// ```rust
/// # use kamo::parser::{prelude::*, code, Input, Position};
/// let mut parser = context_and(tag("hello"), |err| {
///     (code::ERR_TAG, "Expected `hello`".into())
/// });
/// 
/// assert_eq!(parser.parse("hello world".into()),
///     Ok(("hello", Input::from(" world"))));
/// assert_eq!(parser.parse("world".into()), Err(ParseError::new(
///     Position::new(0, 1, 1),
///     code::ERR_TAG,
///     "Expected `hello`"
/// )));
/// ```
pub fn context_and<'a, 'b, F1, F2, O>(
    mut f: F1,
    mut g: F2,
) -> impl FnMut(Input<'a>) -> ParseResult<'a, O>
where
    O: 'b,
    F1: Parser<'a, 'b, O> + 'b,
    F2: FnMut(&ParseError) -> (Code, String),
{
    move |input| {
        f.parse(input).map_err(|mut err| {
            let (code, msg) = g(&err);
            err.push(Span::new(input.position(), err.span().end()), code, msg);
            err
        })
    }
}