Previous week Up Next week


Here is the latest OCaml Weekly News, for the week of May 20 to 27, 2014.

  1. Arbitrary precision unsigned integers
  2. OCaml release 4.02.0+beta1
  3. ocaml-ctypes 0.3
  4. GADT and local modules
  5. Ocsigen Eliom 4.0
  6. Litiom 3.0
  7. Other OCaml News

Arbitrary precision unsigned integers


Thomas Braibant asked and Xavier Leroy replied:
> I wonder if there is a publicly available library that implements
> arbitrary precision (un)signed integers. I could not find anything
> relevant with Google, nor on Opam.
> By arbitrary, I mean that I want to implement e.g., 43 bits
> unsigned arithmetic, and have the right overflow behaviors. I know
> of zarith which seems to implement arbitrary precision in the
> sense that the precision of the numbers grows as needed.

In a pinch, you can use Zarith and follow each arithmetic operation by
a Z.extract or Z.signed_extract operation to normalize the result to
the desired range (N-bit unsigned or N-bit signed). It's not as fast
as it could be, but should be reasonably efficient.

OCaml release 4.02.0+beta1


Damien Doligez announced:
Dear OCaml users,

The release of OCaml version 4.02.0 will take place around the
beginning of July. We have created a beta version to get your
feedback. Please download the sources, compile, install, and test your
favourite software with it. Then let us know what doesn't work by
posting bugs to the BTS.

This is a major release with several big changes, so it is
particurarly important for us to get feedback from you.

Happy hacking,

-- Damien Doligez for the OCaml team.

sources and documentation of 4.02.0+beta1:

Bug-tracking system (BTS):

OCaml 4.02.0+beta1:

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

Language features:
- Attributes and extension nodes
- Generative functors
- Module aliases
* Alternative syntax for string literals {id|...|id} (can break comments)
- Separation between read-only strings (type string) and read-write byte
  sequences (type bytes). Activated by command-line option -safe-string.
- Exception cases in pattern matching (patch by Jeremy Yallop).
- Extensible open datatypes (patch by Leo White).

Build system for the OCaml distribution:
- Use -bin-annot when building.
- Use GNU make instead of portable makefiles.

Shedding weight:
* Removed Camlp4 from the distribution, now available as third-party software.
* Removed Labltk from the distribution, now available as a third-party library.

Type system:
* Keep typing of pattern cases independent in principal mode
  (i.e. information from previous cases is no longer used when typing
  patterns; cf. 'PR#6235' in testsuite/test/typing-warnings/
- Allow opening a first-class module or applying a generative functor
  in the body of a generative functor. Allow it also in the body of
  an applicative functor if no types are created
* Module aliases are now typed in a specific way, which remembers their
  identity. In particular this changes the signature inferred by
  "module type of"
- PR#6331: Slight change in the criterion to distinguish private
  abbreviations and private row types: create a private abbreviation for
  closed objects and fixed polymorphic variants.
* PR#6333: Compare first class module types structurally rather than
  nominally. Value subtyping allows module subtyping as long as the internal
  representation is unchanged.

- More aggressive constant propagation, including float and
  int32/int64/nativeint arithmetic.  Constant propagation for floats
  can be turned off with option -no-float-const-prop, for codes that
  change FP rounding modes at run-time.
- New back-end optimization pass: common subexpression elimination (CSE).
  (Reuses results of previous computations instead of recomputing them.)
- New back-end optimization pass: dead code elimination.
  (Removes arithmetic and load instructions whose results are unused.)
- PR#6269 Optimization of string matching (patch by Benoit Vaugon
  and Luc Maranget)
