anpa 0.11.0

A generic monadic parser combinator library inspired by Haskell's 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

use core::{ops::{Add, AddAssign, Sub, SubAssign}, slice::Iter, str::Chars};

/// Share trait for "slicable" inputs. Anpa can be used to parse types implementing this trait.
pub trait SliceLike: Copy {
    type Idx: Add<Output = Self::Idx> + AddAssign + Sub<Output = Self::Idx> +
                           SubAssign + PartialEq + PartialOrd + From<bool> + Default + Copy;
    type RefItem: Copy;
    type Iter: Iterator<Item = Self::RefItem>;

    /// Get an index from `usize`.
    fn slice_idx_from_offset(self, idx: usize) -> Self::Idx;

    /// Get an iterator for this input.
    fn slice_iter(self) -> Self::Iter;

    /// Get the first item of this input along with the rest, if it satisfies the provided predicate.
    fn slice_first_if(self, pred: impl FnOnce(Self::RefItem) -> bool + Copy) -> Option<(Self::RefItem, Self)>;

    /// Get the (optional) index of the first item that matches `pred`.
    fn slice_find_pred(self, pred: impl FnMut(Self::RefItem) -> bool + Copy) -> Option<Self::Idx>;

    /// Get the current length of the input.
    fn slice_len(self) -> Self::Idx;

    /// Create a slice from index `from` until the end of the input.
    fn slice_from(self, from: Self::Idx) -> Self;

    /// Create a slice from the start of the input until `to` (exclusive).
    fn slice_to(self, to: Self::Idx) -> Self;

    /// Split the input at index `at`.
    fn slice_split_at(self, at: Self::Idx) -> (Self, Self);

    /// Check if the input is empty.
    fn slice_is_empty(&self) -> bool;
}

impl<'a, A> SliceLike for &'a [A] {
    type Idx = usize;
    type RefItem = &'a A;
    type Iter = Iter<'a, A>;

    #[inline(always)]
    fn slice_idx_from_offset(self, idx: usize) -> Self::Idx {
        idx
    }

    fn slice_iter(self) -> Self::Iter {
        self.iter()
    }

    fn slice_first_if(self, pred: impl FnOnce(Self::RefItem) -> bool + Copy) -> Option<(Self::RefItem, Self)> {
        self.split_first().filter(|x| pred(x.0))
    }

    fn slice_find_pred(self, pred: impl FnMut(Self::RefItem) -> bool + Copy) -> Option<usize> {
        self.iter().position(pred)
    }

    fn slice_len(self) -> usize {
        self.len()
    }

    fn slice_from(self, from: usize) -> Self {
        &self[from..]
    }

    fn slice_to(self, to: usize) -> Self {
        &self[..to]
    }

    fn slice_split_at(self, at: usize) -> (Self, Self) {
        self.split_at(at)
    }

    fn slice_is_empty(&self) -> bool {
        self.is_empty()
    }
}

impl<'a> SliceLike for &'a str {
    type Idx = usize;
    type RefItem = char;
    type Iter = Chars<'a>;

    #[inline(always)]
    fn slice_idx_from_offset(self, idx: usize) -> Self::Idx {
        idx
    }

    fn slice_iter(self) -> Self::Iter {
        self.chars()
    }

    fn slice_first_if(self, pred: impl FnOnce(Self::RefItem) -> bool + Copy) -> Option<(Self::RefItem, Self)> {
        let mut chars = self.chars();
        let first = chars.next()?;
        pred(first).then_some((first, chars.as_str()))
    }

    fn slice_find_pred(self, pred: impl FnMut(Self::RefItem) -> bool + Copy) -> Option<usize> {
        self.find(pred)
    }

    fn slice_len(self) -> usize {
        self.len()
    }

    fn slice_from(self, from: usize) -> Self {
        &self[from..]
    }

    fn slice_to(self, to: usize) -> Self {
        &self[..to]
    }

    fn slice_split_at(self, at: usize) -> (Self, Self) {
        self.split_at(at)
    }

    fn slice_is_empty(&self) -> bool {
        self.is_empty()
    }
}