Olaf Hering | 26 May 22:11 2016
Picon

OASIS help: link stublib to system lib and another caml lib

The ocaml-fuse package as is does not build for bytecode target. I
updated the _oasis file as shown below and everything worked great. But
when feeding the resulting package to google-drive-ocamlfuse I got link
errors because ocaml-fuse was not linked to -lfuse and -lcamlidl. I
figured out how to link to fuse, its in $libdir so the compiler picks it
up.

But I can not figure out a generic way to link against -lcamlidl. This
package is in $libdir/ocaml, so I would have to exent CCLib: with
something like '-L $libdir/ocaml -lcamlidl'. This works if I force it to
be '-L/usr/lib64/ocaml -lcamlidl' for a 64bit build. But this would
break for 32bit builds.

Unfortunately I have not found the spot in the documentation where this
is explained. Appearently there is also no example covering such setup.

So how has the _oasis file to be changed to link to the system -lfuse
and to -lcamlidl in the ocaml installation path?

Olaf

$ cat ocaml-fuse/ocamlfuse-2.7.1_cvs2/_oasis:
OASISFormat:      0.4
Name:             ocamlfuse
Version:          2.7.1-cvs2
Synopsis:         OCaml bindings for FUSE (Filesystem in UserSpacE)
Description:      OCaml bindings for FUSE (Filesystem in UserSpacE)
Authors:          Vincenzo Ciancia
LicenseFile:      LICENSE
License:          GPL
(Continue reading)

Kenichi Asai | 26 May 15:20 2016
Picon

CFP: ML workshop 2016

Submission site is now open!  See you in Nara!
---------------------------------------------------------------------
Higher-order, Typed, Inferred, Strict: ACM SIGPLAN ML Family Workshop
Thursday September 22, 2016, Nara, Japan
(immediately following ICFP and preceding OCaml Users and Developers Workshop)

Call for papers: http://www.mlworkshop.org/ml2016/

ML is a very large family of programming languages that includes Standard
ML, OCaml, F#, SML#, Manticore, MetaOCaml, JoCaml, Alice ML, Dependent ML,
Flow Caml, and many others. All ML languages share several fundamental
traits, besides a good deal of syntax. They are higher-order, strict, mostly
pure, and typed, with algebraic and other data types. Their type systems are
derived from Hindley-Milner. The development of these languages has inspired
a significant body of computer science research and influenced the design of
many other programming languages, including Haskell, Scala and Clojure,
Rust, ATS and many others.

ML workshops have been held in affiliation with ICFP continuously since
2005. This workshop specifically aims to recognise the entire extended ML
family and to provide a forum for presenting and discussing common issues,
both practical (compilation techniques, implementations of concurrency and
parallelism, programming for the Web) and theoretical (fancy types, module
systems, metaprogramming). The scope of the workshop includes all aspects of
the design, semantics, theory, application, implementation, and teaching of
the members of the ML family. We also encourage presentations from related
languages (such as Scala, Rust, Nemerle, ATS, etc.), to exchange experience
of further developing ML ideas.

The ML family workshop will be held in close coordination with the OCaml
(Continue reading)

Mohamed Iguernlala | 26 May 10:24 2016
Picon

Is this a bug in Num.float_of_num ?

Hi,

I came to the following "stange" behavior when using the function
float_of_num. I don't know if this should be considered as a bug,
since this function has no specification (in num.mli *)

The float "f = 6004799503160661. /. 18014398509481984." has an
exact representation on 64 bits. Its value is

0.333333333333333314829616256247390992939472198486328125

However, when using float_of_num to compute the float corresponding to
the number above represented as a num, the result is slightly different.
In fact, the value returned for the expression

fnum = Num.float_of_num (Num.num_of_string 
"6004799503160661/18014398509481984")

is

0.333333333333000025877623784253955818712711334228515625

