OCaml Weekly News

It's my pleasure to announce the first release of ttweetnacl.

Ttweetnacl provides thin bindings to the TweetNaCl cryptographic library.

Ttweetnacl has no dependencies. The binding code is distributed under the ISC license and the integrated TweetNaCl C code is in the public domain.

The binding has only been lightly used so far. Early adopters should pay special attention (or even better, review the binding code :–)

• Home page: https://erratique.ch/software/ttweetnacl
• Docs: https://erratique.ch/software/ttweetnacl/doc/ (or odig doc ttweetnacl)
• Install: opam install ttweetnacl (once this is merged)

It is my pleasure to announce the release of Dmap.

Dmap is an OCaml library that implements dependent (heterogeneous) immutable maps. The type of keys is indexed by the type of the associated values, so that the maps can contain data whose types may depend on the values of keys. It is adapted from the implementation code for maps that is used by the OCaml standard library.

For instance:

module IntBool = struct
  (* The type for the keys of our maps. The index ['a] denotes the type
     of the values that will be associated to the keys. In the case of the
     [Int] constructor, the map will expect data of type [string]. In the
     case of the [Bool] constructor, the map will expect values of type [char].
  *)
  type 'a t = Int : int -> string t | Bool : bool -> char t

  (* Total order on values of type [_ t]. *)
  let compare (type a1 a2) (v1 : a1 t) (v2 : a2 t) : (a1, a2) cmp =
    match (v1, v2) with
    | Int n1, Int n2 -> if n1 = n2 then Eq else if n1 < n2 then Lt else Gt
    | Bool b1, Bool b2 ->
        if b1 = b2 then Eq else if (not b1) || b2 then Lt else Gt
    | Bool _, Int _ -> Lt
    | Int _, Bool _ -> Gt
end

(* We create a module of maps whose keys have type [IntBool.t] *)
module IntBoolMap = Dmap.Make(IntBool)

(* Definition of a map of type [IntBoolMap.t]. *)
let m = IntBoolMap.(empty |> add (Int 42) "hello" |> add (Bool true) 'A')

(* Some queries on the map [m] *)
let () =
  assert (IntBoolMap.find_opt (Int 42) m = Some "hello");
  assert (IntBoolMap.find_opt (Bool true) m = Some 'A');
  assert (IntBoolMap.find_opt (Bool false) m = None)

This creates a new module IntBoolMap , with a new type IntBoolMap.t of maps from IntBool.t to string or char . As specified by the GADT definition of IntBool.t , the values associated to the keys of the form Int n have type string , and the values associated to the keys of the form Bool b have type char .

You can install Dmap using opam by running opam install dmap

Repository: https://gitlab.inria.fr/bmontagu/dmap

thanks for your release announcement. Did you look into other similar libraries, and have a perspective how they are different from dmap? What comes to my mind are hmap and gmap. Are there other design goals, or different performance tradeoffs/guarantees?

thanks for asking. Here are the differences with hmap and gmap, as far as I understand. Please correct me if I misunderstood some parts.

• hmap only supports keys with no contents. In particular, no total ordering of keys is required. Instead, you can dynamically create new keys, with the type index that you want. It is fully type-safe (no assert false, no Obj.magic, etc). It does not support (but maybe it could) a polymorphic map function (this requires second-order polymorphism). It reuses the standard library's Map implementation by calling Map.Make.
• gmap supports keys with contents, and expects a total ordering function that returns a GADT to witness type equality, exactly as I did in dmap. It supports a polymorphic map function (using second-order polymorphism). It reuses the standard library's Map implementation by calling Map.Make. The implementation records the keys twice: as keys, and as part of the associated data, so that type equality witnesses can be exploited. This results in extra calls to the comparison functions on keys (see the code of get for an example). The extra calls and the double recording of keys might have an impact in terms of cost, that I cannot quantify. I should be measured. The code is almost type-safe: it relies on the invariant the key is the same as the key part that is recorded as data for that that binding. The impossible cases returned by the comparison function are given the assert false behavior.
• dmap also supports a polymorphic map function. It does not store keys twice: as in the standard library's implementation, the keys are stored only once. In comparison to gmap, the comparisons on keys are not done twice. The code is completely type-safe: no assert false is introduced to handle the impossible cases of key comparison. The implementation duplicates the one of the standard library, rather than calling Map.Make. The exported functions and their names are on par with the standard library's Map.

hmap… It does not support (but maybe it could) a polymorphic map function (this requires second-order polymorphism).

That reminds me of a PR I completely forgot about https://github.com/dbuenzli/hmap/pull/6

It is my pleasure to announce the release of the cryptographic library bls12-381.3.0.0 (keep reading for more details about the library content and engineering problems we faced and solved). The changelog from 2.0.1 can be found here. The release is available in the public opam-repository. You can install it using

opam install bls12-381.3.0.0

• Repository: https://gitlab.com/dannywillems/ocaml-bls12-381
• Release: https://gitlab.com/dannywillems/ocaml-bls12-381/-/tags/3.0.0
• License: MIT
• Documentation: https://dannywillems.gitlab.io/ocaml-bls12-381/bls12-381/index.html
• Nomadic Labs website: https://nomadic-labs.com

This is also the first public announcement of a bls12-381 release. And, for this reason, I would like to describe the history of the library and the different challenges we faced as it may interest OCaml engineers, and also describe the content of bls12-381.

Editor’s note: please find the rest of this long message at the archive link above.

After a long time, it's time to officially release setup-ocaml v2! With the official caching functionality introduced from v2, setup is much faster. (Notable thing: we've spent some time with the GitHub team pulling Actions and the ecosystem itself to the level where it "actually works".) We hope you will enjoy this release with a lot of other functionalities that we really need to do real development, such as support for semver-style versioning (ocaml-compiler: 4.13.x). And please report any bugs you encounter! Thank you!

