Re: [Caml-list] [ANN] Planck: a small monadic parser combinator library for OCaml

[Jun Furuse <jun.furuse@gmail.com>]

Sorry for late reply.

> Have you considered writing a defunctionalized version of the parsing
> library ? There are two different kinds of closure construction in your
> code:
> - the "bind" interface requires to be passed a function, which is generally
> a closure built on the fly
> - the parsing monad itself is a function type (it is a state+error monad, so
> written in state-passing style)
>
> There is not much you can do for the first closure source, if you want to
> keep a monadic interface, but the second cause is inessential. You may
> defunctionalize the state monad by reifying it into an algebraic datatype.
> The monad computation would return a big data structure (instead of a big
> function), and you would then write an interpretation function passing the
> state around, without any closure construction.

Yeah, I had just started some test implementation of this kind, but
removed it from the repo before the release.

I had fixed the 1st of April as the dead line of the personal weekend
project, and it was already in mid May, so I released it. Now I am
working on something different (the port of ocamlspot to 3.13 binannot
branch), and have no personal time work on Planck, but I am always
welcome to hear responses. Thanks!

> Moreover, the heavy use of "bind" (which needs a function/closure as
> parameter) in your parsing code could be avoided. You may use more parsing
> combinators (like <|>) and less binding operators. For example your current
> style is to write (v1 <-- p1; v2 <-- p2; return (p1, p2)), you may as well
> write something like ((v1,v2) <-- p1 <*> p2; return (v1,v2)), with one less
> bind call (the idea is to "currify" successive bindings with product-binding
> combinators). I think you should promote the use of combinators over raw
> "binds".

The preprocessor hack described in my blog post is almost the same
effort, and it improved the performance a lot.

The idea of using <*> is nice for two, but not beautiful enough if I
have to write ((((((v1,v2), v3), v4), v5), v6) <-- p1 <*> p2 <*> p3
<*> ... <*> p6. Any good trick to write (v1, v2, v3, v4, v5, ..., vn)
<-- p1 <*> p2 <*> .. <*> pn ? I am afraid I have to use another CamlP4
trick here...

Jun