I tried to investigate the reason of this difference. It seems
that it is due to the (default) value of the constant
"floating_precision"[1] in file arith_flags.ml of num library: it
is equal to 12 instead of 54 (I think) for 64bits standard floats
representation.

How should this situation be interpreted ?

(Continue reading)

publicityifl | 24 May 21:13 2016
Picon

1st CfP: IFL 2016 (28th Symposium on Implementation and Application of Functional Languages)

Hello,

Please, find below the first call for papers for IFL 2016.
Please forward these to anyone you think may be interested.
Apologies for any duplicates you may receive.

best regards,
Jurriaan Hage
Publicity Chair of IFL

---

IFL 2016 - Call for papers

28th SYMPOSIUM ON IMPLEMENTATION AND APPLICATION OF FUNCTIONAL LANGUAGES - IFL 2016

KU Leuven, Belgium

In cooperation with ACM SIGPLAN

August 31 - September 2, 2016

https://dtai.cs.kuleuven.be/events/ifl2016/

Scope

The goal of the IFL symposia is to bring together researchers actively engaged
in the implementation and application of functional and function-based
programming languages. IFL 2016 will be a venue for researchers to present and
discuss new ideas and concepts, work in progress, and publication-ripe results
related to the implementation and application of functional languages and
function-based programming.

Peer-review

Following the IFL tradition, IFL 2016 will use a post-symposium review process
to produce the formal proceedings. All participants of IFL 2016 are invited to
submit either a draft paper or an extended abstract describing work to be
presented at the symposium. At no time may work submitted to IFL be
simultaneously submitted to other venues; submissions must adhere to ACM
SIGPLAN's republication policy:

http://www.sigplan.org/Resources/Policies/Republication

The submissions will be screened by the program committee chair to make sure
they are within the scope of IFL, and will appear in the draft proceedings
distributed at the symposium. Submissions appearing in the draft proceedings
are not peer-reviewed publications. Hence, publications that appear only in the
draft proceedings are not subject to the ACM SIGPLAN republication policy.
After the symposium, authors will be given the opportunity to incorporate the
feedback from discussions at the symposium and will be invited to submit a
revised full article for the formal review process. From the revised
submissions, the program committee will select papers for the formal
proceedings considering their correctness, novelty, originality, relevance,
significance, and clarity. The formal proceedings will appear in the
International Conference Proceedings Series of the ACM Digital Library.

Important dates

August 1: Submission deadline draft papers
August 3: Notification of acceptance for presentation
August 5: Early registration deadline
August 12: Late registration deadline
August 22: Submission deadline for pre-symposium proceedings
August 31 - September 2: IFL Symposium
December 1: Submission deadline for post-symposium proceedings
January 31, 2017: Notification of acceptance for post-symposium proceedings
March 15, 2017: Camera-ready version for post-symposium proceedings

Submission details

Prospective authors are encouraged to submit papers or extended abstracts to be
published in the draft proceedings and to present them at the symposium. All
contributions must be written in English. Papers must use the new ACM two
columns conference format, which can be found at:

http://www.acm.org/publications/proceedings-template

For the pre-symposium proceedings we adopt a 'weak' page limit of 12 pages. For
the post-symposium proceedings the page limit of 12 pages is firm.

Authors submit through EasyChair:

https://easychair.org/conferences/?conf=ifl2016

Topics

IFL welcomes submissions describing practical and theoretical work as well as
submissions describing applications and tools in the context of functional
programming. If you are not sure whether your work is appropriate for IFL 2016,
please contact the PC chair at tom.schrijvers <at> cs.kuleuven.be. Topics of interest include,
but are not limited to:

- language concepts
- type systems, type checking, type inferencing
- compilation techniques
- staged compilation
- run-time function specialization
- run-time code generation
- partial evaluation
- (abstract) interpretation
- metaprogramming
- generic programming
- automatic program generation
- array processing
- concurrent/parallel programming
- concurrent/parallel program execution
- embedded systems
- web applications
- (embedded) domain specific languages
- security
- novel memory management techniques
- run-time profiling performance measurements
- debugging and tracing
- virtual/abstract machine architectures
- validation, verification of functional programs
- tools and programming techniques
- (industrial) applications

