OCaml Weekly News

Here is a blog post that I wrote recently, about the increase of the size of the OCaml Distribution over the recent years:

https://ocamlpro.com/blog/2023_01_02_ocaml_distribution

Hope it can be interesting to read !

Pyre recently switched our backend build to Ocaml 5.0.0.

It was a smooth switch for the most part. I know a lot of work went into this and we appreciate it!

We did notice one surprising regression - we had to remove a call to Gc.stat that we had for telemetry tracking.

The problem was that when we type-checked our largest Python codebase, that call was taking more than 50 seconds (in 4.14, the same call took well under 1 second).

After asking around we’ve learned that:

• the Gc.stat implementation did change and some regression is expected
• we should have been using Gc.quick_stat anyway, which is a change I’ll make soon

Nonetheless we thought it might be good to report this in case the slowness we experienced comes as a surprise.

Let’s use this thread to track progress of the various projects adopting this Code of Conduct. So far, it has been adopted by the following projects:

• ocaml/ocaml
• ocaml/dune
• ocaml/opam

GitHub has a nice icon to indicate it -

After a long time, Esperanto was upgraded with the last version of Cosmopolitan which includes threads.cmxa now. A PR on lwt (to support Esperanto) is pending but we found an issue with dune when we tried to compile a small program. This paves the way for OCaml 5 but, in the meantime, most OCaml applications can be compiled with this new toolchain (if the C files are not too fancy). A sample application is currently available here: Bob. You can also see the reproducibility of the software here (here is an article for more information).

Here’s the promised update on what kind of feedback we got out of the user survey. I tried to distill as best as I could, there was so much feedback! :)

We have responses from 20 people in total, and a lot of those have volunteered to be interviewed by Claire. So this is excellent! In the interest of getting a good overview of the userbase, Claire will select people and send out invites.

A quick update on recent works of the OCaml Software Foundation. It is a non-profit foundation (earlier thread) that receives funding from our industrial sponsors each year, and tries its best to spend it to support and strengthen the OCaml ecosystem and community.

(Previous update: summer 2022.)

The funding volume we receive each year is around 200K€. (For comparison: this is the yearly cost of one experienced full-time software engineer in many parts of the world.) We do not fund people full-time for long periods. Most actions receive from 3K€ to 20K€. The work to prepare and execute actions is mostly done by the (unpaid) Executivee Committee. It is currently formed by Nicolás Ojeda Bär (’nojb’), Damien Doligez, Xavier Leroy, Kim Nguyễn, Alan Schmitt and myself, with administrative personel provided by INRIA. (Alan Schmitt is a new member this year, he agreed to work as an “interim director” from September to March to reduce my own Foundation workload a bit. Thanks Alan.)

Our current sponsors (thanks!) are ahrefs, Jane Street, Tezos, Bloomberg, Lexifi, SimCorp, MERCE and Tarides. (If your company would like to join as a sponsor, please get in touch. Unfortunately, we still cannot efficiently process small donations, so we are not calling for individual donations.)

Feel free to use this thread for questions/suggestions :-)

Hi all! Recently I’ve been playing with tests, and have fallen in love with dune’s cram tests :heart:

As I wasn’t able to find any support for it elsewhere, I’ve written a small Emacs mode to highlight cram tests to make it a little easier to distinguish between comments, commands and outputs:

https://gist.github.com/Gopiandcode/b17e15b09c28e70aa18453a1658021dc

Here’s what it looks like:

There’s probably some things that I’m not doing properly w.r.t to Emacs conventions, but I’ve found it works well enough for my usecases.

Aside: Cram tests really are awesome! I think they’re the best method of writing tests that I’ve found in OCaml, and I’m only saddened that I didn’t try it earlier! The ease of creating new tests (simply a new file, no boilerplate needed), updating expected outputs (dune runtest --autopromote), enabling a result to be tested (simply make sure it has a conversion to string – no need to hassle around with deriving equality etc.) are leagues above the other approaches I’ve used so far.

My current approach to testing my projects - (so far, mainly SQL-backed applications), is to first write a runner binary that calls the appropriate library functions based on its arguments and prints the result (sometimes I generate this programmatically from the types of my APIs), and then write cram tests to document the different interactions between calls that I expect. Especially when interacting with Lwt, I’ve found my cram tests to be far more readable than the corresponding unit tests that I might write with Alcotest.

Hi! Coming back to OCaml after 7+ years, today I decided to look at the open PRs to see where the language is headed. Maybe someone finds it useful. I’m mostly omitting Stdlib changes. These stood out to me:

1. Bidirectional type checking: more type propagation during inference, improves autocompletion (e.g. for OO code).
2. Monadic syntax for match. Also: Jane Street not using binding operators, but the old PPX ← is it still true? The let syntaxes are not fully made use of.
3. Bigarray: free and overlap.
4. Unwind-protect mechanism Fun.with_resource → in draft.
5. Built-in syntax Promote constructors to functions → contested use of curried functions.
6. Unique types to make more abstract types work well with GADTs
7. Modular explicits, modular implicits without the implicit application part. This has the power of first-class functors, but with much more concise syntax, avoids explicit signatures, and allows local type annotations like let f {module M : S} (x : M.t) = x
8. MetaOCaml: reserve >., syntax for .<e>., .~e, pprintast, support for .<e>., .~e.
9. “Subtyping syntax” for modules enables things like include (M :> S).
10. Half-precision floats in Bigarray.
11. Atomic.modify.
12. ~let.op x = ~ bindings parameterized by the op, complementing the current let+ x = and let* x = binding syntaxes.
13. OCaml memory model documentation.
14. Turn keywords to identifiers (mainly for backward compatibility).
15. Serialize Random.State.t.
16. Built-in syntax Promote fields to functions.

I’m glad to announce the initial release of odep – dependency graphs generator for OCaml modules, libraries and packages.

Some months ago I was frustrated with the lack of such modern tool (list of similar ones I found) and decided to code up one universal tool that covers all the use cases (xkcd reference). After interest from the community, I have now made a proper release of the tool on opam.