ocaml-re

ocaml-re[1] uses a derivative-style construction to lazily build a DFA. The general idea is to use something similar to Owens et al's DFA construction, but doing it inline with some caching, to compile lazily (and building a thomson-like automaton, for group capture). In practice, it is fairly fast, although not as optimized as the Rust crate. :) Derivatives supports several match semantics very easily (ocaml-re does longest, shortest, greedy, non-greedy, first). It indeed doesn't handle unicode matching though (it's possible, there is a prototype implem, but nobody took the time to push it through). Note that it's not difficult to (lazily or not) build a NFA using derivatives as well (with Antimirov's construction). [1]: https://github.com/ocaml/ocaml-re/

Here is (I think) the example regex ported to OCaml's Re library [1] let my_regex = let open Re in seq [ bos; opt (str "0x"); repn ( alt [ rg 'A' 'F'; rg 'a' 'f'; rg '0' '9'; ] ) 4 None |> group; eos; ] |> compile I'm familiar with standard (compact) regex syntax, but I've been using the above syntax recently in a couple small places. I'm a bit on the fence as to which is "better". The compact syntax is, of course, more compact. I think it's a very similar comparison between APL (which I've not used) and most other common programming languages. One advantage of the expanded syntax is that it's a bit nicer to incorporate a string variable, e.g. "str some_string" vs. "/#{Regexp.esca

Combinators make for a very nice Regex API. In OCaml, most people use the re[1] library for regular expressions (example[2]). I wrote a library called tyre[3] for typed extraction that follows a similar API. Of course these APIs are much more verbose, but they are also very regular(hah!): Regular operators are normal functions of the language, typechecking and completion works, etc. [1]: https://github.com/ocaml/ocaml-re [2]: https://github.com/ocaml/ocaml-re/blob/master/benchmarks/ben... [3]: https://github.com/Drup/tyre

Hi, author here! I didn't invented the combinators for regex, that was already in ocaml-re (which is used as backend for tyre). The combinator approach has many advantages: - You don't need to remember which regex syntax the library is using. Is it using the emacs one ? The perl one ? The javascript one ? The bash one ?! (shudder) ... - It's "self documenting". Your combinators are just functions, so you just expose them and give them type signatures, and the usual documentation/autocompletion/whatevertooling works. - It composes better. You don't have to mash string together to compose your regex, you can name intermediary regexs with normal variables, etc. - Related to the point above: No string quoting hell. Now, tyre doesn't really improve any of that. If anything, combinators are simpler in ocaml-re[1]. What tyre gives you is the au

The ocaml-re module linked in this article is a neat read. A PCRE parser in ~200 lines: https://github.com/ocaml/ocaml-re/blob/master/lib/re_perl.ml