Peter Landin Prize

The Peter Landin Prize is awarded to the best paper presented at the symposium
every year. The honored article is selected by the program committee based on
the submissions received for the formal review process. The prize carries a
cash award equivalent to 150 Euros.

Programme committee

Chair: Tom Schrijvers, KU Leuven, Belgium

- Sandrine Blazy, University of Rennes 1, France
- Laura Castro, University of A Coruña, Spain
- Jacques, Garrigue, Nagoya University, Japan
- Clemens Grelck, University of Amsterdam, The Netherlands
- Zoltan Horvath, Eotvos Lorand University, Hungary
- Jan Martin Jansen, Netherlands Defence Academy, The Netherlands
- Mauro Jaskelioff, CIFASIS/Universidad Nacional de Rosario, Argentina
- Patricia Johann, Appalachian State University, USA
- Wolfram Kahl, McMaster University, Canada
- Pieter Koopman, Radboud University Nijmegen, The Netherlands
- Shin-Cheng Mu, Academia Sinica, Taiwan
- Henrik Nilsson, University of Nottingham, UK
- Nikolaos Papaspyrou, National Technical University of Athens, Greece
- Atze van der Ploeg, Chalmers University of Technology, Sweden
- Matija Pretnar, University of Ljubljana, Slovenia
- Tillmann Rendel, University of Tübingen, Germany
- Christophe Scholliers, Universiteit Gent, Belgium
- Sven-Bodo Scholz, Heriot-Watt University, UK
- Melinda Toth, Eotvos Lorand University, Hungary
- Meng Wang, University of Kent, UK
- Jeremy Yallop, University of Cambridge, UK

Venue

The 28th IFL will be held in association with the Faculty of Computer Science,
KU Leuven, Belgium. Leuven is centrally located in Belgium and can be easily
reached from Brussels Airport by train (~15 minutes). The venue in the
Arenberg Castle park can be reached by foot, bus or taxi from the city center.
See the website for more information on the venue.
Drup | 24 May 00:27 2016

[ANN] TyXML 4.0

It is with great pleasure that we are announcing the release of TyXML 4.0.0. The major features of this new release are a new PPX syntax extension that allows to use the standard HTML syntax and an improved user experience for both old and new TyXML users.

TyXML is a library for building statically correct HTML5 and SVG documents. It provides a set of combinators which use the OCaml type system to ensure the validity of the generated document. TyXML’s combinators can be used to build textual HTML and SVG, but also DOM trees or reactive interfaces, using Eliom and Js_of_ocaml.

A presentation of the new release is available on the ocsigen blog and the changelog is available on github.

Happy HTML and SVG hacking!
Daniel Bünzli | 23 May 23:58 2016
Picon
Gravatar

[ANN] Topkg 0.7.0

Hello (last one today, promised),

I'd like to announce the first release of topkg. For those who know topkg, it is no longer an embedded script
but a library that you add as a build dependency to your package. It now also comes with an optional tool that
helps you to manage your package and make swift and correct releases.

Bla bla bla:
```
Topkg is a packager for distributing OCaml software. It provides an API to describe the files a package
installs in a given build configuration and to specify information about the package's distribution
creation and publication procedures.

The optional topkg-care package provides the `topkg` command line tool which helps with various aspects
of a package's life cycle: creating and linting a distribution, releasing it on the WWW, publish its
documentation, add it to the OCaml OPAM repository, etc.

Topkg is distributed under the ISC license and has **no** dependencies. This is what your packages will
need as a *build* dependency.

Topkg-care is distributed under the ISC license and depends on fmt, logs, bos, cmdliner and opam-lib.
```

