Features Download
From: Alan Schmitt <alan.schmitt-o/5/jSaJEHk+NdeTPqioyti2O/JbrIOy <at> public.gmane.org>
Subject: Attn: Development Editor, Latest Caml Weekly News
Newsgroups: gmane.comp.lang.ocaml.weekly-news
Date: Tuesday 13th October 2009 07:49:46 UTC (over 7 years ago)

Here is the latest Caml Weekly News, for the week of October 06 to 13,

1) Core 0.6.0
2) camlp5/revised syntax questions
3) Improving OCaml's choice of type to display
4) Other Caml News

1) Core 0.6.0
Archive: <http://groups.google.com/group/fa.caml/browse_thread/thread/bfe4469e378897dd#>
** Ralph Douglass announced:

We are proud to announce the second major release of Core, Jane Street's
alternative to OCaml's standard library.  This release also includes
Core_extended, which adds new functionality such as subcommand style
line argument handling, a procfs interface, readline support, and more.
Core_extended is used heavily at Jane Street, but not systematically code
reviewed in the same manner as Core.

As was warned in the first release, the interfaces to many modules have
changed, so upgrade with care. Interfaces will continue to change with

Core is intended to be used with OCaml 3.11.1.  It will not compile with

We have tested the code on Linux (Centos 5), but have only limited
with it on other platforms.  It compiles on Mac OS 10.6, but has had almost
testing on that platform, and hasn't been tested at all on anything else.

You can find the library here:


along with three other libraries that you will need to use along with it:
type-conv, sexplib, bin-prot, and fieldslib.  These four libraries provide
macros for generating functions for serializing and deserializing types,
for folding over records.

In addition, Core depends on Pcre and Res.  Core_extended also depends on
You can find them at Markus's website:


If you have any comments or patches, we'd love to hear about it.  Our
blog is a great place for comments:


and patches should be sent to
[email protected]

All of the released libraries are licensed under the
LGPL-plus-linking-exception that is used by the OCaml standard

** Markus Mottl then added:

The new Jane Street Core library is now also available through Godi
and is tested to build on Linux.

2) camlp5/revised syntax questions
Archive: <http://groups.google.com/group/fa.caml/browse_thread/thread/16e3654fbfda9720#>
** Aaron Bohannon asked and blue storm replied:

Disclaimer : I have learned camlp4 from the ocaml distribution >=
3.10, wich is different from camlp5 : take my words with a grain of

Aaron Bohannon wrote:
> >From reading the camlp5 documentation, I've managed to write a syntax
> extension that adds a new expression starting with a distinct keyword,
> and it seems to work fine.  However, if I want to experiment with
> infix notations, things get a little trickier.  I need to specify it's
> precedence and associativity, of course.
> So, there is a list of syntactic structures on this page:
> <http://pauillac.inria.fr/~ddr/camlp5/doc/htmlc/ast_transi.html>
> 1) Where can I find the "level names" for each of these syntactic
> constructs, for use with BEFORE, LIKE, etc?  Is that what the
> "Comment" column is for?

The different "level names" are not absolute among all camlp4 grammars
: they're a property of each grammar rule of each grammar. If you want
to "modify" a specific grammar (that is, EXTEND it), you must check
the different levels available in the definition. See the files
meta/pa_r.ml and etc/pa_o.ml in the camlp5 source tree for the
definition of the revised and classical syntax, respectively. Luckily,
the expr rules (the one defining ocaml expressions, wich you seem
interested in) of both syntax mostly share the same levels (the
revised syntax has an additional "where" level for example, but
they're otherwise mostly the same).

There is no explicitely "precedence" in camlp4 parlance, you must use
the levels instead : each precedence level of infix operators has it
own level, usually named after the most representative infix operator
of the level : ':=', '||', '&&', '<'...

> 2) I am confused by the fact that this is a list is for the revised
> syntax.  I think most people (including me) want to modify the
> original syntax.  e.g., imagine that I want to modify the record
> update operator "<-" in the original syntax---I need to refer to it
> somehow, but it doesn't even appear in the list.

While concrete syntaxes for revised and classical syntax are
different, the abstract syntax tree is the same. Camlp4 quotations
works by replacing (using camlp4) the quotation you wrote by the
concrete ocaml AST representation. A nice side-effet of this is that
you can use quotations "in the revised syntax" (the code inside
quotations use the revised syntax) when writing an extension for the
classical syntax. Eg. if you parse "for i = 0 to 10 step 2 do ...
done" and you want to generate the OCaml AST corresponding to "for i =
0 to 10/2 do let i = i * 2 in ... done", you can write <:expr< for i =
0 to 10 / 2 do { let i = i * 2 in ... } >> , it will generate the
corresponding AST and be printed (after processing the source using
the extenion) in whatever syntax the user of your extension is using
(probably the classical one).

