OCaml Weekly News

The release of OCaml 4.14.0 is approaching. We have released a second alpha version 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:

https://github.com/ocaml/ocaml/issues

Compared to the last alpha release, we have exceptionally a new feature for writing future-compatible early thread exit in 4.14.0 . The second notable change is a major fix in the typechecker for escaping existential types when using GADTs, that might break existing code that relied on the broken types. However, there are currently no known instance of package broken by this change in the opam repository. The other fixes are more usual and should be fairly safe.

Welcome to the January 2022 Multicore OCaml monthly update! This update along with the previous updates has been compiled by @avsm, @ctk21, @kayceesrk and @shakthimaan.

@xavierleroy clicked "merge" on the upstream Multicore OCaml PR#10831 to upstream OCaml, which simultaneously made for a great start to the new year and prepared us for the hard work ahead to get to a stable release of OCaml 5.00.0! Since the merge, we have continued to work on the release via bug fixes, code improvements, and tooling support directly in the main ocaml repository. Notably, a new draft PR for ARM64 backend support has already been proposed.

OCaml 5.0 trunk also removes a number of deprecated modules, and renames EffectHandlers to Effect for consistency with the rest of the standard library. In the ecosystem, several of the key support libraries like uring, multicore-opam, and domainslib have had updates to work with 5.0.0+trunk. The Eio effects-based direct-style parallel IO for OCaml has had significant enhancements, and now also builds with OCaml 5.00.0+trunk. The Sandmark benchmarking suite now provides a 5.00.0+stable and 5.00.0+trunk OCaml variants to build the benchmarks for trunk.

After a meeting last week, the core compiler team has agreed on a short-list of blocking issues for the OCaml 5.0 at https://github.com/ocaml/ocaml/issues/11013 .

It's my pleasure to announce the release 1.1.0 of cmdliner. Cmdliner allows the declarative definition of command line interfaces in OCaml.

The main points of this release are:

• Support for UTF-8 man pages.
• Support for deprecating commands, arguments and environment variables.
• Arbitrary sub command nesting, each with its own command line syntax and help page.

To bring in the latter but limit cruft and confusion, the API was reorganized around the notion of [command]. But except for the vagaries of introducing a new module in your scope, no existing program should be broken due to this.

However all programs will be subject to deprecation warnings to migrate to this new API. This being mostly a reorganization rather than a redesign, transitioning to it should be smooth (example for a simple tool), but a few defaults have been changed along the way.

Therefore make sure to read the [release notes][notes] which have all the details and credits the people who gave a hand for this long delayed release; many thanks to them.

Finally a special thanks to @kit-ty-kate for her tremendous help and dedicated boring work in having this merged into the opam package repository.

If you have any question about the new API, use this thread.

• Home page: https://erratique.ch/software/cmdliner
• API docs & manuals: https://erratique.ch/software/cmdliner/doc/ or odig doc cmdliner
• Install: opam install cmdliner

It's my pleasure to announce a new release (#18) of stdcompat, providing an implementation of OCaml 4.14 standard library which is compatible with all versions of OCaml from 3.07.

In particular, the new modules In_channel and Out_channel, and the new functions introduced in Seq are now available whatever the version of OCaml you use.

Available through opam: opam install stdcompat

Development repository: https://github.com/thierry-martinez/stdcompat

Eio provides an effects-based direct-style IO stack for OCaml 5.0. It aims to be easy to use, secure, well documented, and fast. It consists of a generic cross-platform API, plus optimised backends for different platforms.

This 0.1 release is for early adopters to try it out and provide feedback. It works with OCaml 5.00.0+trunk at the time of writing, but as that is a moving target we suggest using 4.12.0+domains for now:

opam switch create 4.12.0+domains
--repositories=multicore=git+https://github.com/ocaml-multicore/multicore-opam.git,default
opam install eio_main

There is a tutorial giving a tour of the main features:

