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::{Parser, EasyParser, prim, prim::{oneof, char}, message};
// It reads a number of letters (numbers) from 0 to 9,
let num = oneof('0'..='9').many::()
// Interpreted as a number, errors are reported as a message.
.andthen(|str| str.parse::().maperr(message));
// Multiply by something separated by '' and
let prod = num.sep_fold1(char(''), |a,,b| a * b);
// Then add the '+' separator to it.
let sum = prod.sepfold1(char('+'), |a,,b| a + b);
// Can parse simple addition and multiplication expressions.
asserteq!(sum.parse_ok("1+2*3+4"), Some(11));
```
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::*;
[derive(Debug, PartialEq, Eq)]
enum SExp {
Term(String),
List(Vec),
}
fn sexplike>() -> impl EasyParser {
// The parser is to prevent recursion of existential types (removing it will crash the current compiler).
parser(|k| {
let term = satisfy(|c: &char| !char::isspace(c) && c != &'(' && c != &')').many1();
k.then(term.map(SExp::Term).or(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::;
use chasa::char::;
[derive(Debug,PartialEq)]
enum JSON {
Object(Vec<(String, JSON)>),
Array(Vec),
String(String),
Number(f64),
True,
False,
Null,
}
fn jsonparser>() -> impl EasyParser {
any.case(|c, k| match c {
'{' => k
.then(
char('"')
.right(stringchar.manywith(|iter| iter.mapwhile(|x| x).collect()))
.between(whitespace, whitespace)
.bind(|key| char(':').right(jsonparser).maponce(move |value| (key, value)))
.sep(char(',')),
).left(char('}'))
.map(JSON::Object),
'[' => k.then(jsonparser.sep(char(','))).left(char(']')).map(JSON::Array),
'"' => k.then(stringchar.manywith(|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(error::unexpect(c)),
})
.between(whitespace, whitespace)
}
fn whitespace>() -> impl EasyParserof("\t\r\n ").skipmany()
}
fn stringchar>() -> impl EasyParser> {
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| {
char::fromu32(u32::fromstrradix(&str, 16).maperr(message)?)
.ok_or(unexpect("invalid unicode char"))
})
)
.map(Some),
c => k.fail(unexpect(c)),
}
})),
'"' => k.to(None),
c => k.to(Some(c)),
})
}
fn numparser>(c: char) -> impl EasyParser {
let digit = satisfy(|c| ('0'..='9').contains(c));
extendwithstr(c.tostring(),
parseronce(move |k| match c {
'0' => k.done(),
c @ '1'..='9' => k.then(digit.skipmany()),
c => k.fail(unexpect(c)),
})
.left(char('.').right(digit.skipmany1()).ornot())
.left(oneof("eE").right(oneof("+-").ornot()).right(digit.skipmany1()).ornot())
).andthenonce(|(,str)| str.parse::().map_err(message))
}
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))]))
]))
);
```