Boost logo

Boost :

From: Christopher Kormanyos (e_float_at_[hidden])
Date: 2024-02-20 09:01:39

> Review for Zach's parsing library starts> on Feb 19th

Here is my review of the proposed

## What is your evaluation of the design?

The design is clear with good structure.
This makes the proposed Boost.Parser
library easy to use. It is simultaneously
quite powerful. Naming choices are
intuitive, which will help both
beginning as well as intermediate
and advanced clients when using
this library.

## What is your evaluation of the implementation?


A few suggestions for potential
evolution of the library follow

I would like to see some evidence of
Code Coverage in testing. Some newer
Boost libraries are showing improved
quality with Code Coverage reports
and statistics. Although this adds
no real functionality, I think it
helps prove overall quality.

When compiling, I really enjoy using
advanced compiler warnings. Two of
my favorites on GCC are -Wconversion
and -Wsign-conversion. When using these
I found several easy-to-fix warnings
present in the proposed Boost.Parser.

Providing evidence of running modern
syntax checker(s) might improve
confidence in the library and/or
reduce the library's vulnerability.

- What is your evaluation of the documentation?

It's great. The library is deep in scope
and functionality. But I was able to
(with help from the docs) get a small
example up and running quickly.
It is easy to study the docs and theyread crsply and clearly.

- What is your evaluation of the potential
usefulness of the library?

Exceptionally high. Parsing tasks
are uniformly ubiquitous in almost all
programming domains. A strong, intuitive
parser library fills a much needed gap
in the collection. Spirit is great and
hopefully will continue to be maintained.
But I hope to migrate new designs to
the proposed Boost.Parser and I will
recommend to others to do the same.

- Did you try to use the library? With
what compiler? Did you have any problems?

Yes absolutely. At first I tried a simple
command-line interpreter. It worked
immediately and was up and running
within minutes. I then went on to define
a simple grammar with upper-case words(and underscores) and try to parse it.
This also worked perfectly.

I did not have time for it yet,
but I would like to attempt to
make a primitive for parsing
big-integers and big-floats
(in the sense of Boost.Multiprecision).

I tried with MSVC 2019, 2022, GCC 11-13
No issues.

- How much effort did you put into your evaluation?
A glance? A quick reading? In-depth study?

I spent about 2 days, using the code,
then did quite a bit of looking at code
and reading the docs.

- Are you knowledgeable about the problem domain?

Yes. But only in the empirical sense.

I have written many programs and
applications based on and using parsers,
usually parsing self-invented grammars,
protocols, binary streams, lexical
fragments and the like, really a lot
of parser-things. Yet at the same time,
I consider myself to be vastly uninformed
about the formal depths of grammars,
standard parser formats and the like.
So it has been a struggle to move.

This is what makes the proposed
Boost.Parser so great. I can use
the proposed Boost.Parser effectively
to solve problems in my domain(s)
even though my formal parser
knowledge is weak.

This makes the proposed Boost.Parser
a valuable library.

## Do you think the library should be accepted as a Boost library?


Christopher Kormanyos

    On Monday, February 12, 2024 at 05:04:11 PM GMT+1, Marshall Clow via Boost <boost_at_[hidden]> wrote:
 That’s a week from now.


— Marshall

Unsubscribe & other changes:

Boost list run by bdawes at, gregod at, cpdaniel at, john at