pa_rs/
parser.rs

1use std::fmt::Debug;
2
3#[derive(PartialEq, Debug)]
4pub enum Either<T, U> {
5    Left(T),
6    Right(U),
7}
8
9pub struct ParseOk<'a, T> {
10    result: T,
11    input: &'a str,
12}
13
14impl<'a, T> ParseOk<'a, T> {
15    fn new(result: T, input: &'a str) -> Self {
16        ParseOk { result, input }
17    }
18}
19
20pub type ParseResult<'a, T> = Result<ParseOk<'a, T>, String>;
21
22pub trait Parse
23where
24    Self: Sized,
25    Self::Result: PartialEq + Debug,
26{
27    type Result;
28
29    fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result>;
30
31    fn run(&self, input: &str) -> Result<Self::Result, String> {
32        self.parse(input).map(|x| x.result)
33    }
34
35    fn and<U: Parse>(self, other: U) -> And<Self, U> {
36        And(self, other)
37    }
38
39    fn and_ref<'a, U: Parse>(&'a self, other: &'a U) -> AndRef<'a, Self, U> {
40        AndRef(self, other)
41    }
42
43    fn or<U: Parse>(self, other: U) -> Or<Self, U> {
44        Or(self, other)
45    }
46
47    fn or_ref<'a, U: Parse>(&'a self, other: &'a U) -> OrRef<'a, Self, U> {
48        OrRef(self, other)
49    }
50
51    fn map<U, F: Fn(Self::Result) -> U>(self, f: F) -> Map<Self, F, U> {
52        Map(self, f)
53    }
54
55    fn map_ref<'a, U, F: Fn(Self::Result) -> U>(&'a self, f: &'a F) -> MapRef<'a, Self, F, U> {
56        MapRef(self, f)
57    }
58
59    fn zero_or_more(self) -> ZeroOrMoreOf<Self> {
60        ZeroOrMoreOf(self)
61    }
62
63    fn zero_or_more_ref<'a>(&'a self) -> ZeroOrMoreOfRef<'a, Self> {
64        ZeroOrMoreOfRef(self)
65    }
66
67    fn one_or_more(self) -> OneOrMoreOf<Self> {
68        OneOrMoreOf(self)
69    }
70
71    fn one_or_more_ref<'a>(&'a self) -> OneOrMoreOfRef<'a, Self> {
72        OneOrMoreOfRef(self)
73    }
74
75    fn drop<U: Parse>(self, other: U) -> Drop<Self, U> {
76        Drop(self, other)
77    }
78
79    fn drop_ref<'a, U: Parse>(&'a self, other: &'a U) -> DropRef<'a, Self, U> {
80        DropRef(self, other)
81    }
82
83    fn keep<U: Parse>(self, other: U) -> Keep<Self, U> {
84        Keep(self, other)
85    }
86
87    fn keep_ref<'a, U: Parse>(&'a self, other: &'a U) -> KeepRef<'a, Self, U> {
88        KeepRef(self, other)
89    }
90
91    fn sbws(self) -> Sbws<Self> {
92        Sbws(self)
93    }
94
95    fn sbws_ref<'a>(&'a self) -> SbwsRef<'a, Self> {
96        SbwsRef(self)
97    }
98
99    fn sep_by(self, sep: char) -> SepBy<Self> {
100        SepBy(self, sep)
101    }
102
103    fn sep_by_ref<'a>(&'a self, sep: char) -> SepByRef<'a, Self> {
104        SepByRef(self, sep)
105    }
106
107    fn parse_while<F: Fn(&Self::Result) -> bool>(self, f: F) -> ParseWhile<Self, F> {
108        ParseWhile(self, f)
109    }
110
111    fn parse_while_ref<'a, F: Fn(&Self::Result) -> bool>(
112        &'a self,
113        f: &'a F,
114    ) -> ParseWhileRef<'a, Self, F> {
115        ParseWhileRef(self, f)
116    }
117}
118
119pub struct NullParser;
120
121impl Parse for NullParser {
122    type Result = ();
123
124    fn parse<'a>(&self, input: &'a str) -> ParseResult<'a, Self::Result> {
125        Ok(ParseOk::new((), input))
126    }
127}
128
129pub struct CharParser(char);
130
131impl Parse for CharParser {
132    type Result = char;
133
134    fn parse<'a>(&self, input: &'a str) -> ParseResult<'a, Self::Result> {
135        match input.as_bytes().get(0) {
136            Some(x) => {
137                let ch = *x as char;
138                if ch == self.0 {
139                    Ok(ParseOk {
140                        result: ch,
141                        input: &input[1..],
142                    })
143                } else {
144                    Err(format!("Expected {:?} but found {:?}", self.0, ch))
145                }
146            }
147            None => Err(format!("No Characters left to parse")),
148        }
149    }
150}
151
152pub struct AnyCharParser;
153
154impl Parse for AnyCharParser {
155    type Result = char;
156
157    fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result> {
158        match input.as_bytes().get(0) {
159            Some(&ch) => Ok(ParseOk {
160                result: ch as char,
161                input: &input[1..],
162            }),
163            None => Err(format!("No Input left to parse")),
164        }
165    }
166}
167
168pub struct And<T: Parse, U: Parse>(T, U);
169
170impl<T: Parse, U: Parse> Parse for And<T, U> {
171    type Result = (<T as Parse>::Result, <U as Parse>::Result);
172
173    fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result> {
174        AndRef(&self.0, &self.1).parse(input)
175    }
176}
177pub struct AndRef<'a, T: Parse, U: Parse>(&'a T, &'a U);
178
179impl<'a, T: Parse, U: Parse> Parse for AndRef<'a, T, U> {
180    type Result = (<T as Parse>::Result, <U as Parse>::Result);
181
182    fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result> {
183        let ParseOk { result: lhs, input } = self.0.parse(input)?;
184        let ParseOk { result: rhs, input } = self.1.parse(input)?;
185        Ok(ParseOk::new((lhs, rhs), input))
186    }
187}
188
189pub struct Or<T: Parse, U: Parse>(T, U);
190
191impl<T: Parse, U: Parse> Parse for Or<T, U> {
192    type Result = Either<<T as Parse>::Result, <U as Parse>::Result>;
193
194    fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result> {
195        OrRef(&self.0, &self.1).parse(input)
196    }
197}
198
199pub struct OrRef<'a, T: Parse, U: Parse>(&'a T, &'a U);
200
201impl<'a, T: Parse, U: Parse> Parse for OrRef<'a, T, U> {
202    type Result = Either<<T as Parse>::Result, <U as Parse>::Result>;
203
204    fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result> {
205        match self.0.parse(input) {
206            Ok(ParseOk { result, input }) => Ok(ParseOk::new(Either::Left(result), input)),
207            _ => match self.1.parse(input) {
208                Ok(ParseOk { result, input }) => Ok(ParseOk::new(Either::Right(result), input)),
209                Err(err) => Err(err),
210            },
211        }
212    }
213}
214
215pub struct Map<T: Parse, F: Fn(<T as Parse>::Result) -> U, U>(T, F);
216
217impl<T: Parse, U: PartialEq + Debug, F: Fn(<T as Parse>::Result) -> U> Parse for Map<T, F, U> {
218    type Result = U;
219
220    fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result> {
221        MapRef(&self.0, &self.1).parse(input)
222    }
223}
224
225pub struct MapRef<'a, T: Parse, F: Fn(<T as Parse>::Result) -> U, U>(&'a T, &'a F);
226
227impl<'a, T: Parse, U: PartialEq + Debug, F: Fn(<T as Parse>::Result) -> U> Parse
228    for MapRef<'a, T, F, U>
229{
230    type Result = U;
231
232    fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result> {
233        let ParseOk { result, input } = self.0.parse(input)?;
234        Ok(ParseOk::new((self.1)(result), input))
235    }
236}
237
238pub struct AllOf<T: Parse>(Vec<T>);
239
240impl<T: Parse> Parse for AllOf<T> {
241    type Result = Vec<<T as Parse>::Result>;
242
243    fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result> {
244        AllOfRef(&self.0).parse(input)
245    }
246}
247
248pub struct AllOfRef<'a, T: Parse>(&'a Vec<T>);
249
250impl<'a, T: Parse> Parse for AllOfRef<'a, T> {
251    type Result = Vec<<T as Parse>::Result>;
252
253    fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result> {
254        let mut results = ParseOk::new(vec![], input);
255        for parser in self.0.iter() {
256            let ParseOk { result, input } = parser.parse(results.input)?;
257            results.result.push(result);
258            results.input = input;
259        }
260
261        Ok(results)
262    }
263}
264
265pub struct OneOf<T: Parse>(Vec<T>);
266
267impl<T: Parse> Parse for OneOf<T> {
268    type Result = <T as Parse>::Result;
269
270    fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result> {
271        OneOfRef(&self.0).parse(input)
272    }
273}
274pub struct OneOfRef<'a, T: Parse>(&'a Vec<T>);
275
276impl<'a, T: Parse> Parse for OneOfRef<'a, T> {
277    type Result = <T as Parse>::Result;
278
279    fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result> {
280        let mut error = "Nothing to parse".into();
281        for parser in self.0.iter() {
282            match parser.parse(input) {
283                Ok(result) => return Ok(result),
284                Err(err) => error = err,
285            }
286        }
287        Err(error)
288    }
289}
290
291pub struct ZeroOrMoreOf<T: Parse>(T);
292
293impl<T: Parse> Parse for ZeroOrMoreOf<T> {
294    type Result = Vec<<T as Parse>::Result>;
295
296    fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result> {
297        ZeroOrMoreOfRef(&self.0).parse(input)
298    }
299}
300
301pub struct ZeroOrMoreOfRef<'a, T: Parse>(&'a T);
302
303impl<'a, T: Parse> Parse for ZeroOrMoreOfRef<'a, T> {
304    type Result = Vec<<T as Parse>::Result>;
305
306    fn parse<'b>(&self, mut input: &'b str) -> ParseResult<'b, Self::Result> {
307        let mut results = vec![];
308        while let Ok(ParseOk {
309            result,
310            input: input1,
311        }) = self.0.parse(input)
312        {
313            results.push(result);
314            input = input1;
315        }
316
317        Ok(ParseOk::new(results, input))
318    }
319}
320
321pub struct OneOrMoreOf<T: Parse>(T);
322
323impl<T: Parse> Parse for OneOrMoreOf<T> {
324    type Result = Vec<<T as Parse>::Result>;
325
326    fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result> {
327        OneOrMoreOfRef(&self.0).parse(input)
328    }
329}
330
331pub struct OneOrMoreOfRef<'a, T: Parse>(&'a T);
332
333impl<'a, T: Parse> Parse for OneOrMoreOfRef<'a, T> {
334    type Result = Vec<<T as Parse>::Result>;
335
336    fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result> {
337        let ParseOk { result, mut input } = self.0.parse(input)?;
338        let mut results = vec![result];
339
340        while let Ok(ParseOk {
341            result,
342            input: input1,
343        }) = self.0.parse(input)
344        {
345            results.push(result);
346            input = input1;
347        }
348
349        Ok(ParseOk::new(results, input))
350    }
351}
352
353pub struct Drop<T: Parse, U: Parse>(T, U);
354
355impl<T: Parse, U: Parse> Parse for Drop<T, U> {
356    type Result = <U as Parse>::Result;
357
358    fn parse<'a>(&self, input: &'a str) -> ParseResult<'a, Self::Result> {
359        DropRef(&self.0, &self.1).parse(input)
360    }
361}
362
363pub struct DropRef<'a, T: Parse, U: Parse>(&'a T, &'a U);
364
365impl<'a, T: Parse, U: Parse> Parse for DropRef<'a, T, U> {
366    type Result = <U as Parse>::Result;
367
368    fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result> {
369        let ParseOk { input, .. } = self.0.parse(input)?;
370        self.1.parse(input)
371    }
372}
373
374pub struct Keep<T: Parse, U: Parse>(T, U);
375
376impl<T: Parse, U: Parse> Parse for Keep<T, U> {
377    type Result = <T as Parse>::Result;
378
379    fn parse<'a>(&self, input: &'a str) -> ParseResult<'a, Self::Result> {
380        KeepRef(&self.0, &self.1).parse(input)
381    }
382}
383
384pub struct KeepRef<'a, T: Parse, U: Parse>(&'a T, &'a U);
385
386impl<'a, T: Parse, U: Parse> Parse for KeepRef<'a, T, U> {
387    type Result = <T as Parse>::Result;
388
389    fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result> {
390        let ParseOk { result, input } = self.0.parse(input)?;
391        let ParseOk { input, .. } = self.1.parse(input)?;
392        Ok(ParseOk { result, input })
393    }
394}
395
396pub struct WhitespaceParser;
397
398impl Parse for WhitespaceParser {
399    type Result = String;
400
401    fn parse<'a>(&self, mut input: &'a str) -> ParseResult<'a, Self::Result> {
402        let mut ws = String::new();
403        while let Ok(ParseOk {
404            result,
405            input: input1,
406        }) = one_of_p(" \n\t\r".chars().map(|ch| CharParser(ch))).parse(input)
407        {
408            ws.push(result);
409            input = input1;
410        }
411        Ok(ParseOk { result: ws, input })
412    }
413}
414
415pub struct Sbws<T: Parse>(T);
416
417impl<T: Parse> Parse for Sbws<T> {
418    type Result = <T as Parse>::Result;
419
420    fn parse<'a>(&self, input: &'a str) -> ParseResult<'a, Self::Result> {
421        SbwsRef(&self.0).parse(input)
422    }
423}
424
425pub struct SbwsRef<'a, T: Parse>(&'a T);
426
427impl<'a, T: Parse> Parse for SbwsRef<'a, T> {
428    type Result = <T as Parse>::Result;
429
430    fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result> {
431        let ParseOk { input, .. } = WhitespaceParser.parse(input)?;
432        let ParseOk { result, input } = self.0.parse(input)?;
433        let ParseOk { input, .. } = WhitespaceParser.parse(input)?;
434        Ok(ParseOk { result, input })
435    }
436}
437
438pub struct SepBy<T: Parse>(T, char);
439
440impl<T: Parse> Parse for SepBy<T> {
441    type Result = Vec<<T as Parse>::Result>;
442
443    fn parse<'a>(&self, input: &'a str) -> ParseResult<'a, Self::Result> {
444        SepByRef(&self.0, self.1).parse(input)
445    }
446}
447
448pub struct SepByRef<'a, T: Parse>(&'a T, char);
449
450impl<'b, T: Parse> Parse for SepByRef<'b, T> {
451    type Result = Vec<<T as Parse>::Result>;
452
453    fn parse<'a>(&self, input: &'a str) -> ParseResult<'a, Self::Result> {
454        self.0
455            .sbws_ref()
456            .keep_ref(&CharParser(self.1).sbws())
457            .zero_or_more_ref()
458            .and(self.0.sbws_ref())
459            .map(|(mut v, e)| {
460                v.push(e);
461                v
462            })
463            .parse(input)
464    }
465}
466
467pub struct ParseSquareList<T: Parse>(T);
468
469impl<T: Parse> Parse for ParseSquareList<T> {
470    type Result = Vec<<T as Parse>::Result>;
471
472    fn parse<'a>(&self, input: &'a str) -> ParseResult<'a, Self::Result> {
473        ParseSquareListRef(&self.0).parse(input)
474    }
475}
476
477pub struct ParseSquareListRef<'a, T: Parse>(&'a T);
478
479impl<'a, T: Parse> Parse for ParseSquareListRef<'a, T> {
480    type Result = Vec<<T as Parse>::Result>;
481
482    fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result> {
483        CharParser('[')
484            .drop(
485                self.0
486                    .sep_by_ref(',')
487                    .or(NullParser)
488                    .map(|either| match either {
489                        Either::Left(left) => left,
490                        Either::Right(_) => {
491                            vec![]
492                        }
493                    }),
494            )
495            .keep(CharParser(']'))
496            .parse(input)
497    }
498}
499
500pub struct ParseWhile<T: Parse, F: Fn(&'_ <T as Parse>::Result) -> bool>(T, F);
501
502impl<'a, T: Parse, F: Fn(&'_ <T as Parse>::Result) -> bool> Parse for ParseWhile<T, F> {
503    type Result = Vec<<T as Parse>::Result>;
504
505    fn parse<'b>(&self, input: &'b str) -> ParseResult<'b, Self::Result> {
506        ParseWhileRef(&self.0, &self.1).parse(input)
507    }
508}
509
510pub struct ParseWhileRef<'a, T: Parse, F: Fn(&'_ <T as Parse>::Result) -> bool>(&'a T, &'a F);
511
512impl<'a, T: Parse, F: Fn(&'_ <T as Parse>::Result) -> bool> Parse for ParseWhileRef<'a, T, F> {
513    type Result = Vec<<T as Parse>::Result>;
514
515    fn parse<'b>(&self, mut input: &'b str) -> ParseResult<'b, Self::Result> {
516        let mut results = vec![];
517
518        while let Ok(ParseOk {
519            result,
520            input: input1,
521        }) = self.0.parse(input)
522        {
523            let pred = self.1(&result);
524            if pred {
525                results.push(result);
526                input = input1;
527            } else {
528                break;
529            }
530        }
531
532        Ok(ParseOk::new(results, input))
533    }
534}
535
536pub struct StringParser(String);
537
538impl Parse for StringParser {
539    type Result = String;
540
541    fn parse<'b>(&self, mut input: &'b str) -> ParseResult<'b, Self::Result> {
542        for ch in self.0.chars() {
543            let ParseOk { input: input1, .. } = CharParser(ch).parse(input)?;
544            input = input1;
545        }
546
547        Ok(ParseOk::new(self.0.clone(), input))
548    }
549}
550
551pub fn char_p(ch: char) -> CharParser {
552    CharParser(ch)
553}
554
555pub fn any_char_p() -> AnyCharParser {
556    AnyCharParser
557}
558
559pub fn str_p(st: &str) -> StringParser {
560    StringParser(st.to_string())
561}
562
563pub fn one_of_p<I: IntoIterator<Item = T>, T: Parse>(iter: I) -> OneOf<T> {
564    OneOf(iter.into_iter().collect())
565}
566
567pub fn bool_p() -> impl Parse<Result = bool> {
568    one_of_p([str_p("true"), str_p("false")])
569        .map(|x| x.parse::<bool>().expect("Cannot convert to bool"))
570}
571
572pub fn digit() -> impl Parse<Result = char> {
573    one_of_p(('0'..='9').map(|ch| CharParser(ch)))
574}
575
576pub fn uint_p() -> impl Parse<Result = u64> {
577    digit().one_or_more().map(|x| {
578        x.into_iter()
579            .collect::<String>()
580            .parse()
581            .expect("This has to be an int")
582    })
583}
584
585pub fn int_p() -> impl Parse<Result = i64> {
586    CharParser('-').and(uint_p()).or(uint_p()).map(|x| match x {
587        Either::Left((_, x)) => -(x as i64),
588        Either::Right(x) => x as i64,
589    })
590}
591
592pub fn float_p() -> impl Parse<Result = f64> {
593    int_p()
594        .and(CharParser('.'))
595        .and(uint_p())
596        .map(|((l, _), r)| format!("{l}.{r}").parse().expect("Cannot convert to float"))
597        .or(uint_p().and(CharParser('.')).map(|(x, _)| x as f64))
598        .map(|x| match x {
599            Either::Left(l) => l,
600            Either::Right(r) => r,
601        })
602        .or(uint_p())
603        .map(|x| match x {
604            Either::Left(l) => l,
605            Either::Right(r) => r as f64,
606        })
607}
608
609pub fn whitespace() -> WhitespaceParser {
610    WhitespaceParser
611}
612
613pub fn list_square_p<T: Parse>(t: T) -> ParseSquareList<T> {
614    ParseSquareList(t)
615}
616
617pub fn dq_str_p() -> impl Parse<Result = String> {
618    char_p('"')
619        .drop(any_char_p().parse_while(|&x| x != '"'))
620        .keep(char_p('"'))
621        .map(|x| x.into_iter().collect())
622}
623
624pub fn sq_str_p() -> impl Parse<Result = String> {
625    char_p('\'')
626        .drop(any_char_p().parse_while(|&x| x != '\''))
627        .keep(char_p('\''))
628        .map(|x| x.into_iter().collect())
629}
pa_rs/parser.rs

pa_rs/
parser.rs