Install: opam install topkg topkg-care
Homepage: http://erratique.ch/software/topkg
API docs & manual: http://erratique.ch/software/topkg/doc/Topkg.html#basics
See also `topkg help release` and `topkg help`

A few things worth noting:

* Topkg pretends to work on Windows (provided your build system does) but early users may need to give a hand,
please do report issues if things go wrong.

* Topkg pretends to be able to work with hg source repositories, the same as for Windows applies.

* Topkg should be able to work with other build systems than ocamlbuild. But a few things (e.g.
documentation support or dependency linting) do at the moment rely on ocamlbuild being used. It's not my
priority but I'm not against improving it to make it easier to use with other build systems.

* Topkg only supports OCaml from 4.01 on and hence will also impose this limit on your packages.

* Topkg has toy, proof of concept, support to publish documentation and distributions via GitHub's pages
and release system. I'm personally not using this so do not hesitate to report broken or suboptimal
behaviour. Better support — especially gh issue interaction for 'topkg issue' and better
authentication would be nice, but is left in the hands of a motivated github user. Someone should develop
and distribute a good github topkg delegate (e.g. using ocaml-github) that github users can install; see
'toy-github-topkg-delegate --help' and 'topkg help delegate'; the source of the toy delegate [1] can be
used as a blueprint. Do not hesitate to get in touch for more information and/or design discussion.  

Topkg may not be the final word in OCaml building & packaging, however, depending on your needs, topkg's
release workflow (see 'topkg help release') may come as a significant improvement over the current
status quo.  

I have been using a similar but more ad-hoc system with my packages for a few years now since I realized that
oasis was getting in my way to scale modularity. Except for the maintainability problem of having an
embedded script which is now gone with this new incarnation of topkg, it has already been shown to work
quite well in practice for me and a limited number of other persons, in a large range of software install
scenarios, YMMV.

Best,

Daniel

P.S. If you are on github and start to use `topkg` you can mention me ( <at> dbuenzli) in the inaugural PR or
commit, I'm interested to see how it is used and misused.

[1] https://github.com/dbuenzli/topkg/blob/v0.7.0/src-bin/toy_github_delegate.ml

--

-- 
Caml-list mailing list.  Subscription management and archives:
https://sympa.inria.fr/sympa/arc/caml-list
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
Bug reports: http://caml.inria.fr/bin/caml-bugs
Daniel Bünzli | 23 May 23:01 2016
Picon
Gravatar

[ANN] Bos 0.1.0

Hello, 

I'd like to announce the first release of bos:

```
Bos provides support for basic and robust interaction with the operating system in OCaml. It has functions
to access the process environment, parse command line arguments, interact with the file system and run
command line programs.

Bos works equally well on POSIX and Windows operating systems.

Bos depends on Rresult, Astring, Fmt, Fpath, Logs and the OCaml Unix library. 
It is distributed under the ISC license.
```

Homepage: http://erratique.ch/software/bos
API docs: http://erratique.ch/software/bos/doc/

Bos can be seen as improved Sys module for programs and scripts that have light OS interaction
requirements. Inspired by the excellent work of scsh [0], it seems this path has been pursued more than
once in OCaml for example with cash [1] or shcaml [2]. 

Bos however has a slightly different take on this. It does not try to recover the shell's terseness or
processing model but rather tries to overcome the shell's brittleness in face of errors, error reporting
and insane quoting conventions. The difference between a script and a program is an artificial one and bos
tries to encourage you to write programs that do not fail obscurely and evolve gracefully from a quick,
small one (a.k.a "script") to a complex one (a.k.a. "program") while keeping good usability for the end
user who is the one who eventually gets processing failures in the face.

This first version number is intentionally low, as I don't see bos as fully finished at the moment. Some
interfaces could be tweaked and other added in the future (feedback and discussion on the issue tracker is
welcome). I did however already write a few programs/scripts that make use of most of the features
provided by the library, so the low number should not be interpreted as "alpha" quality software. What is
provided here should work as described and if it doesn't, scream on the issue tracker.

