chasa
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::()
// Interpreted as a number, errors are reported as a message.
.andthen(|str| str.parse::().maperr(fromerror));
// 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::*};
[derive(Debug, PartialEq, Eq)]
enum SExp {
Term(String),
List(Vec),
}
fn sexplike() -> impl Pat {
// run 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::*;
[derive(Debug, PartialEq)]
enum JSON {
Object(Vec<(String, JSON)>),
Array(Vec),
String(String),
Number(f64),
True,
False,
Null,
}
fn jsonparser() -> impl Pat {
any.case(|c, k| match c {
'{' => k
.then(
char('"')
.right(stringchar.manymap(|iter| iter.mapwhile(|x| x).collect::()))
.between(whitespace, whitespace)
.bind(|key| char(':').right(run(jsonparser)).maponce(move |value: JSON| (key, value)))
.sep(char(',')),
)
.left(char('}'))
.map(JSON::Object),
'[' => k.then(jsonparser.sep(char(','))).left(char(']')).map(JSON::Array),
'"' => k.then(stringchar.manymap(|iter| iter.mapwhile(|x| x).collect())).map(JSON::String),
'-' => k.then(any).bind(numparser).map(|n| JSON::Number(-n)),
c @ '0'..='9' => k.then(numparser(c)).map(JSON::Number),
't' => k.then(str("rue").to(JSON::True)),
'f' => k.then(str("alse").to(JSON::False)),
'n' => k.then(str("ull").to(JSON::Null)),
c => k.fail(unexpected(token(c))),
})
.between(whitespace, whitespace)
}
fn whitespace() -> impl Patof("\t\r\n ").skipmany()
}
fn stringchar() -> impl Pat> {
any.case(|c, k| match c {
'\' => k.then(any.case(|c, k| {
match c {
'"' => k.to(Some('\"')),
'\' => k.to(Some('\')),
'/' => k.to(Some('/')),
'b' => k.to(Some('\x08')),
'f' => k.to(Some('\x0C')),
'n' => k.to(Some('\n')),
'r' => k.to(Some('\r')),
't' => k.to(Some('\t')),
'u' => k
.then(
satisfy(|c| matches!(c, '0'..='9' | 'a'..='f' | 'A'..='F'))
.repeat::(4)
.andthen(|str| u32::fromstrradix(&str, 16).maperr(fromerror))
.andthen(|int| char::fromu32(int).ok_or(unexpected(format("invalid unicode char")))),
)
.map(Some),
c => k.fail(unexpected(token(c))),
}
})),
'"' => k.to(None),
c => k.to(Some(c)),
})
}
fn numparser(c: char) -> impl Pat {
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::().maperr(fromerror))
}
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))]))
]))
);
```