Dear camelers,

I am glad to announce the release 1.1 of pacomb.

defined with the `Grammar`

module (or indirectly though a PPX extension) to

the combinators of the `Combinator`

module. The library offers *scanner less*

parsing, but the `Lex`

module provide a notion of *terminals* and *blanks*

that give a simple way to write grammars in two phases, as usual.

The main advantage of PaComb and similar solutions, contrary to ocamlyacc, is

that grammars (compiled or not) are **first class values**. This allows using

the full power of OCaml for manipulating grammars. For example, this is very

useful when working with syntax extension mechanisms.

Importantly, the **performances** of PaComb are very good: it is only two to

five times slower than grammars generated by ocamlyacc, which is a compiler.

Defining languages using the `Grammar`

module directly is cumbersome. For that

reason, PaComb provides a BNF-like PPX syntax extension (enabled using the

`-ppx pacomb.ppx`

compilation flag).

Pacomb also support: self extensible grammars, ambiguous grammars (with merge),

late rejection of rule via raising exception from action code, priority and others.

Documentation is here https://raffalli.eu/pacomb/

github: GitHub - craff/pacomb: A parsing library that compiles grammars to combinators using elimination of left recursion

and it is available via `opam install pacomb`

As teaser, the usual calculator example:

```
(* The three levels of priorities *)
type p = Atom | Prod | Sum
let%parser rec
(* This includes each priority level in the next one *)
expr p = Atom < Prod < Sum
(* all other rule are selected by their priority level *)
; (p=Atom) (x::FLOAT) => x
; (p=Atom) '(' (e::expr Sum) ')' => e
; (p=Prod) (x::expr Prod) '*' (y::expr Atom) => x*.y
; (p=Prod) (x::expr Prod) '/' (y::expr Atom) => x/.y
; (p=Sum ) (x::expr Sum ) '+' (y::expr Prod) => x+.y
; (p=Sum ) (x::expr Sum ) '-' (y::expr Prod) => x-.y
```