parlib 0.1.1

A barebones parser combinator library, inspired by Haskells parsec
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

use std::fmt::Debug;

use crate::{traits::Parser, type_alias::ParserRes};

use super::{ParseMatch, ParseWhileOrNothing};

/// A parser that consists of first running some parser A, then some parser B.
///
/// If either of the parsers give an error, that error will be returned. If they
/// both suceed, their outputs will be combined using the `AndCombinator`, and
/// that will be reuturned, with the rest of the unparsed string.
pub struct AndThenParser<A, B, C>
where
    A: Parser,
    B: Parser,
    C: AndCombinator<A::Output, B::Output>,
{
    pub first_parse: A,
    pub second_parse: B,
    combinator: C,
}

impl<A, B, C> AndThenParser<A, B, C>
where
    A: Parser,
    B: Parser,
    C: AndCombinator<A::Output, B::Output>,
{
    pub fn combine<NC>(self, combinator: NC) -> AndThenParser<A, B, NC>
    where
        NC: AndCombinator<A::Output, B::Output>,
    {
        AndThenParser {
            first_parse: self.first_parse,
            second_parse: self.second_parse,
            combinator,
        }
    }
}

/// This serves as a way to combine two parser outputs
pub trait AndCombinator<A, B> {
    type Combined;
    fn combine(&self, pair: (A, B)) -> Self::Combined;
}

/// Combine A and B into a tuple (A, B)
pub struct IdentityAndCombinator;

impl<A, B> AndCombinator<A, B> for IdentityAndCombinator {
    type Combined = (A, B);
    fn combine(&self, pair: (A, B)) -> Self::Combined {
        pair
    }
}

/// Keep the output from the first (A) parser, and discard the output
/// of the second parser (B)
pub struct KeepFirstOutputOnly;

impl<A, B> AndCombinator<A, B> for KeepFirstOutputOnly {
    type Combined = A;
    fn combine(&self, (a, _): (A, B)) -> Self::Combined {
        a
    }
}

/// Keep the output from the second (B) parser, and discard the output
/// of the first parser (A)
pub struct KeepSecondOutputOnly;

impl<A, B> AndCombinator<A, B> for KeepSecondOutputOnly {
    type Combined = B;
    fn combine(&self, (_, b): (A, B)) -> Self::Combined {
        b
    }
}

/// Discard the output of both parsers, and return the unit type
pub struct KeepNone;

impl<A, B> AndCombinator<A, B> for KeepNone {
    type Combined = ();
    fn combine(&self, _: (A, B)) -> Self::Combined {
        ()
    }
}

impl<A, B, C> From<(A, B, C)> for AndThenParser<A, B, C>
where
    A: Parser,
    B: Parser,
    C: AndCombinator<A::Output, B::Output>,
{
    fn from((first_parse, second_parse, combinator): (A, B, C)) -> Self {
        Self {
            first_parse,
            second_parse,
            combinator,
        }
    }
}

impl<A, B> From<(A, B)> for AndThenParser<A, B, IdentityAndCombinator>
where
    A: Parser,
    B: Parser,
{
    fn from((first_parse, second_parse): (A, B)) -> Self {
        Self {
            first_parse,
            second_parse,
            combinator: IdentityAndCombinator,
        }
    }
}

impl<A, B, C> Parser for AndThenParser<A, B, C>
where
    A: Parser,
    B: Parser,
    C: AndCombinator<A::Output, B::Output>,
    C::Combined: Debug,
{
    type Output = C::Combined;
    fn parse(&self, input: &str) -> ParserRes<Self::Output> {
        let (a, rest) = A::parse(&self.first_parse, input)?;
        let (b, rest) = B::parse(&self.second_parse, &rest)?;
        Ok((C::combine(&self.combinator, (a, b)), rest))
    }
}