OCaml Weekly News

Archive: https://discuss.ocaml.org/t/native-and-js-stubs-with-js-of-ocaml/2164/1

Paul Biggar asked:

Some of the functions and modules I'm using in my native executable, are not able to compile to JS using js_of_ocaml. For example, Nocrypto cannot compile to JS, and some of the Core.Time functions are not in Core_kernel.Time. However, there are straightforward JS equivalents I could use.

How can I write these stubs so that the same library can compile both JS and native? For example, I have a library that could call either Nocrypto.Hash.SHA284.digest or a JS file called crypto.js with sha384_digest, depending on the compilation target. How would I set jbuilder up to compile that?

Related question: if I want a type that is one thing when doing our JS compilation (perhaps a JS object) and another thing (probably a Core.Time.t) for native compilation, how do I do that. I guess I want to create a MyTime.t that abstracts over those two types, but I don't know where to get started with this.

Christophe Riolo suggested:

I do not know if what you want to do can be achieved with js_of_ocaml but you might be interested in checking Bucklescript (https://bucklescript.github.io/) which enables linking to JS functions as exernals. I do not know how it works with jbuilder though, it seems to have its own build system.

As for your second question, no idea, but there is, linked to Bucklescript again, bsb-native that enables compiling to ocaml instead of JS (https://github.com/bsansouci/bsb-native) I'd expect that you can give alternatives depending on the backend.

Thomas Gazagnaire also replied:

There is work-in progress to support that out of the box in jbuilder/dune, it's called Library Variants. The idea is to define a commun signature for various implementations, depending on the backends you want to use. Tip: we are very interested to have this for MirageOS :slight_smile:

That feature is not planned for dune 1.0, but you can already achieve something similar by tweaking a bit your build system: see https://github.com/diml/variants-workaround for a template. The trick is to compile the common mli with -no-keep-locs on 4.06.1 and to choose the right implementation at link time.

Paul Biggar then said:

Thanks, this is super helpful! I haven't quite got the JS side working, but the ocaml side and structure works well.

For anyone else whose doing a similar thing, here's how it played out:

We had a simple layout:

• lib: almost all the code
• main: a few binaries, mostly 6-7 lines, using lib
• test: tested lib code

We now have:

• libtarget: target-specific functions. Has no implementation
• libtarget.ocaml: implementation for libtarget for the backend
• libtarget.js: implementation for libtarget for the frontend
• libbackend: all server code, depends on libtarget and libtarget.ocaml
• libexecution: the code we wanted to share between client and server. Depends on libtarget
• libfrontend: all client code. Depends on libtarget and libtarget.js
• main: makes binaries from libbackend
• js: makes js from libfrontend
• test: tests js code

Quick question: why is --no-keep-locs important?

Thomas Gazagnaire then said:

That's great! We are in the process of chaning some of the mirage libraries to use that scheme too, to have both a portable OCaml and an efficient C implementation for checksums and hashes. We should add a JS backend too at one point too.

Using --keep-locs allows to get better error messages. It adds locations to the cmi files, which make them non relocatable. See https://github.com/ocaml/ocaml/pull/1219 for the rational of turning that on per default and the related discussion.

nick betteridge replied to the original question:

There's also gen_js_api for generating ocaml bindings for javascript

Archive: https://sympa.inria.fr/sympa/arc/caml-list/2018-06/msg00032.html

Gabriel Scherer announced:

The release of OCaml version 4.07.0 is imminent. We have created a release candidate for your testing pleasure. Please download the sources, compile, install, and test your favourite software with it, and let us know whether it works for you.

We want to know about any show-stopping bugs, especially in the compilation and installation phases.

This release candidate is available as an opam switch 4.07.0+rc1, and as source archive at this address: https://caml.inria.fr/pub/distrib/ocaml-4.07/

Happy hacking,

– Gabriel Scherer for the OCaml team.

Some highlights of this release are:

• The way the standard library modules are organized internally has changed (GPR#1010):

  1. the List module (for example) is now named Stdlib__list
  2. a new Stdlib module contains a series of aliases such as module List = Stdlib__list
  3. the Stdlib module is implicitly opened when type-checking OCaml programs (as Pervasives previously was), so that Stdlib.List can be accessed as just List, as before.

  This should be invisible to most users, although it is possible that some tools show the Stdlib. or Stdlib__ prefixes in messages. (You might want to report these situations as usability bugs.) The change prevents standard library modules from conflicting with end-user filenames (please avoid stdlib.ml and the stdlib__ prefix); we may introduce new standard library modules in the future with less fear of breaking user code. In particular, Float (GPR#1638) and Seq (GPR#1002) modules have now been added to the standard library.

• The error messages caused by various typing errors have been improved to be easier to understand, in particular for beginners. (GPR#1505, GPR#1510)

  For example,

  # while 1 do () done;;
          ^
  Error: This expression has type int but an expression was expected of type
         bool
  

  now adds the extra explanation

  because it is in the condition of a while-loop
  

• Effort has been made to reduce the compilation time of flambda programs, and the size of the produced .cmx files when using the -Oclassic optimisation level. (GPR#1401, GPR#1455, GPR#1627, GPR#1665, GPR#1667)

• The HTML manual has benefited from various style improvements and should look visually nicer than previous editions. (GPR#1741, GPR#1757, GPR#1767)

  A preview of this new manual is available at http://caml.inria.fr/pub/docs/manual-ocaml-4.07/ For comparison, the 4.06 manual uses the old style: http://caml.inria.fr/pub/docs/manual-ocaml-4.06/

• Since 4.01, it is possible to select a variant constructor or record field from a sub-module that is not opened in the current scope, if type information is available at the point of use. This now also works for GADT constructors. (GPR#1648)
• The GC should handle the accumulation of custom blocks in the minor heap better; this solves some memory-usage issues observed by code which allocates a lot of small custom blocks, typically small bigarrays (GPR#1476)

The full changelog is included below.

(Changes that can break existing programs are marked with a "*")

Archive: https://sympa.inria.fr/sympa/arc/caml-list/2018-06/msg00033.html

Daniel Bünzli announced:

> P.S. Currently `omod` doesn't work with opam system compilers.

omod 0.0.2 has been released and solves this problem.

See [0] for all the changes. 

Best, 

Daniel

[0]: https://github.com/dbuenzli/omod/blob/master/CHANGES.md#v002-2018-06-19-zagreb

Archive: https://discuss.ocaml.org/t/http2-implementation-in-ocaml/2172/1

Anurag Soni announced:

After the discussion on another thread (https://discuss.ocaml.org/t/advantages-of-ocaml-over-rust/2112/44?u=anuragsoni), I have started some work towards exploring the types needed to start an implementation of HTTP2. This might not be the best code as I'm still making my way through learning OCaml. Feedback and/or contributions are very welcome. For now i'll be reading the HTTP2 specs (https://httpwg.org/specs/rfc7540.html) and looking at some existing implementations. (Rust, Dart and Haskell are a few that have existing implementations)

https://github.com/anuragsoni/h2

Archive: https://discuss.ocaml.org/t/ann-dokeysto-a-simple-key-value-store-in-ocaml/2173/1

UnixJunkie announced:

Dokeysto provides a persistent hash table of string keys to string values. Optionally, if you use the right module (like Dokeysto.Db.RWZ), values will be compressed using LZ4 before being written to disk.

The interface is here: https://github.com/UnixJunkie/dokeysto/blob/master/src/db.mli

An example/test is here: https://github.com/UnixJunkie/dokeysto/blob/master/src/test.ml

UnixJunkie then added:

To install it:

opam update && opam install dokeysto

Archive: https://discuss.ocaml.org/t/cli-prompt-package/2181/1

Nadeem Bitar asked:

Is anyone aware of a package that helps display a multi-select prompt from a CLI app?

Here is a screenshot of an example of what I'm trying to accomplish.

Matthieu Dubuget suggested:

You may have a look at notty.

Not sure that it is what you are looking for…

Hezekiah Carty also suggested:

lambda-term is another option. lambda-term is used by utop. notty probably has a smaller dependency footprint.

Archive: https://discuss.ocaml.org/t/any-intermediate-advanced-ocaml-moocs/2182/1

Phil Tomson asked:

I know there's an introductory OCaml MOOC. I'm wondering if there's a more advanced class that digs deeply into Modules, Functors, GADTs and the like?

Anything already out there or in planning?

Levi Roth suggested:

I don't know if it's a MOOC per se, but @yallop teaches an "Advanced Functional Programming" course at Cambridge that has its materials online: https://www.cl.cam.ac.uk/teaching/1718/L28/materials.html

Marcello Seri also suggested:

That is quite interesting, but a bit hard without the frontal lectures imho. Depending on your experience, you may want to have a look at the types course first: https://www.cl.cam.ac.uk/teaching/1718/Types/

Archive: https://discuss.ocaml.org/t/ann-atd-2-0-0/2193/1

Rudi Grinberg announced:

On behalf of the atd team, I'm pleased to announce the release of atd 2.0. This release is a major version bump because it contains a couple of breaking changes:

• Removal of the tag_field field. E.g. <json tag_field=..>.
• Removal of untyped field.

These features now have superior alternatives:

• An open_enum option to read unknown strings into a catch all variant
• An adapter mechanism to manipulate json on the fly before it is passed on to the atd generated readers/writers.

I'll refer to the manual for more thorough descriptions of the feature:

• https://atd.readthedocs.io/en/latest/atdgen.html?highlight=open_enum#field-open-enum
• https://atd.readthedocs.io/en/latest/atdgen.html?highlight=open_enum#field-adapter-ocaml

The manual is also quite new, and the team is working on polishing the documentation. We are happy to hear your comments.

Gabriel Scherer and the editor compiled this list:

Here is a sneak peek at some potential future features of the Ocaml compiler, discussed by their implementers in these Github Pull Requests.

• Add "finally" function to Pervasives (https://github.com/ocaml/ocaml/pull/1855)

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.