Previous week Up Next week


Here is the latest Caml Weekly News, for the week of December 21 to 28, 2010.

  1. new mailing-list software for caml-list
  2. ocamlnet-3.2
  3. F# Compiler & Tools Position
  4. Job offer at LexiFi
  5. Manifest types in module type inclusions
  6. Other Caml News

new mailing-list software for caml-list


Xavier Leroy announced:
Dear subscribers,

Just to let you know that the caml-list mailing list, previously
managed by Mailman running on our development server, was migrated to
the Sympa list manager running on INRIA's dedicated,
professionally-administered mailing-list server.  Thanks are due to
Jean-Paul Chieze who performed the migration with great care.

To review and change your subscription options, please visit:

Messages to the list should be posted to 
caml-list AT,
 as before.
There used to be an alternate address which will cease
to work some time in the future, so please bookmark the address.

Along with the migration, we also got new Web archives for the list
(going back to its inception in the early 1990's):
The new archives don't look quite as good as the old ones, but at
least dates are not mangled.

Enjoy the mailing list and please be forgiving if the migration is a
bit bumpy.



Gerd Stolpmann announced:
A new version of ocamlnet (3.2) is ready for download and installation.
This version adds a number of features:

      * Netfs.stream_fs is the class type for a simple file system. It
        is quite minimalistic, and covers a bit more than can be done
        with the standard library (w/o Unix)
      * Netfs.local_fs is an implementation of stream_fs for accessing
        the local filesystem
      * Http_fs.http_fs is another implementation for accessing
        filesystems via HTTP
      * Shell_fs.shell_fs is another implementation for accessing
        filesystems by executing shell commands
      * There are generic algorithms for iterating and copying files
      * Netglob: is an implementation of globbing (wildcard resolution).
        It can be used for local files, but also for any stream_fs file.
      * Netmulticore is an experimental library for parallelizing code
        by using multiple processes.
      * Netconversion.user_encoding returns the current character
        encoding the user has set in the environment (locale)
      * Netsys_posix: adding the openat family of functions; adding
        fchdir; adding fdopendir

There is also a bugfix: Http_client can again take advantage from
aggressive connection caching.



Examples for Netmulticore:

Please report problems to 
gerd AT

GODI users: ocamlnet-3.2 is only provided for Ocaml 3.12, and in the
ocamlnet3 overlay for Ocaml 3.11.

F# Compiler & Tools Position


Don Syme announced:
(It's been a while since I posted to the Caml list. My warm regards to 
everyone in the community, and best wishes for 2011)

Hi all,

The F# team are looking for a world class developer to join the team in 

We are seeking a talented and highly motivated software engineer with 
experience in compilers, language tools and data programming to help us ship 
the next version of F#. The ideal candidate will have a love for functional 
programming and the F# language, strong .NET programming skills including 
object-oriented techniques, knowledge of network, data and cloud programming, 
and experience of working on compilers. An interest in giving F# talks and 
working with F# users is also a strong plus, as is experience in 
data-oriented work, object/relational mappings, web services and other 
connectivity technologies. 

Above all, we're looking for people who can make significant contributions to 
the F# language implementation & tools, and who can help develop the 
foundations necessary for the application of F# in the professional developer 

An MS or PhD degree in Computer Science or a related technical field is 
considered an advantage. The F# compiler is released as open source via a 
code-drop model on major releases, and experience with both large projects 
and binary/code releases on smaller, agile projects is valuable.

We'd love to hear from you! Please apply via the online forms, and feel free 
to contact myself or Joe Pamer 
(jopamer AT
 for more information.  Details at
 Applications must be submitted via the online forms.

Kind regards & best wishes,

Job Category: Software Engineering: Development 
Location: United States, WA, Redmond 
Job ID: 739350 30512 
Division: Server & Tools Business

Job offer at LexiFi


Alain Frisch announced:
LexiFi is looking to expand its team of OCaml developers.
We have many fun projects; it's a great time to join us!

The official job offer (in French) is available here:

We are based in Paris area (Boulogne-Billancourt). Internships are also

Please send your cover letter and resume to 
careers AT

Manifest types in module type inclusions


Markus Mottl asked and Jacques Garrigue replied:
> please consider the following code:
> -------------------
> module M = struct type t = A | B end
> module X : sig
> (*  type t = M.t = A | B *)
>  include module type of M
> (*  include module type of M with type t = M.t = A | B *)
> end = struct include M end
> let () = assert (M.A = X.A)
> -------------------
> This will fail, because M.A is not of the same type as X.A.  But I
> would really like to make the types equivalent.
> Using the first commented out line instead of the module type
> inclusion will succeed, but then I would not be able to automatically
> include any functions potentially contained in module M.  The last
> commented out line won't work, because one cannot establish a type
> equivalence via a manifest type definition after "with type".  Even
> if, I don't think one could override anything else but an abstract
> type that way, and we are including a sum type here already.
> Does anybody have any suggestions for a workaround?  I suspect this
> may be a missing feature.

Unfortunately there is no easy workaround using 3.12.0.
Intuitively at least the 3rd line should work, but a bug prevents this.

In 3.12.1, you should be able to write either the 3rd, or the
simpler following version:

  include module type of M with type t = M.t

This should solve your problem.

Side note: the choice to make "include M" define "type t = A | B"
rather than "type t = M.t = A | B" was done to allow more implementations
(any module defining the same operations as M is allowed, rather
than modules sharing the same representation for types.)
But it resulted in not allowing the code you write here, which was
not intentional.

Other Caml News

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

References with physical equality:

ocaml-extunix 0.0.2 released:

hypertable bindings:

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