Best, 

Daniel

[0] https://scsh.net/
[1] http://pauillac.inria.fr/cash/
[2] http://users.eecs.northwestern.edu/~jesse/code/shcaml/

--

-- 
Caml-list mailing list.  Subscription management and archives:
https://sympa.inria.fr/sympa/arc/caml-list
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
Bug reports: http://caml.inria.fr/bin/caml-bugs

Neuhaeusser, Martin | 23 May 16:33 2016
Picon

Hash consed Patricia trees

Dear all,

during some experiments with integer set implementations, I came across a discussion on that list that
proposed to use Patricia trees and hash consing on the tree nodes' constructors to achieve maximal sharing:
http://caml.inria.fr/pub/ml-archives/caml-list/2008/03/5be97d51e2e8aab16b9e7e369a5a5533.en.html

Is anyone aware of a corresponding implementation that also has a performance benefit (or, at least, no
negative performance impact) compared to standard sets or to non-hash consed Patricia trees? Or is
anyone aware of a paper on that matter? 

Sadly, in all my experiments, the combination of Patricia trees with hash consing applied to the terms
representing the tree has a horrible impact on performance (a slowdown by an order of magnitude). After
spending some thoughts, this seems to be reasonable given the structure of a Patricia tree. In
particular, we found no way to make significand use of the reflexivity properties obtained by hash
consing in set operations like subset or union. In our benchmarks, the time for constructing hash-consed
subtrees during set operations outweighs any gains obtained by the "physical equality = set equality"
property. Or is the whole point in the earlier discussion the possibility to use hash consing tags for
memoization of set operations? 

Any hints and comments are highly appreciated. It would really be great if some of the participants from the
2008 discussion could perhaps share their experience.

Best regards,
Martin

--

-- 
Caml-list mailing list.  Subscription management and archives:
https://sympa.inria.fr/sympa/arc/caml-list
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
Bug reports: http://caml.inria.fr/bin/caml-bugs
Louis Roché | 23 May 13:00 2016
Picon

Re: Prochain meetup OUPS 7 juin 2016 / Next OUPS meetup, 7th of June 2016

(English version below) 

Bonjour,

Mise à jour des informations :

Le meetup se tiendra dans les locaux de Mozilla Paris. L'adresse est 16 Bis Boulevard Montmartre Paris 75009. Un contrôle d'accès sera en place à l'entrée. Vous devez impérativement être inscrits pour y accéder.

La liste définitive des présentations :

- Danny Willems : Bindings OCaml à Cordova grâce à js_of_ocaml et gen_js_api
- Frédéric Bour : sturgeon — A toolkit for communicating with Emacs from OCaml
- Corentin De Souza : dead_code_analyzer — un détecteur de code mort pour OCaml

Pour vous inscrire, ou pour plus d'informations rendez vous ici:

http://www.meetup.com/fr-FR/ocaml-paris/events/231068590/

Louis

----------------------------------------------------------------

Hi,

Updated informations:

The meetup will take place at Mozilla Paris. The address is 16 Bis Boulevard Montmartre Paris 75009. The access is controlled. You won't be allowed to join the meetup if you are not registered.

The definitive list of talks:

- Danny Willems : Bindings OCaml à Cordova grâce à js_of_ocaml et gen_js_api
- Frédéric Bour : sturgeon — A toolkit for communicating with Emacs from OCaml
- Corentin De Souza : dead_code_analyzer — un détecteur de code mort pour OCaml

To register, or for more information, go here:

http://www.meetup.com/fr-FR/ocaml-paris/events/231068590/

Louis

On May 14, 2016 21:17, "Louis Roché" <louis <at> louisroche.net> wrote:
(English version below) 

