glue 0.8.7

Glue is a parser combinator framework for parsing text based formats, it is easy to use and relatively fast too.
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
128
129
130
131
132
133
134
135
136
137

//! Parser combinators for mapping one thing to another.

use crate::types::*;

#[inline]
/// Run a parser and map the error it returns on failure.
///
/// ```
/// # use glue::prelude::*;
/// assert_eq!(
///     map_error(take(1.., is(numeric)), |error| error.tag("a number")).parse("abc"),
///     Err((
///         ParserContext {
///             input: "abc",
///             bounds: 0..0,
///         },
///         SourceError::TaggedRanges(
///             "a number".into(),
///             vec![SourceError::Ranges(vec![SourceError::Range(0..0)])]
///         )
///     ))
/// );
/// ```
pub fn map_error<'a, Res, Par, Map>(mut parser: Par, mut mapper: Map) -> impl Parser<'a, Res>
where
    Par: Parser<'a, Res>,
    Map: FnMut(SourceError) -> SourceError,
{
    move |ctx| parser.parse(ctx).map_error(|result| mapper(result))
}

#[inline]
/// Run a parser and map the data it returns on success.
///
/// ```
/// # use glue::prelude::*;
/// assert_eq!(
///     map_result(take(1.., is(numeric)), |num: &str| num
///         .parse::<usize>()
///         .unwrap())
///     .parse("123"),
///     Ok((
///         ParserContext {
///             input: "123",
///             bounds: 0..3,
///         },
///         123
///     ))
/// );
/// ```
pub fn map_result<'a, OldRes, NewRes, Par, Map>(
    mut parser: Par,
    mut mapper: Map,
) -> impl Parser<'a, NewRes>
where
    Par: Parser<'a, OldRes>,
    Map: FnMut(OldRes) -> NewRes,
{
    move |ctx| parser.parse(ctx).map_result(|result| mapper(result))
}

#[inline]
/// Run a parser and map its result to an `Option<T>`.
///
/// ```
/// # use glue::prelude::*;
/// assert_eq!(
///     optional(is("foobar")).parse("foobar"),
///     Ok((
///         ParserContext {
///             input: "foobar",
///             bounds: 0..6
///         },
///         Some("foobar")
///     ))
/// );
/// assert_eq!(
///     optional(is("foobar")).parse("boofar"),
///     Ok((
///         ParserContext {
///             input: "boofar",
///             bounds: 0..0
///         },
///         None
///     ))
/// );
/// ```
pub fn optional<'a, Res, Par>(mut parser: Par) -> impl Parser<'a, Option<Res>>
where
    Par: Parser<'a, Res>,
{
    move |ctx: ParserContext<'a>| {
        parser
            .parse(ctx.clone())
            .and_then(|(ctx, res)| Ok((ctx, Some(res))))
            .or_else(|(_, _err)| Ok((ctx, None)))
    }
}

#[inline]
pub fn tag_error<'a, Par, Res>(mut parser: Par, message: &'a str) -> impl Parser<'a, Res>
where
    Par: Parser<'a, Res>,
{
    move |ctx| {
        parser
            .parse(ctx)
            .map_error(|error| SourceError::TaggedRanges(message.into(), vec![error]))
    }
}

#[inline]
pub fn tag_error_with<'a, Par, ParRes, Alt, AltRes, Call>(
    mut parser: Par,
    mut alternative: Alt,
    callback: Call,
) -> impl Parser<'a, ParRes>
where
    Par: Parser<'a, ParRes>,
    Alt: Parser<'a, AltRes>,
    Call: Fn(AltRes) -> String,
{
    move |ctx| {
        parser
            .parse(ctx)
            .or_else(|(ctx, error)| match alternative.parse(ctx) {
                Ok((ctx, res)) => Err((
                    ctx.clone(),
                    SourceError::TaggedRanges(
                        callback(res),
                        vec![error, SourceError::Range(ctx.bounds)],
                    ),
                )),
                Err((ctx, _)) => Err((ctx, error)),
            })
    }
}