OCaml Weekly News

The batteries maintainers are pleased to announce the latest minor release of OCaml batteries-included: v3.2.0. Batteries is an open-source, community-maintained, extended standard library for OCaml. The latest version is available in opam.

Thanks to all the contributors for this release!

The change log follows:

The OCaml survey 2020 is now closed. It attracted 745 replies. Everyone should be able to see the summary of results and to download the raw data.

I and a few others will try to write a summary of the replies, especially of the many free-form replies. Everyone is welcome to help sifting through the results! Short comments can be posted in this discussion thread, and longer analyses can be put somewhere else and mentioned here.

We are happy to announce the v1.4.0 release of VSCode OCaml Platform, a Visual Studio Code extension for OCaml. It will be available shortly on the VSCode Marketplace.

This release has the following changes:

• Stop highlighting ocaml unit/array/list literals with bold (#416)
• Add a snippet struct end with prefix struct (#420)
• Only restart the language server for the ocaml.server.restart command (#426)
• Use highlighting for character literals which is consistent with other languages in VS Code (#428)
• Allow using ${workspaceFolder:folder_name} placeholder variables in sandbox configurations for portable settings.json files (#424)
• Fix OCaml problem matcher for warning codes and error messages without characters (#429)

The workspace folder variables in sandbox configurations should make configurations portable, a common request we've had. The extension will now use portable settings by default for local opam switches and esy configurations.

Please feel free to share feedback.

We are pleased to present directories, which is an OCaml library that provides configuration, cache and data paths (and more!) following the suitable conventions on Linux, macOS and Windows. It is inspired by similar libraries for other languages such as directories-jvm.

The following conventions are used:

• XDG Base Directory Specification andxdg-user-dirs on Linux
• Known Folders on Windows
• Standard Directories on macOS

On Linux and macOS it has no dependency. On Windows, it depends only on ctypes.

You will find more information here: https://github.com/OCamlPro/directories

The article you linked is an interesting read. This talk on youtube also explains the difference in an easily digestible way.

Looking at awesome-ocaml there doesn't seem to be a web framework that relies on threading. Is there one out there somewhere?

It's a very far cry from a framework, but my tiny httpd relies on threads and works pretty well for http 1.1.

News, now that M1 is out?

OCaml 4.12 will have full native code macOS/ARM support. The first alpha is due out any day now, and the ecosystem tools will be ready on the day of its release as well, thanks to the OCaml readiness team's efforts

@Blaisorblade currently with my backport to OCaml 4.10 everything is working, a couple of months ago I did bootstrap opam using it.

This one,

https://github.com/EduardoRFS/ocaml/tree/4.10+ios+esy

Stephen Diehl has started a series of blog posts about module systems using OCaml as an example. This provides a nice introduction to the finer points.

The OCaml module system let create a very modular program with quite unlimited complexly nested sig and struct, while avoiding redundancy. But the resulting documentation reflects exactly that, which makes it hard to read, resulting in jumping from one sig (or struct) to another. It may give headache and especially provoke mistakes when writing an expression with illegal type.

What is the straightest manner to get the resulting signature and structure of an OCaml program:

• in its generated documentation
• from the toplevel (it seems roughly to work with #show_module module-path but it sometimes has weird behavior/result)

The error messages are also more complex, revealing the modular structure. It can even be harder to understand when polymorphic variants are used! Is there a way to limit that burden? One simplistic idea would be to program in a modular way, then to "flatten" the whole program in order to let him expose the resulting sig/struct. Is that idea sensible, and how to simply do that?

If you are interested in generating the documentation of such a structure - this is not an easy problem and was the topic of a talk at this year's OCaml Workshop: The final pieces of the OCaml documentation puzzle

Rendering OCaml document is widely known as a very difficult task: The ever-evolving OCaml module system is extremely rich and can include complex set of inter-dependencies that are both difficult to compute and to render in a concise document. Its tasks are even harder than the typechecker as it also needs to keep track of documentation comments precisely and efficiently. As an example, signatures such as include F(X).T and destructive substitutions were never handled properly by any documentation generator.

It is my pleasure to announce the 0.4 release of ocaml-r, a library providing bindings to the R statistical environment interpreter and a few of its standard libraries.

Documentation: http://pveber.github.io/ocaml-r/index.html
Repository: https://github.com/pveber/ocaml-r

This new release brings a big API change, where the bindings are exposed through modules and abstract types instead of types parameterized by object types. The new style is similar in spirit to what's offered in Lexify's gen_js_api or Daniel Bünzli's Brr. The result is hopefully a lot easier to read and use, and incidentally provides a condensed (although incomplete) specification of R's type system.

Finally the documentation, while it's far from being exhaustive, has improved a bit. On this topic, I'd like to address a warm and loud thank you to all the good people involved in odoc: you're changing people's life for the better ;)

Greetings! I'm a new OCaml user. The intent of this post is simply to share my experience thus far in OCaml and hopefully generate some casual conversation about how other community users think about & use OCaml. What do I hope to get from this post? Critiques, affirmation, tips, whatever. I learned OCaml alone, in a bubble, during pandemic lockdown. Was my experience the classic OCaml learning experience, or was it unique in some way? I'm hoping to garner feedback from other community members. Talk at me! :)

Hi, thanks for this write-up, very interesting and super valuable to hear what new users are going through. FWIW, I think you made the right call going with TypeScript; when learning something new, it's better to focus on one thing at a time. Btw, opam does support the .nvmrc style, see http://opam.ocaml.org/blog/opam-local-switches/

Nice thoughts. I think I will do a library for string interpolation - it should just be a simple ppx. You can already check out this project : https://github.com/EmileTrotignon/embedded_ocaml_templates, that attempts to be EJS for OCaml (not every feature is here though), and provide the following syntax:

let name = "John"
let john = [%eml "Name : <%-name%>"]

However I the ${...} syntax in a package that would not allow control structures, just interpolation, would definitely be useful. Maybe it even already exists, I will check before I try and implement it ^^

Edit : it does exists : https://github.com/bloomberg/ppx_string_interpolation

Thanks for the incredibly well written and useful write up, especially describing the things you like, think are okay and weren't so great.

I can't speak about how to resolve all of your pain-points (e.g. no integrated debugger) but what I can say is that:

guided tutorial on how to start doing productive things™

is actively being worked on, which includes more information (amongst other things) about

dune & opam

The (very WIP) set of "workflows" for getting productive things done in OCaml can be found here and are live here (easier to digest full list here). The goal is to fill these out more but also maintain the continuous integration which helps ensure they are working examples of how to be productive with the OCaml Platform (and friends). As I said, it's early days but I think it is already in a position that at least one user might find something useful in there.

Good luck with the rest of your very cool project!

In case you needed more options, https://github.com/janestreet/ppx_string is another string interpolation ppx. It's part of ppx_jane, so if you're already using that, [%string] is available without any further work.

Hi, I've been working on a decimal package: https://github.com/yawaramin/ocaml-decimal (arbitrary-precision floating-point decimals).

I've published a very early preview on opam: http://opam.ocaml.org/packages/decimal/

You can try it out:

$ opam install decimal
$ utop
#
  module D = Decimal
  let i = D.of_int
  let s = D.of_string;;
#
  #install_printer D.pp;;
#
  D.(s "0.1" + s "0.2");;
- : D.t = 0.3
# (* default precision is 32 *)
  D.(i 1 / i 3);;
- : D.t = 0.33333333333333333333333333333333

The module is basically a port of the Python decimal module, with some simplifications like, I'm ignoring different types of NaN like negative NaN, quiet NaN, signalling NaN, and just treating them all as NaN. Otherwise I aim to have the same functionality.

What I need help with mainly is porting the Python decimal unit tests: https://github.com/python/cpython/tree/23831a7a90956e38b7d70304bb6afe30d37936de/Lib/test/decimaltestdata . They are written in a plain-text DSL consisting of test cases like:

addx6324 add  0.12  0.01    ->  0.13

And I assume they have an interpreter somewhere that parses and runs these tests as standard Python unit tests.

What I would like to do is to port these tests into plain OCaml. The above test case could look like (e.g. Alcotest):

check string "addx6324" "0.13" D.(to_string (s "0.12" + s "0.01"))

The test DSL has a few more features, like comments and setting and checking flags, but not too much more complex. So I would really appreciate some help with porting them. I was thinking good old regular expressions to do the conversions, but I'm open to suggestions.

The set of new features for the future version 4.12.0 of OCaml has been frozen, maybe a little earlier than expected.

In this new version of OCaml, the gap between the mainline and multicore runtime has been considerably narrowed. Moreover, this new version comes with a port to the newly launched macOs/ARM architecture. We are thus planning to have a shorter release cycle this time around to get this new version out the door as soon as sensible — which probably translates to the beginning of January.

I am thus happy to announce the first alpha release for OCaml 4.12.0 .

This alpha version is here to help fellow hackers join us early in our bug hunting and opam ecosystem fixing fun. You can see the progress on this front at:

https://github.com/ocaml/opam-repository/issues/17530

Once the major tools are supported, we will switch to beta releases.

And since changes are more fun when they come in pair, we are also testing a new layout for the opam compiler packages.

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

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

If you want to tweak the configuration of the compiler, the new layout offers much finer-grained options. The new command looks like this:

opam update
opam switch create <switch_name> --packages=ocaml-variants.4.12.0~alpha1+options,<option_list>
--repositories=default,beta=git+https://github.com/ocaml/ocaml-beta-repository.git

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.12.0~alpha1+flambda+nffa
--packages=ocaml-variants.4.12.0~alpha1+options,ocaml-option-flambda,ocaml-option-no-flat-float-array
--repositories=default,beta=git+https://github.com/ocaml/ocaml-beta-repository.git

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

https://github.com/kit-ty-kate/opam-alpha-repository

with

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:

• https://github.com/ocaml/ocaml/archive/4.12.0-alpha1.tar.gz
• https://caml.inria.fr/pub/distrib/ocaml-4.12/ocaml-4.12.0~alpha1.tar.gz

If you find any bugs, please report them here:

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

If you are interested by the ongoing list of new features and fixed bugs, the updated change log for OCaml 4.12.0 is available at:

• https://github.com/ocaml/ocaml/blob/4.12/Changes

The 4.12.0 alpha1 release is out and with it is an experiment for a new layout for the ocaml-variants packages to try to reduce the number of packages needed for each compiler release and also to allow packages to depend on particular OCaml configurations.

I have published today a library I ve done for my personnal usage : messages, which allow to encode and decode json data between ocaml applications. The library as been thought in order to exchange data between javascript and server side with a minimum of code.

The idea is to declare the type of the json content in a shared code, and then let the application generate the appropriate encoding and decoding functions automaticaly. I wanted something simple and easy to maintain (or extend), and opt for a classic libray instead of ppx rewrite. I found nothing with this design and built my own library :)

The code is hosted on github : https://github.com/Chimrod/messages

This is the first time I'm annoncing a library publically I hope you you will find it usefull for you !