Skip to main content

xrust/parser/combinators/
map.rs

1use crate::item::Node;
2use crate::parser::{ParseError, ParseInput, ParserState, StaticState};
3use qualname::{NamespacePrefix, NamespaceUri};
4
5pub fn map<'a, P, F, A, B, N: Node, L>(
6    parser: P,
7    map_fn: F,
8) -> impl Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, B), ParseError>
9//-> impl Fn(ParseInput<N>)-> Result<(String, usize, B), usize>
10where
11    P: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, A), ParseError>,
12    F: Fn(A) -> B,
13    L: FnMut(&NamespacePrefix) -> Result<NamespaceUri, ParseError>,
14{
15    move |input, ss| parser(input, ss).map(|(input2, result)| (input2, map_fn(result)))
16}
17
18pub fn map_ver<'a, P, F, G, A, B, N: Node, L>(
19    parser: P,
20    map_fn10: F,
21    map_fn11: G,
22) -> impl Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, B), ParseError>
23//-> impl Fn(ParseInput<N>)-> Result<(String, usize, B), usize>
24where
25    P: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, A), ParseError>,
26    F: Fn(A) -> B,
27    G: Fn(A) -> B,
28    L: FnMut(&NamespacePrefix) -> Result<NamespaceUri, ParseError>,
29{
30    move |input, ss| {
31        parser(input, ss).map(|((input2, state2), result)| {
32            if state2.xmlversion == "1.1" {
33                ((input2, state2), map_fn11(result))
34            } else {
35                ((input2, state2), map_fn10(result))
36            }
37        })
38    }
39}
40
41pub fn map_with_state<'a, P, F, A, B, N: Node, L>(
42    parser: P,
43    map_fn: F,
44) -> impl Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, B), ParseError>
45//-> impl Fn(ParseInput<N>)-> Result<(String, usize, B), usize>
46where
47    P: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, A), ParseError>,
48    F: Fn(A, ParserState<N>, &mut StaticState<L>) -> B,
49    L: FnMut(&NamespacePrefix) -> Result<NamespaceUri, ParseError>,
50{
51    move |input, ss| match parser(input, ss) {
52        Ok((input2, result)) => Ok(((input2.0, input2.1.clone()), map_fn(result, input2.1, ss))),
53        Err(err) => Err(err),
54    }
55}
56
57pub fn map_with_state_and_result<'a, P, F, A, B, N: Node, L>(
58    parser: P,
59    map_fn: F,
60) -> impl Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, B), ParseError>
61//-> impl Fn(ParseInput<N>)-> Result<(String, usize, B), usize>
62where
63    P: Fn(ParseInput<'a, N>, &mut StaticState<L>) -> Result<(ParseInput<'a, N>, A), ParseError>,
64    F: Fn(A, ParserState<N>, &mut StaticState<L>) -> Result<B, ParseError>,
65    L: FnMut(&NamespacePrefix) -> Result<NamespaceUri, ParseError>,
66{
67    move |input, ss| match parser(input, ss) {
68        Ok((input2, result)) => match map_fn(result, input2.1.clone(), ss) {
69            Ok(b) => Ok(((input2.0, input2.1.clone()), b)),
70            Err(err) => Err(err),
71        },
72        Err(err) => Err(err),
73    }
74}