- Experimental native code generator for AArch64 (ARM 64 bits)
- Optimization of integer division and modulus by constant divisors
  (feature wish PR#6042)
- Add "-open" command line flag for opening a single module before typing
* "-o" now sets module name to the output file name up to the first "."
  (it also applies when "-o" is not given, i.e. the module name is then
   the input file name up to the first ".")
* PR#5779: better sharing of structured constants
- PR#6182: better message for virtual objects and class types
  (Leo P. White, Stephen Dolan)
- PR#5817: new flag to keep locations in cmi files
- PR#5854: issue warning 3 when referring to a value marked with
  the [@@deprecated] attribute
* PR#6203: Constant exception constructor no longer allocate
- PR#6311: Improve signature mismatch error messages
- PR#6345: Better compilation of optional arguments with default values
- PR#6260: Unnecessary boxing in let (patch by vbrankov)
- PR#6017: a new format implementation based on GADTs
  (initial patch by Benoît Vaugon, review by Gabriel Scherer)

Toplevel interactive system:
- PR#5377: New "#show_*" directives

Runtime system:
- New configure option "-no-naked-pointers" to improve performance by
  avoiding page table tests during block darkening and the marking phase
  of the major GC.  In this mode, all out-of-heap pointers must point at
  things that look like OCaml values: in particular they must have a valid
  header.  The colour of said headers should be black.
- Fixed bug in native code version of [caml_raise_with_string] that could
  potentially lead to heap corruption.
- Blocks initialized by [CAMLlocal*] and [caml_alloc] are now filled with
  [Val_unit] rather than zero.
- Fixed a major performance problem on large heaps (~1GB) by making heap
  increments proportional to heap size by default
- PR#4765: Structural equality should treat exception specifically
- PR#5009: Extending exception tag blocks
- PR#6075: avoid using unsafe C library functions (strcpy, strcat, sprintf)
- An ISO C99-compliant C compiler and standard library is now assumed.
  (Plus special exceptions for MSVC.)  In particular, emulation code for
  64-bit integer arithmetic was removed, the C compiler must support a
  64-bit integer type.

Standard library:
* Add new modules: Bytes and BytesLabels.
- PR#4986: add List.sort_uniq and Set.of_list
- PR#5935: a faster version of "raise" which does not maintain the backtrace
- PR#6146: support "Unix.kill pid Sys.sigkill" under Windows
- PR#6148: speed improvement for Buffer (patch by John Whitington)
- PR#6180: efficient creation of uninitialized float arrays

- PR#6257: handle full doc comments for variant constructors and
           record fields
- PR#6310: fix ocamldoc's subscript/superscript CSS font size
           (patch by Anil Madhavapeddy)
- PR#6273: fix Sys.file_exists on large files (Win32)
           (patch by Christoph Bauer)

Bug fixes:
- PR#4719: Sys.executable_name wrong if executable name contains dots (Windows)
- PR#4855: 'camlp4 -I +dir' accepted, dir is relative to 'camlp4 -where'
- PR#5201: ocamlbuild: add --norc to the bash invocation to help performances
- PR#5598: follow-up fix related to PR#6165
- PR#5820: Fix camlp4 lexer roll back problem
- PR#6062: Fix a regression bug caused by commit 13047
- PR#6109: Typos in ocamlbuild error messages
- PR#6116: more efficient implementation of Digest.to_hex (patch by ygrek)
- PR#6165: Alterations to handling of \013 in source files breaking other tools
- PR#6173: Typing error message is worse that before
- PR#6174: OCaml compiler loops on an example using GADTs (-rectypes case)
- PR#6175: Fix open!
- PR#6183: enhanced documentation for 'Unix.shutdown_connection'
- PR#6184: ocamlbuild: `ocamlfind ocamldep` does not support -predicate
           (report and patch by Jacques-Pascal Deplaix)
- PR#6194: Incorrect unused warning with first-class modules in patterns
- PR#6216: inlining of GADT matches generates invalid assembly
- PR#6233: out-of-bounds exceptions lose their locations on ARM, PowerPC
- PR#6235: Issue with type information flowing through a variant pattern
- PR#6239: sometimes wrong stack alignment when raising exceptions
           in -g mode with backtraces active
- PR#6240: Fail to expand module type abbreviation during substyping
- PR#6241: Assumed inequality between paths involving functor arguments
- PR#6243: Make "ocamlopt -g" more resistant to ill-formed locations
- PR#6262: equality of first-class modules take module aliases into account
- PR#6267: more information printed by "bt" command of ocamldebug
- PR#6275: Soundness bug related to type constraints
- PR#6293: Assert_failure with invalid package type
- PR#6302: bytecode debug information re-read from filesystem every time
  (Jacques-Henri Jourdan)
- PR#6307: Behavior of 'module type of' w.r.t. module aliases
- PR#6332: Unix.open_process fails to pass empty arguments under Windows
- PR#6346: Build failure with latest version of xcode on OSX
- PR#6348: Unification failure for GADT when original definition is hidden
- PR#6352: Automatic removal of optional arguments and sequencing
- PR#6361: Hashtbl.hash not terminating on some lazy values w/ recursive types
- PR#6383: Exception Not_found when using object type in absent module
- PR#6384: Uncaught Not_found exception with a hidden .cmi file
- PR#6385: wrong allocation of large closures by the bytecode interpreter
- PR#6394: Assertion failed in Typecore.expand_path
- PR#6405: unsound interaction of -rectypes and GADTs
- PR#6408: Optional arguments given as ~?arg instead of ?arg in message
- fix -dsource printing of "external _pipe = ..."
  (Gabriel Scherer)
- bound-checking bug in caml_string_{get,set}{16,32,64}
  (Pierre Chambart and Gabriel Scherer, report by Nicolas Trangez)
- sometimes wrong stack alignment at out-of-bounds array access
  (Gabriel Scherer, review by Xavier Leroy, report by Pierre Chambart)

Features wishes:
- PR#4243: make the Makefiles parallelizable
- PR#4323: have "of_string" in Num and Big_int work with binary and
           hex representations (patch by Zoe Paraskevopoulou)
- PR#5547: Enable the "-use-ocamlfind" option by default
- PR#5650: Camlp4FoldGenerator doesn't handle well "abstract" types
- PR#5808: allow simple patterns, not just identifiers, in "let p : t = ..."
- PR#6000: add a warning for non-principal coercions to format
- PR#6054: add support for M.[ foo ], M.[| foo |] etc.
           (patch by Kaustuv Chaudhuri)
- PR#6064: GADT representation for Bigarray.kind + CAML_BA_CHAR runtime kind
- PR#6071: Add a -noinit option to the toplevel (patch by David Sheets)
- PR#6166: document -ocamldoc option of ocamlbuild
- PR#6187: ocamlbuild: warn when using -plugin-tag(s) without
  (patch by Jacques-Pascal Deplaix)
- PR#6246: allow wilcard _ as for-loop index
- PR#6270: remove need for -I directives to ocamldebug in common case
  (patch by Josh Watzman, review by Xavier Clerc and Alain Frisch)
- PR#6358: obey DESTDIR in install targets
  (Gabriel Scherer)
- PR#5899: a programmer-friendly access to backtrace information
  (Jacques-Henri Jourdan and Gabriel Scherer)
- ocamllex: user-definable refill action
  (patch by Frédéric Bour, review by Gabriel Scherer and Luc Maranget)
- shorten syntax for functor signatures: "functor (M1:S1) (M2:S2) .. -> .."
  (patches by Thomas Gazagnaire and Jeremy Yallop, review by Gabriel Scherer)
Kakadu asked and Damien Doligez replied:
> Where should I look for labltk now?

It's on ocamlcore:
Jacques Garrigue then added:
You can now find a beta release of labltk there, in sync with ocaml 4.02

ocaml-ctypes 0.3


Jeremy Yallop announced:
I'm pleased to announce the release of ocaml-ctypes 0.3, which is now
available on OPAM and for download from GitHub:

The ocaml-ctypes library makes it possible to call C functions
directly from OCaml without writing any C code.  For example, you can
bind C's "puts" function by supplying its name and type:

   # let puts = foreign "puts" (string @-> returning int);;
   val puts : string -> int = <fun>

You can then call the function immediately:

   # puts "Hello, world!";;
   Hello, world!
   - : int = 14

This is a simple example, but you can use the library to describe most
standard C types -- scalars, functions, structs, unions, arrays, and
pointers to values and functions -- making it possible to bind and
call almost any C function without leaving OCaml.

The ocaml-ctypes 0.1 release was announced on caml-list last summer:

Since then the library has acquired a number of new features, including

 * Stub generation for functions.

   In addition to the dynamic binding mode illustrated with "puts"
above, ocaml-ctypes now supports generating stub code which can be
statically linked into your program.  The interface for stub
generation is close to the existing interface for dynamic binding, so
it should be easy to adapt existing code that uses ctypes to use stub
generation.  The pull request that introduced stub generation
describes the interface:

   The release notes link to a number of examples:

 * Support for inverse stub generation.

   Stub generation can also operate in reverse, turning OCaml code
into a shared library that can be used from C.  There is an example
available which exposes a simple subset of Xmlm's XML-parsing API to C
(all without actually writing any C, of course):

 * Support for bigarrays.

 * Support for passing OCaml strings directly to C. (Patch by Peter Zotov.)

 * Top-level printing for C types and values: you can now build a
representation of a C type or a value and see its C printed form:

    # void @-> returning (ptr (array 10 (funptr (void @-> returning char))));;
    - : (unit -> (unit -> char) carray ptr) fn = char(*(*(void))[10])(void)

    # struct_value ;;
    - : (s, [ `Struct ]) structured = { i = 10, d = 3.5  }

The release notes for this release and for ocaml-ctypes 0.2 list a
number of other newly-available features.  There is also one
backwards-incompatible change: what was previously the Ctypes.Array
module is now called Ctypes.CArray.

I'm grateful to the following people for contributions to the 0.2 and
0.3 releases:
   Daniel Bünzli
   Ivan Gotovchits
   Rob Hoes
   Anil Madhavapeddy
   Mike McClurg
   Greg Perkins
   David Sheets
   Peter Zotov

GADT and local modules


Thomas Braibant asked:
I would like to find a way to name (or capture) the variables that are
existentially quantified in a GADT constructor, to put them inside a
module and apply a functor on the said module. Attached below is a
mockup of what I would like to have. (I can live without this coding
pattern, but I would like to know whether or not it is possible to
make it work, even if I suspect that the answer is no).


type t = Pack : 'a * 'b list -> t

(* I want to unpack a t, and put its content in a module of signature S *)
module type S = sig
  type a
  type b
  val foo : (a * b) list

(* I want to apply the functor M on my module to produce a result,
whose type does not depend on the types in S.  I am using a functor as
a way to structure the computations that happen inside. I started with
a version without modules, which requires to write quite a few type
annotations... *)
module M (C:S) : sig val result : int end= struct

  include C

 (* Here I want bar to have type (a * b) list. Of course, I could have
bar s a function that takes two type variables as arguments, and a
list, and returns a list of the right type. *)
  let bar = List.rev foo
  let result = List.length bar


(* Here, I do not know of a way to retrieve the type variables
quantified in the GADT constructor Pack, to feed them in C *)
let f (t : t) =
  match t with
  | Pack l -> let module C = .... in M(C)

(* alternative with modules, which is not satisfying. *)

module type S = sig
  val t : t

module M (C:S) : sig val result : int end = struct

  include C

  (* Now, I can unpack the t locally in each function, but I cannot
     open the existential in the whole module, which is painful. *)

Gabriel Scherer suggested:
You will be familiar with the solution from the Coq world.

  match t with
   | Pack l ->
     begin fun (type a') (type b') l ->
       let module C = struct
         type a = a'
         type b = b'
         let foo = l
      end in
      let module R = M(C) in
    end l
Thomas Braibant replied:
Oh my. I would never have thought that I could use commutative cuts in
OCaml. I should have thought about this myself, given the time that I
spent playing with these.

For the interested reader, this solution is also called the convoy
pattern in Coq, and is described here

Ocsigen Eliom 4.0


Vincent Balat announced:
A few weeks after Js_of_ocaml 2, we are happy to announce release 4.0
of Eliom. Eliom is a framework for writing Web sites and client-server
Web applications in OCaml. It can be used to build simple Web sites as
well as complex Web applications. In the latter case, both client and
server parts are written in OCaml, as a single program, with a syntax
to distinguish both parts. Thus, communication between server and
client is very easy.

This release brings the following new features:
* Reactive DOM elements, using Daniel Bünzli's React library.
  Reactive nodes can be created either client- or server-side.
* PUT and DELETE services for RESTful Eliom Applications.
* EXPERIMENTAL: Mobile apps with Eliom. (By making it possible to
  start the application from client-side.)

A lot of efforts have been put in documentation improvements.
The full Changelog is available here:

Migration from 3.0 should be very easy:

If you want to start learning Eliom, the best starting point is the
tutorials on page
even when you are an advanced OCaml programmer. Choose the tutorial
that best fits your needs.

This release is the result of a collaboration with Besport inc.
We send them our warm acknowledgements for their contributions,
especially to Hugo Heuzard.  We also thank Guillem Rieu, from
Domoco, for his contributions.

Eliom is a collaborative work by the Ocsigen team.

Vincent Balat, for the Ocsigen team

Litiom 3.0


Dario Teixeira announced:
I'm happy to announce the release 3.0 of Litiom, a small library
aiming to complement Eliom, the web programming framework part of the
Ocsigen project. Litiom is basically a collection of modules offering
high-level constructs for Web programming.

Along with some minor adjustments so that Litiom works with the newly
release Eliom 4.0, Litiom 3.0 takes advantage of the bump in major
version number to make a long sought reorganisation of the API. Yes,
this means that Litiom 3.0 is not backwards-compatible with Litiom
2.1. On the bright side, porting code using the old Litiom to the new
one is mostly a matter of search & replace, and should not require any
major refactoring.

I've written a blog post detailing some of the changes:

Also, the package is already available in OPAM. Happy hacking!

Other OCaml News

From the ocamlcore planet blog:
Thanks to Alp Mestan, we now include in the OCaml Weekly News the links to the
recent posts from the ocamlcore planet blog at

Ocsigen Eliom 4.0:

Depth first search:

Announcing CCSS 1.5:

Installing OPAM 1.1.1 on a CentOS 6.5:

CCSS 1.5 released:

Making type inference explode:

Old cwn

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.

Alan Schmitt