Editor’s note: the full changelog is available at the archive link above.

My name is Jakub and I am a CS student. I would like to share with you a Hardcaml project that I have been working for the past few months, which is a network load balancer. It has no practical usage, but I decided to publish it because of (hopefully) educational value.

Link to the project: https://github.com/xThaid/fpga-lb

When I was learning Hardcaml, the biggest barrier for me was the lack of existing projects. It would be extremely useful to take a look at such a project to get to know some techniques, tricks, or how a big project should look like in general. Therefore, I post this with hope that somebody will find it useful. Hardcaml seems to be a really interesting alternative to other hardware description languages and I wish it had broader recognition.

Brief documentation of the architecture and more comments about the project are available in the repo.

Please let me know if you have any comments!

Fun read with the rogue-like! - especially concerning your experiments with avoiding the gameloop via effects, as I've been thinking about gameloopy stuff in the context of FRP.

I don't think the structure you propose scales very well concerning the complexity of extending the game semantics over time, which you also stumbled over - but I guess that wasn't the intention.

A problem related to what you mentioned about updating other entities life, and having them update their state before they are done sleeping - is that you would need to update your state after each resume of your continuation based on what other entities communicated via the shared state. So in the end the code doesn't look as elegant, and becomes more errorprone.

If others are interested in the "alternative gameloop" aspects - I implemented a simple browser-game with an Elm-style gameloop using FRP in OCaml some years ago: https://github.com/rand00/flappy/blob/master/src/flap.ml#L29

beNEXT, an Australian-based startup, is hiring for the "Software Engineer".

beNEXT is creating the next generation of Smart Legal Contracts based on the Accord Project.

Our plan is to change the way contracts are negotiated and executed, and relegate paper and dumb PDFs to the recycle bin of history, by turning contracts into discrete pieces of software that execute and interact with the real world!

You can learn more about beNEXT by visiting https://benext.io or the Accord Project by visiting https://accordproject.org

beNEXT is looking for a highly motivated and intelligent individual with solid and demonstrable skills in one or more of the following:

• OCaml;
• Q*cert compiler;
• Coq;

Ideally this person would also have experience with Node.js and/or various Javascript frameworks.

An understanding of the Accord Project (including Ergo, Concerto and Cicero) would be advantageous but not mandatory.

Candidates can be located anywhere in the world, provided they have access to reliable, high-speed internet and are prepared to work hours which overlap with Australian Eastern Time - typically UTC+10:00.

If the successful candidate were lucky enough to live in Melbourne, Australia, then attending the beNEXT office in Collingwood is an option. However, our assumption is that this engineer would work from their home office and/or a local domestic office of their choosing.

