A parser combinator with many taking iterator, conditional branching, and method chain.
A parser combinator is a mechanism that allows you to combine small syntactic elements to define a larger syntax, which can then be parse directly.
```rust
use chasa::char::prelude::*;
// It reads a number of letters (numbers) from 0 to 9,
let num = oneof('0'..='9').many1::
// Multiply by something separated by '' and let prod = num.sep_reduce(char(''), |a,,b| a * b); // Then add the '+' separator to it. let sum = prod.sepreduce(char('+'), |a,,b| a + b); // Can parse simple addition and multiplication expressions. asserteq!(sum.parse_ok("101010+999"), Some(1729)); ```
The base is Parsec, but with some Rust essence added. For example, not only do you get Vec with many, but you can also manipulate iterators.
rust
let string = char('"').right(
any.many_with(|iter| iter.take_while(|c| c != &'"').collect())
);
assert_eq!(
string.parse_ok("\"Lorem ipsum\" dolor sit amet,"),
Some("Lorem ipsum".to_string())
)
Like the relationship between Fn and FnOnce, we have Parser and ParserOnce and write a parser to manipulate the iterator.
To define and re-use the syntax recursively, use a function (which implements the [Parser] trait) that returns impl[ParserOnce].
In the following example, EasyParser is a special case alias for ParserOnce.
```rust
use chasa::{char, char::prelude::*};
enum SExp {
Term(String),
List(Vecrun prevents type recursion, but does not Box
let term = satisfy(|c| !char::isspace(c) && c != &'(' && c != &')').many1();
term.map(SExp::Term).or(run(sexplike).sep(ws1).between(char('('), char(')')).map(SExp::List))
}
asserteq!(
sexplike.parseeasy("(defun fact (x) (if (zerop x) 1 (* x (fact (- x 1)))))"),
Ok(SExp::List(vec![
SExp::Term("defun".tostring()),
SExp::Term("fact".tostring()),
SExp::List(vec![SExp::Term("x".tostring())]),
SExp::List(vec![
SExp::Term("if".tostring()),
SExp::List(vec![SExp::Term("zerop".tostring()), SExp::Term("x".tostring())]),
SExp::Term("1".tostring()),
SExp::List(vec![
SExp::Term("*".tostring()),
SExp::Term("x".tostring()),
SExp::List(vec![
SExp::Term("fact".tostring()),
SExp::List(vec![SExp::Term("-".tostring()), SExp::Term("x".tostring()), SExp::Term("1".to_string())]),
]),
]),
]),
])),
);
```
Rust doesn't allow you to branch different functions, which prevents you from writing procedural parsers. This hampers the writing of procedural parsers, which can be replaced by a procedural chain for better visibility.
For example, the JSON parser is procedural, but you can write it in procedural form: ```rust use chasa::char::prelude::*;
enum JSON {
Object(Vec<(String, JSON)>),
Array(Vec
fn jsonparser<'a>() -> impl Pat<&'a str, JSON> {
any.case(|c, k| match c {
'{' => k
.then(
char('"')
.right(stringchar.manywith(|iter| iter.mapwhile(|x| x).collect::
fn whitespace<'a>() -> impl Pat<&'a str, ()> { oneof("\t\r\n ").skipmany() }
fn stringchar<'a>() -> impl Pat<&'a str, Option
fn numparser<'a>(c: char) -> impl ParserOnce<&'a str, f64> {
let digit = oneof('0'..='9');
extendwithstr(c.tostring(), {
skipchain((
parseronce(move |k| match c {
'0' => k.done(),
'1'..='9' => k.then(digit.skipmany()),
c => k.fail(unexpected(token(c))),
}),
char('.').right(digit.skipmany1()).ornot(),
oneof("eE").right(oneof("+-").ornot()).right(digit.skipmany1()).ornot(),
))
})
.andthenonce(|(, str)| str.parse::
asserteq!( jsonparser.parseok("{\"key1\": \"value1\", \"key2\": [ true, \"value3\" ], \"key3\": { \"key4\": 15e1 }}"), Some(JSON::Object(vec![ ("key1".tostring(), JSON::String("value1".tostring())), ("key2".tostring(), JSON::Array(vec![JSON::True, JSON::String("value3".tostring())])), ("key3".tostring(), JSON::Object(vec![("key4".to_string(), JSON::Number(150.0))])) ])) ); ```