This way (using revised syntax inside the quotation of your
extension), your can stay consistent with the camlp5 documentation
(wich describes the quotation in the revised syntax). camlp4 >= 3.10
also has quotations in the classical syntax, but I wouldn't recommend
using them : revised syntax is a less ambiguous syntax wich makes
those things easier.

In your specific case, you can parse whatever syntax you want using
the "<-" operator, then output the corresponding AST using a quotation
in the revised syntax, that is <:expr< a := b >> (instead of "a <-
b"). For a reference, see the related rules in etc/pa_o.ml :

 | ":=" NONA
   [ e1 = SELF; ":="; e2 = expr LEVEL "expr1" ->
     <:expr< $e1$.val := $e2$ >>
   | e1 = SELF; "<-"; e2 = expr LEVEL "expr1" ->
     <:expr< $e1$ := $e2$ >> ]

** Later on, Aaron Bohannon asked and blue storm replied:

> Thanks for your detailed reply.  I had a suspicion I would have to
> read the source code to get the all of the necessary documentation.

It is actually possible to pretty-print the grammar rules during
camlp* execution. For example, here is the code I gave to the toplevel
(using ocamlfind/findlib) to print the default "expr" grammar and
levels :

 #use "topfind";;
 open Camlp4.PreCast;;
 Gram.Entry.print Format.std_formatter Syntax.expr;;

This is probably camlp4-specific, but the printing routine is
documented for camlp5 (
) so an equivalent code should work. I however prefer to read the
source code, wich is easier to browse and contains more information
(pretty printing shows the parsing rules, but not the parse action).

> However, I'm still missing some basic point here.
> blue storm wrote:
>> The different "level names" are not absolute among all camlp4 grammars
>> : they're a property of each grammar rule of each grammar. If you want
>> to "modify" a specific grammar (that is, EXTEND it), you must check
>> the different levels available in the definition.
> Yes, I understand that.  But how do you specify which grammar your
> file is extending?  My file is structured like this:
> #load "pa_extend.cmo";
> #load "q_MLast.cmo";
> open Pcaml;
>  GLOBAL: expr;
>  ...
> END;
> So where did I specify whether I was extending the original syntax or
> the revised syntax (or some other grammar entirely)?  I suppose I must
> have implicitly chosen the original syntax because my code works fine
> on that.

The syntax extension mechanism is imperative in nature : the EXTEND
statement works on an existing grammar and add/change/delete rules
(camlp5 documentation :
) : more
precisely, the EXTEND syntax is a camlp4 extension itself, wich gets
desugared to a bare ocaml expression wich modifies the given
Grammar.Entry.t values (in an imperative way).

The revised and classical syntax are designed as syntax extensions
(pa_o.ml pa_r.ml) that extend an empty grammar, wich already contains
some (empty) grammar entries. They first clear every entry of that
grammar (probably to make sure it's really empty), then add by
extension every syntaxic construct of the ocaml language. They get
compiled to pa_o.cmo and pa_r.cmo, wich you can pass to camlp4 to
choose one of the two syntax :
 camlp4 pa_o.cmo my_extension.cmo ...

What happens here is that :
 - camlp4 starts with an empty ocaml grammar
 - you link it to pa_o.cmo, wich gets executed and set up the
classical syntax (by mutation of the (empty) grammar entries)
 - you then add your own extension wich makes additional mutations

In essence, the effect of your extension depends on the side effects
that were done before. If pa_o.cmo or pa_r.cmo was passed as a
parameter, you build upon their syntax rules, but it can be the case
that an additional syntax extension was added before yours, and thus
you're actually working upon slightly modified syntax rules.

camlp4o and camlp4r are just packaged versions of camlp4, wich
respectively "pa_o.cmo" and "pa_r.cmo" implicitly linked.

In general, reasonably local syntax extension tends to work on both
the classical and the revised syntax (because their syntax rules are
quite similar). If your extension depends on one of the syntax, you
should specify it. If your extension tries to delete a rule wich was
not present in the syntax you're extending, you will get a runtime
error (for example, trying to delete the "where"-related rule in the
classical syntax).

> 1) In the parsing rule for the simple dot noation...
>      | e1 = SELF; "."; e2 = SELF -> <:expr< $e1$ . $e2$ >> ]
> ...why is the field label an "expr"?  This does not agree with the
> OCaml manual, which has a separate syntactic category for "field"
> (<http://caml.inria.fr/pub/docs/manual-ocaml/expr.html>),
nor with my
> intuition about the meaning of the code.

Is suppose this presentation was chosen to make the grammar rules simpler.

Camlp4 parsers are not tied to the documented ocaml grammar. Camlp4
grammars for ocaml (you can use camlp4 to parse other languages,
without necessarily starting from the OCaml grammar) use a
camlp4-specific ocaml AST with then get translated to the specific AST
the OCaml compiler expects (when no camlp4 preprocessing is needed,
the ocaml compiler use its own yacc parser wich directly produces the
ocaml-compiler AST).
There are actually subtle differences in parsing (for example "let id
x = x in id fun _ -> ()" gets rejected by the non-camlp4 parser but
parses fine under camlp4 and camlp5), and I don't think any of them is
"right" : they are all tied to implementation-specific parsing
strategies (weird recursive descent for camlp{4,5} and yacc), and I'm
not sure even the yacc version rigourously respects the documented BNF

> 2) Furthermore, as one can see from the ":=" entry above, the entire
> left side of a record update is parsed as its own subexpression.  So
> this means, that in the context of a record update, that subexpression
> has to be interpreted as a reference, but in other contexts, the very
> same expression must be interpreted as a value.  I don't necessarily
> care what kind of magic makes this possible on the back end, but I am
> wondering whether this has any implications for modifying the record
> syntax.

