incpa 0.0.3

An INCremental PArser composition crate.
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

/// The non-error outcome of incremental parsing
#[derive(Debug, PartialEq)]
pub enum Outcome<P, O> {
    /// The parser updated its state; a full output has not yet been parsed
    Next(P),

    /// The parser successfully parsed an item
    Parsed(O),
}
use Outcome::*;

/// Extension methods to map outcomes within other structures
pub trait OutcomeExt<P, O> {
    /// The container type produced by mapping the outcome
    type MappedOutcome<P2, O2>;

    /// Map the parser state
    fn map_parser<F, P2>(self, f: F) -> Self::MappedOutcome<P2, O>
    where
        F: FnOnce(P) -> P2;

    /// Map the output
    fn map_output<F, O2>(self, f: F) -> Self::MappedOutcome<P, O2>
    where
        F: FnOnce(O) -> O2;
}

impl<P, O> OutcomeExt<P, O> for Outcome<P, O> {
    type MappedOutcome<P2, O2> = Outcome<P2, O2>;

    /// Map the parser state
    fn map_parser<F, P2>(self, f: F) -> Outcome<P2, O>
    where
        F: FnOnce(P) -> P2,
    {
        match self {
            Next(p) => Next(f(p)),
            Parsed(x) => Parsed(x),
        }
    }

    /// Map the output
    fn map_output<F, O2>(self, f: F) -> Outcome<P, O2>
    where
        F: FnOnce(O) -> O2,
    {
        match self {
            Next(p) => Next(p),
            Parsed(x) => Parsed(f(x)),
        }
    }
}

impl<P, O, E> Outcome<P, Result<O, E>> {
    /// Convert an [Outcome] with a [Result] output to a [Result] containing [Outcome]
    ///
    /// This may be useful after [Outcome::map_output] if mapped to a [Result].
    pub fn transpose_output(self) -> Result<Outcome<P, O>, E> {
        match self {
            Next(s) => Ok(Next(s)),
            Parsed(Ok(x)) => Ok(Parsed(x)),
            Parsed(Err(e)) => Err(e),
        }
    }
}