• Concurrent code without a need for monads or special syntax: no more >>=, let%lwt, Lwt_list.iter_s, etc. Just use plain OCaml code (|>, let, List.iter).
• Concurrency primitives (promises, streams, semaphores), as usual.
• Run multiple fibres on a single core, or distribute work across multiple CPUs.
• Replace any OS features (files, networks, clocks, etc) with mocks for testing.
• Structured concurrency, to prevent leaking resources (such as open file descriptors or fibres).
• Automatic handling of cancellation, so that if one part of your program fails then other fibres are cancelled automatically until the exception is handled or the program exits with a stack trace.
• Capability-based security. For example, a Dir.t only grants access within some sub-tree of the filesystem, and prevents escaping it using .. or by following symlinks out of the tree.

Various libraries are in the process of being ported to Eio. Examples include a Gemini client (including ports of angstrom, httpaf, notty and ocaml-tls), and Dream (providing a direct-style API to users while using lwt-eio internally to integrate with existing libraries).

Performance seems good, especially on recent versions of Linux were Eio can take advantage of io_uring. For example, this graph shows how various HTTP servers cope with increasing load:

httpaf_eio is currently at the top (though note that the Rust server, rust_hyper, is not using io_uring, so this is not a completely fair comparison).

Useful resources:

• Eio – the main project
• Lwt_eio – integration with or porting from Lwt
• awesome-multicore-ocaml – list of multicore resources

Feedback, and PRs adding missing features, are welcome!

A huge debate followed this message. Please follow the archive link above if you want to read more.

At Solvuu, we develop software for the life sciences industry. Our projects touch human health in various ways, from pursuing cancer therapies to improving agricultural output. We use OCaml across the full stack: cloud infrastructure management, job scheduling, data management and security, statistical data analysis, clients and servers for many APIs, and web based UIs for data exploration.

We currently have a full-time position open for an OCaml programmer with cloud computing experience. The ideal candidate would have at least 2 years of professional software development experience in OCaml, and 2 years of experience building systems on AWS. Other requirements include exceptionally good written and verbal communication skills, organizational skills, and attention to detail. We insist on clean elegant code and a team-first attitude, and will want to be convinced that you do too. Though not required, the following would all strengthen your application: a PhD in distributed systems or programming languages, experience with IaC technologies like Terraform, or experience in the life science industry.

To apply, please send an email to jobs@solvuu.com expressing your interest, and please attach your CV. This is a full-time position and requires authorization to work in the US. Ideally, you would work from one of our offices in Manhattan or San Francisco (which immerse you in an ecosystem of innovative companies alongside Solvuu), but we welcome remote work from anywhere in the US. Our compensation package includes a competitive salary, equity, and health insurance for you and your family.

If the above sounds exciting, but you are outside the US, available only part-time, or feel you don’t quite meet the requirements, please do still reach out. We are keen to meet anyone passionate about OCaml programming as a career, and we will be happy to explore options for working together. You do not need to know any Biology.

On behalf of the Mirage team, I am delighted to announce the beta release of MirageOS 4.0!

MirageOS is a library operating system that constructs unikernels for secure, high-performance network applications across a variety of hypervisor and embedded platforms. For example, OCaml code can be developed on a standard OS, such as Linux or macOS, and then compiled into a fully standalone, specialised unikernel that runs under a Xen or KVM hypervisor. The MirageOS project also supplies several protocol and storage implementations written in pure OCaml, ranging from TCP/IP to TLS to a full Git-like storage stack.

The beta of the MirageOS 4.00 release contains:

• mirage.4.0.0~beta: the CLI tool;
• ocaml-freestanding.0.7.0: a libc-free OCaml runtime;
• and solo5.0.7.0: a cross-compiler for OCaml.

They are all available in opam by using:

opam install 'mirage>=4.0'

Note: you need to explicitly add the 4.0>=0 version here, otherwise opam will select the latest 3.* stable release. For a good experience, check that at least version 4.0.0~beta3 is installed.

On behalf of our vscode team, I’m excited to announce the long awaited version 1.9.0 of our vscode extension.

This release is rich in new features, but I’d like to highlight one in particular. @arozovyk added a full blown interactive AST explorer for PPX development. So long to flipping back and forth between your project and parsetree.mli during development.