I'm not sure what you mean here, but I'm under the impression that
you're confusing the syntaxic representation of the expression and its
runtime/compile-time semantic. Camlp* knows nothing of the meaning of
the code it produces; the output is an AST wich has no idea of what a
"reference" and a "value" means. The semantic of the given code
depends on the deeper passes of the compiler (for example typing),
wich probably have an internal language of their own, and surely make
the difference between lvalue and rvalues.

3) Improving OCaml's choice of type to display
Archive: <http://groups.google.com/group/fa.caml/browse_thread/thread/360508774c821064#>
** Yaron Minsky asked:

Anyone who plays around with the Core library that Jane Street just
can see showcased a rather ugly detail of how Core's design interacts with
OCaml displays types. Witness:

# Int.of_string;;
- : string -> Core.Std.Int.stringable = 
# Float.of_string;;
- : string -> Core_extended.Std.Float.stringable = 

I'd be much happier if this was rendered in the following equally correct
more readable form:

# Int.of_string;;
- : string -> Int.t = 
# Float.of_string;;
- : string -> Float.t = 

Or even:

# Int.of_string;;
- : string -> int = 
# Float.of_string;;
- : string -> float = 

And this isn't just an issue in the top-level. The compiler also displays
types in the same difficult to read form. I'm wondering if anyone has some
thoughts as to what we can do to make the compiler make better choices
There are two issues to overcome:

- Dropping the module name. I'd love to give the compiler the hint that
  Core.Std. could be dropped from the prefix in a context where that module
  open. This is what's done with the pervasives module already, I believe,
  it seems like it should be doable here.

- Choosing shorter names. This one seems harder, but there are various
  different possibilities for what type name to print out, and a reasonable
  heuristic to use might be to pick the shortest one. Part of the reason
  issues come up is our use of standardized interface components (that's
  the "stringable" type name comes from). I suspect this one will be hard
  fix, sadly.

Anyway, we'd be happy with any suggestions on how to improve matters.

** After much discussion, Jun Furuse replied:

I have quickly wrote a small patch against 3.11.1 for this feature, to
see what it would be like.


With this patch, path names are printed without opened modules in the
context. It also tries heuristic data type name simplification: if a
variant/record data type is an alias of another data type whose name
is shorter than the original, the printer uses the latter.

For example:

# open Hashtbl;;
# let tbl = Hashtbl.create 10;;
val tbl : ('_a, '_b) t =       (* not Hashtbl.t, since Hashtbl is
open *)

# type t = int;;
type t = int
# type long_name = int;;
type long_name = int
# (1 : t);;
- : t = 1                     (* t is the shorter than its original type
int *)
# (1 : long_name);;
- : int = 1                   (* int is shorter name for long_name. t
is even shorter but not aliased unfortunatelly. *)

I warn you that the patch is very quickly written and not tested well.

4) Other Caml News
** From the ocamlcore planet blog:

Thanks to Alp Mestan, we now include in the Caml Weekly News the links to
recent posts from the ocamlcore planet blog at <http://planet.ocamlcore.org/>.

ocaml-autoconf 1.1:

OBus 1.0rc1 is out!:

new ocaml-autoconf release: 1.1:

Constructive gem: double exponentials:

Optimizing List.map:

Core 0.6.0 release:

Old cwn

If you happen to miss a CWN, you can send me a message
([email protected]) and I'll
mail it to you, or go take a look at
the archive (<http://alan.petitepomme.net/cwn/>)
or the RSS feed of the
archives (<http://alan.petitepomme.net/cwn/cwn.rss>).
If you also wish
to receive it every week by mail, you may subscribe online at

CD: 3ms