OCaml Weekly News

Previous Week Up Next Week


Here is the latest OCaml Weekly News, for the week of January 18 to 25, 2022.

Table of Contents

wu-manber-fuzzy-search 0.1.0 (new library)

Ifaz Kabir announced

I'm happy to introduce wu-manber-fuzzy-seach, my library for doing fuzzy searches using the Wu and Manber fuzzy search algorithm.

The novel part of this library particularly, when compared to agrep/ocamlagrep, is that I additionally provide a right-leaning variant of the algorithm. The variant reports better matches and error counts when looking at the first match. Here's an example of the differences.

# open Wu_Manber;;
# StringSearch.(search ~k:2 ~pattern:"brown" ~text:"quick brown fox" |> report);;
- : string = "Pattern matched with 2 errors at character 9 of text"
# StringSearch.(search_right_leaning ~k:2 ~pattern:"brown" ~text:"quick brown fox" |> report);;
- : string = "Pattern matched with 0 errors at character 11 of text"

It's a pure OCaml implementation, using Optint.Int63.t as bit-vectors. I don't current support all the extensions that agrep/ocamlagrep supports, and will definitely not match the performance: OCaml+C vs pure OCaml.

The documentation for the library can be found here.

It's not on opam yet, but there is a PR.

Expect more bitvector, Levenshtein distance, and fuzzy search shenanigans in the near future!


Gerd Stolpmann announced

findlib-1.9.2 is out. The only change is a fix for a build problem regarding the OCaml-5 trunk.

For manual, download, manuals, etc. see here:


An updated OPAM package will follow soon.

Signals and Threads on Memory Management

gasche said

I just had an excellent time listening to the last Signals and Threads podcast episode on Memory Management, with Stephen Dolan (@stedolan) as the guest and Yaron Minsky (@Yaron_Minsky) as the host discussing:

  • memory management in programming languages in general
  • memory management in OCaml
  • ongoing research by Stephen and Leo White (@lpw25) on memory-management and data-representation features for OCaml (unboxed types, local values on the stack).

The link https://signalsandthreads.com/memory-management/ contains both the audio and a full text transcript.

I would warmly recommend giving it a try if you are interested in programming language implementation. There is new stuff to learn for everyone, and I also liked the presentation of the parts I was already familiar with.

Yaron Minsky replied

Thanks for the nice words. Interviewing Dolan was fun and I learned a lot.

Local types are still very new: we're hoping to start rolling it out in a limited way internally in the next few weeks, and I expect we'll learn a lot from that. We plan on discussing it more publicly as well, but that's a bit farther out. In the meantime, the source is all available on Github if anyone wants to poke around.

The approach to stack allocation is different and simpler than the one in Rust, as Dolan explained in the episode. Instead of having implicit, polymorphic lifetime variables, function arguments can be marked as local, which prevents the function in question from stashing a reference to those types. This avoids the need to deal with higher-rank polymorphism, which Rust's lifetime approach requires, and as a result makes inference work nicely.

Another neat trick is that you can create functions that can allocate on the parent stack frame (by dint of not having their own stack frame). This lets you build smart constructors for stack-allocated values.

Local types are apparently an example of modal types, though I don't really know enough type theory to have a deep sense of what that means. But it's a powerful thing, and local types appear to be useful for more than just stack allocation, as we're just starting to discover.

Yaron Minsky then added

And, I suppose as I should always mention: we're looking for people to come and work with Dolan and Leo and the rest of the team on this kind of stuff.

More here:


OCaml 4.14.0, first alpha release

octachron announced

The set of new features for the future version 4.14.0 of OCaml has been (finally) stabilized, three months after the release of OCaml 4.13.1. I am thus happy to announce the first alpha release for OCaml 4.14.0 .

This alpha version is here to help fellow hackers join us early in our bug hunting and opam ecosystem fixing fun (see below for the installation instructions). You can see the progress on this front at https://github.com/ocaml/opam-repository/issues/20501 .

If you find any bugs, please report them here:


Most major OCaml developer tools are already supported with this alpha (from odoc to merlin), thus I expect us to switch to beta releases in the beginning of February. The full release is expected to happen in late February.

This early release will give us time to focus on the release of OCaml 5.0.

If you are interested by the list of new features and the ongoing list of bug fixes, the updated change log for OCaml 4.14.0 is available at:


Happy hacking, Florian Angeletti for the OCaml team.

Installation instructions

The base compiler can be installed as an opam switch with the following commands

opam update
opam switch create 4.14.0~alpha1 --repositories=default,beta=git+https://github.com/ocaml/ocaml-beta-repository.git

With opam 2.1, the previous command line can be simplified to

opam update
opam switch create 4.14.0~alpha1

If you want to tweak the configuration of the compiler, you can switch to the option variant with:

opam update
opam switch create <switch_name> --packages=ocaml-variants.4.14.0~alpha1+options,<option_list>

or with opam 2.1:

opam update
opam switch create <switch_name> ocaml-variants.4.14.0~alpha1+options <option_list>

where <option_list> is a comma separated list of ocaml-option-* packages. For instance, for a flambda and no-flat-float-array switch:

opam switch create 4.14.0~alpha1+flambda+nffa ocaml-variants.4.14.0~alpha1+options ocaml-option-flambda

All available options can be listed with opam search ocaml-option.

If you want to test this version, it is advised to install the alpha opam repository



opam repo add alpha git://github.com/kit-ty-kate/opam-alpha-repository.git

This alpha repository contains various fixes in the process of being upstreamed.

The source code for the alpha is also available at these addresses:

A brief survey for Learn-OCaml Community

Erik Martin-Dorel announced

[This post is just a follow-up of an earlier message on caml-list, intended to reach more learn-ocaml instructors, so you can ignore this one if you already replied!]

The OCaml Software Foundation is developing the teaching platform Learn-OCaml that provides auto-graded exercises for OCaml, and was initially authored by OCamlPro for the OCaml MOOC: https://ocaml-sf.org/learn-ocaml.

The platform is free software and easy to deploy; this is great, but as a result we keep learning of users/deployments that we had no idea of. We would be interested in having a better view of our user-base.

If you use Learn-OCaml as a teacher, could you fill this Evento survey to let us know? (the survey will be closed on 2022-02-07)

→ It contains these questions:

  • Where are you using Learn-OCaml? (in which university (a specific course?), which company, online community or…?)
  • Would you like to see your university/company added in github.com/ocaml-sf/learn-ocaml-places?
  • How many students/learners use your deployment in a year?

And just to recall, a few links:

Blog post: Js_of_ocaml, a bundle size study

Javier Chávarri announced

Hi all, I hope your Monday is going great. :slight_smile:

I wanted to analyze bundle size performance in Js_of_ocaml, so I rewrote an existing ReScript web app to compare both outputs.

Here is the blog post with all the data, conclusions, and takeaways:


It has been a very interesting experiment, that helped me learn more about Js_of_ocaml and the way it generates JavaScript code, and also improve some small things along the way in the libraries I was using for the project.

The conclusions, while maybe already known by others, are also quite exciting to me, as the experiment confirms my suspicion that Js_of_ocaml bundle size scales just fine as applications get more complex, so it is suitable for a quite significant number of real world scenarios.

I hope you find it interesting and exciting as well. Please share any feedback you might have! Or any questions if anything is unclear.

Interesting OCaml Articles


If you happen to miss a CWN, you can send me a message and I'll mail it to you, or go take a look at the archive or the RSS feed of the archives.

If you also wish to receive it every week by mail, you may subscribe online.