This release also features work from three new contributors: @tatchi, @SaySayo and @arozovyk. I thank them for their work and wish them luck in participating in our cozy open source community.

Happy Hacking.

On behalf of the ocamllsp team, I’m pleased to announce version 1.10.0. The only new feature this release offers is better code folding, but there are some important bug fixes and performance improvements. If you encounter any sluggishness with our server, do not hesitate to report it.

Unless there are serious bugs with this release, this will be the last release for OCaml 4.13.

Happy Hacking.

I wanted to announce the first release of the SiFun project!!!

SiFun is a Simple Functional language created by me as the part of my bachelor's dissertation project. The aim of the project is to create a language that supports higher rank polymorphism (unlike OCaml). So far I created two type systems: Hindley–Milner (which is just a simply typed lambda calculus) and System F (which extends HM system and adds features of type abstractions, typed functions and visible type application).

The next part of the project is currently under development - the Bidirectional Type checking, which will fully support higher rank types, as expected.

Feel free to play around with this simple interpreter (I've added support of interactive REPL command line) and raise any issues you find. :blush:

Link to the GitHub repo: https://github.com/kkd26/SiFun

I'm pleased to announce the first release of prbnmcn-dagger (dagger for short).

dagger is a library/edsl for probabilistic programming. Models are written in a monadic language and inference is performed by backends implementing that monadic interface. In this first release, dagger only implements variants of lightweight Metropolis-Hastings.

You can have a look at the README or jump straight at the documentation

Some notable sources of inspiration for this project are:

• Functional programming for modular Bayesian inference
• Hakaru10

I am very glad to announce the first release of ppx_pyformat!

ppx_pyformat is a ppxlib based rewriter inspired by Python string format() . This rewriter allows the user to do complex variable substitutions and value formatting. The format string syntax of ppx_pyformat is closely modeled after that of Python3.10 (with several enhancements). Most Python format strings should be compatible with ppx_pyformat with minor modifications. And the behavior is also very similar. So Python users should be able to quickly pick up this rewriter.

The rewriter takes a required format string following with optional input arguments. The rewriter will parse the format string, substitute/format the replacement fields and finally return everything as a single string.

For more details about this package, please check the README.md.

Here is some sample code

let _ =
  let hello = "Hello" in
  let world = "world" in
  print_endline [%pyformat "{hello} {world}!"]
(*Hello world!*)

let _ =
  print_endline [%pyformat "pi = {Float.pi:.10f}"]
(*pi = 3.141592653*)

let _ =
  let string_of_tuple (a, b) = "("^a^", "^b^")" in
  print_endline [%pyformat "{!string_of_tuple}"; ("foo", "bar")]
(*(foo, bar)*)

let _ =
  print_endline [%pyformat "the answer to life the universe and everything {0:#020_b}"; 42]
(*the answer to life the universe and everything 0b000_0000_0010_1010*)

Hope this plugin can make logging/debugging in OCaml a bit easier. Feel free to leave any feedback! Thanks.

I am pleased to announce the release of Caqti 1.7.0. Caqti is a generic RDBMS client interface supporting MariaDB, PostgreSQL, and Sqlite3 via the corresponding bindings to the client libraries. The full release notes follows.

It's my pleasure to announce the release 1.0.0 of Gg. Gg provides basic types for computer graphics.

The big change of this release is that the Gg.Float module now includes the Stdlib.Float module introduced in OCaml 4.07. This means that the additions made there are also in the Float module in your scope when you open Gg.

Ideally the Gg.Float module would have disappeared but some values remain in it that are not in Stdlib.Float and which are unlikely to be ever added there.

Be very careful on upgrading since this entails subtle changes to three of the existing functions of Gg.Float. Besides the semantics of Gg.Float.pp and Box{1,2,4}.inset was also changed.

All of this is carefully documented in the release notes.

Sorry for these silent semantic changes.

• Home page: https://erratique.ch/software/gg
• API docs & manuals: https://erratique.ch/software/gg/doc/
• Install: opam install gg