Bonjour, Le prochain meetup OUPS aura lieu mardi 7 juin.
Le lieu du rendez-vous n’est pas encore fixé. Je vous tiendrai au courant.
Les présentations commenceront à 19h (pour environ 1h30) et seront suivis du pot habituel.

Le programme des exposés confirmés jusqu'ici:

- Danny Willems: Bindings OCaml à Cordova grâce à js_of_ocaml et gen_js_api 
- Frédéric Bour: sturgeon  A toolkit for communicating with Emacs from OCaml

Je profite de l'occasion pour rappeler que je suis toujours en
demande de *propositions* d'exposés sur les sujets de votre choix pour
ce meetup ou les suivants.

Pour vous inscrire, ou pour plus d'informations rendez vous ici:

Vous pouvez retrouver les slides des dernières sessions ici:

Louis

----------------------------------------------------------------

Hi,

The next OUPS meetup will take place on the 7th of June 7pm. The location is not defined yet.
We will have a few talks, followed by pizzas.

The talks will be the following:

- Danny Willems: Bindings OCaml à Cordova grâce à js_of_ocaml et gen_js_api 
- Frédéric Bour: sturgeon  A toolkit for communicating with Emacs from OCaml

Note that we are always in demand of talk *proposals* for future
meetups.

To register, or for more information, go here:
*Registration is required!*

Slides from previous sessions are available online:

Louis
Jeremie Dimino | 23 May 11:39 2016

More frequent pushes to Jane Street github repositories + janestreet/opam-repository

Hi,

We are currently trying to improve our workflow for releasing our code ​on github ​and following up on external contributions.

As a first step in this direction, w​e reworked​ our internal process for ​exporting​ the public release and we are now able to push to github more often. ​So going forward, instead of pushing one huge commit before every ​major release​ in the main opam repository​, we will push smaller commits more frequently.

This has several consequences:

- it will be easier to follow the latest changes
- accepted pull requests will appear in the git repository earlier
- you can complain if we break your code before the next release in opam...

​Initially the commit messages will still be meaningless and the changelogs might be slightly lagging behind given that producing them still requires a fair amount of work from a human.​ However, we are planning to improve this over time.

​Note that we'll continue to provide support for the latest version that is released in opam.​

## ​janestreet/opam-repository

To help trying the development version of our libraries, we've setup an opam repository that follows their latest development version [1]. So in order to try out the latest version of core, you can do:

    $ opam repo add git://github.com/janestreet/opam-repository.git
​    ​$ opam install core

​Pinning individual packages with `opam pin add --dev` might work as well, but there is no guarantee about it​.

## 113.43+70

To start the new process, we just pushed the latest version of our code on github. The version is 113.43+70 and includes a fair amount of changes.


--​ ​
Jeremie​ Dimino, for the Core team
Daniel Bünzli | 23 May 10:58 2016
Picon
Gravatar

[ANN] Fpath 0.7.0

Hello,

It is my pleasure to announce the first release of Fpath, described as:

```
Fpath is an OCaml module for handling file system paths on POSIX and
Windows operating systems. Fpath processes paths without accessing
the file system and is independent from any system library.

Fpath depends on Astring and is distributed under the ISC license.
```

Homepage: http://erratique.ch/software/fpath
API docs: http://erratique.ch/software/fpath/doc/Fpath

Fpath claims to behave reasonably on Windows, in the sense that it is aware of drives, UNC paths, etc. This is
just a claim, Windows user are encouraged to shout on the issue tracker if they feel some things are wrong or
could be improved.

Many thanks to David Sheets, whose insightful review and comments contributed to make Fpath a much saner
and usable library than I would have produced in the first place; remaining misdesigns are mine.

Best,

Daniel

--

-- 
Caml-list mailing list.  Subscription management and archives:
https://sympa.inria.fr/sympa/arc/caml-list
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
Bug reports: http://caml.inria.fr/bin/caml-bugs


Gmane