We are open to engaging the successful candidate in either a full-time, part-time or freelance role depending on the individual circumstances or preferences.

Alternatively, this could be an internship role for a final year computer science student with the view to becoming a permanent employee upon graduation.

The successful candidate would primarily be working on contributions to the Accord Project, in addition to working on the beNEXT smartLEGAL platform, as necessary.

Interested persons can contact us via email at hello@benext.io or by replying to this message.

It is my pleasure to release the Sexp_decode library.

Sexp_decode is a library of monadic combinators for decoding S-expressions (as defined in the Csexp library) into structured data. S-expressions are a simple serialisation format for data exchange, that is (in particular) used in dune. Decoders are a form of parsers for S-expressions.

Repository: https://gitlab.inria.fr/bmontagu/sexp_decode

Sexp_decode is available on opam. You can install it by typing opam install sexp_decode

We (@rand @reynir @hannes) have several updates in this project:

• binary package repositories (debian, ubuntu, FreeBSD) are now available with monotonic version numbering
• the https://builds.robur.coop website has an updated look and feel, and includes dependency visualizations and "which module uses how much space" visualizations (a treemap, based on @Drup modulectomy)

Instructions on how to get started to setup unikernels at https://robur.coop/Projects/Reproducible_builds

I’m happy to publish the fifth issue of the “OCaml compiler development newsletter”. You can find all issues using the tag compiler-newsletter.

Note: the content of the newsletter is by no means exhaustive, only a few of the compiler maintainers and contributor had the time to write something, which is perfectly fine.

Feel free of course to comment or ask questions!

If you have been working on the OCaml compiler and want to say something, please feel free to post in this thread! If you would like me to get in touch next time I prepare a newsletter issue (some random point in the future), please let me know by Discuss message or by email at (gabriel.scherer at gmail).

I wanted to share a blog post that we wrote a while back at Nomadic Labs. I thought this might be interesting to folks here, particularly the more in-depth discussion on how we use Ctypes to safely interface with the formally verified C code of the HACL* cryptography library in OCaml and on the design of our high-level API.

(this is in french only as the talks will be in french it’s probably not relevant for english speakers)

Le prochain OUPS aura lieu le jeudi 10 mars 2022. Le rendez-vous est fixé à 18h30 en salle 15-16 101 .

Ce meetup aura lieu dans les locaux de l'IRILL au 4 place Jussieu, 75005 Paris en salle 101 . Pour accéder à la salle, il faut aller à la colonne 15 ou 16, monter un étage et accéder au couloir 15-16. Voir les instructions d'accès.

L'inscription est obligatoire pour pouvoir accéder au meetup ! Votre nom complet doit être disponible. Merci de vous inscrire le mercredi 9 mars au plus tard.

Le meetup consistera en deux exposés à la suite de quoi, les traditionnels pot et pizza party ne pouvant avoir lieux à l'IRILL, nous proposerons à ceux qui le souhaitent de se rendre au Baker Street Pub pour prolonger les discussions. Le passe sanitaire sera demandé pour participer à cette partie de l'évènement.

Le programme des exposés de cette édition est donné ci-dessous et nous profitons de l'occasion pour rappeler que nous sommes toujours à la recherche de propositions d'exposés pour les meetups suivants. Si vous souhaitez proposer un exposé, contactez-nous sur le zulip OUPS.

We are happy to announce the 1.10.0 release of VSCode OCaml Platform, a Visual Studio Code extension for OCaml. It is now available on the VSCode Marketplace.

This release adds an offline opam package documentation generation and viewing feature by @tatchi. It is available by clicking the icon of a opam package in the OCaml sidebar.

Please feel free to share feedback.

Here are links from many OCaml blogs aggregated at OCaml Planet.

• Segfault Systems Joins Tarides
• OCaml from the Very Beginning now free in HTML and PDF formats
• Permanent Computer Scientist Position at CEA LIST - LSL
• OCaml Labs Joins Tarides
• How Jane Street Pairs Interns to Projects and Teams During the Software Engineering Internship
• Is every projective setoid isomorphic to a type?
• Two new doctors!
• Magic-trace: Diagnosing tricky performance issues easily with Intel Processor Trace