Anders Peter Fugmann | 8 Oct 20:46 2015

Strange Gadt error


I the following example (boiled down from a real use case):

type _ elem =
   | Int: int elem

let rec incr: type a. a elem -> a -> int = function
   | Int -> fun i -> add i 1
and add n m = n + m

I get the error (Ocaml 4.02.3):
File "", line 5, characters 24-25:
Error: This expression has type int but an expression was expected of type
        This instance of int is ambiguous:
        it would escape the scope of its equation

I can get rid of the error by annotating the type of i in line 5 like this:

  | Int -> fun (i : int) -> add i 1

Or move add above incr like this:

let rec add n m = n + m
and incr: type a. a elem -> a -> int = function
   | Int -> fun i -> add i 1

Is there an explanation to why I need to give the type of i in this 
(Continue reading)

Stefan Hellermann | 8 Oct 11:43 2015

Broken 32 bit cross-compiler on 64bit host


currently I'm trying to add OCaml to the openwrt router distribution [1] [2]. This would mean you could run your favorite OCaml applications on your router. I would like to run unison [3] on my router.

So I first build native OCaml 4.02.3 on my x86_64 linux host, and then build a OCaml cross-compiler for the 32 bit target, e.g. mips-openwrt-linux. Building OCaml went fine after adding a small patch to manually set Endianness and Bitness in configure script, please have a look at attached patch.

host OCaml configure line:
./configure -prefix somepath -no-pthread -no-debugger -no-ocamldoc -no-graph -no-cfi
cross OCaml configure line:
./configure -prefix someotherpath -target-bindir /usr/bin -host x86_64-unknown-linux-gnu -target mips-openwrt-linux-musl -cc "mips-openwrt-linux-musl-gcc some target cflags" -as "mips-openwrt-linux-musl-as some target as flags" -no-pthread -no-shared-libs -no-debugger -no-ocamldoc -no-graph -no-cfi -big-endian

Now the bug: When running OCaml applicantions (build with -custom), they crash on startup on the target:

Fatal error: exception Failure("input_value: integer too large")

This is similar to OCaml Bug #5977 [4]

There is a workaround:
Build the host OCaml as 32 bit OCaml, then build the cross compiler with this 32 bit host OCaml. The resulting binaries work on the target.
This is what I did for openwrt [2], but it fails on 64 bit hosts where no 32 bit development tools are installed. It only catches the case when building on x86_64 hosts, it will break when building on say powerpc64 or 64 bit arm. It's also problematic for openwrt, as only the cross compiler but not the host tools are recompiled if the target arch changes, e.g. from 64 bit arm to 32 bit mips.

Now my questions:
- Is building a 32 bit cross compiler on a 64 bit host supposed to work?
- Is my patch to configure ok, or is there a better way to configure the cross-compiler?
- Should I run some test suite on the target and post the results?

[WARNING] Something went wrong while checking native division and modulus please report it at http://
Do I have to care?
I tried defining and undefining NONSTANDARD_DIV_MOD in m.h. without any visible difference. Running the test-prog divmod.c on a few targets always returns 0.


Attachment (001-crosscompile.patch): application/octet-stream, 2815 bytes
Attachment (host configure.log): application/octet-stream, 5076 bytes
Attachment (cross configure.log): application/octet-stream, 5999 bytes
Sébastien Hinderer | 8 Oct 09:43 2015

OCaml projects with tests

Dear all,

Recently the topic was discussed here and several testing frameworks were

I am wondering whether there are well established projects that actually
use tests (unit tests and others) and that could be used as sources of




Caml-list mailing list.  Subscription management and archives:
Beginner's list:
Bug reports:

Geoff Sutcliffe | 6 Oct 16:21 2015

IWIL-11 in Fiji, extended deadline

         11th International Workshop on the Implementation of Logics

                        FINAL CALL FOR PAPERS
                  Extended deadline: October 15, 2015.

The 11th International Workshop on the Implementation of Logics will be held in
November 2015 in conjunction with the 20th International Conference on Logic
for Programming, Artificial Intelligence, and Reasoning in Suva, Fiji

We are looking for contributions describing implementation techniques for and
implementations of automated reasoning programs, theorem provers for various
logics, logic programming systems, and related technologies. Topics of interest
include, but are not limited to:

+ Propositional logic and decision procedures, including SMT
+ First-order and higher order logics
+ Non-classical logics, including modal, temporal, description, non-monotonic reasoning
+ Formal foundations for efficient implementation of logic
+ Data structures and algorithms for the efficient representation and processing of logical concepts
+ Proof/model search organization and heuristics for logical reasoning systems
+ Data analysis and machine learning approaches to search control
+ Techniques for proof/model search visualization and analysis
+ Practical constraint handling
+ Reasoning with ontologies and other large theories
+ Implementation of efficient theorem provers and model finders for different logics
+ System descriptions of logical reasoning systems
+ Issues of reliability, witness generation, and  witness verification
+ Evaluation and benchmarking of provers and other logic-based systems
+ I/O standards and communication between reasoning systems

We are particularly interested in contributions that help the community to
understand how to build useful and powerful reasoning systems, and how to apply
them in practice.

Researchers interested in participating are invited to submit a position
statement (2 pages), a short paper (up to 5 pages), or a full papers (up to 15
pages) via the EasyChair page for IWIL-2015,

Submissions will be refereed by the program committee, which will select a
balanced program of high-quality contributions.

Submissions should be in standard-conforming PDF. Final versions will be
required to be submitted in LaTeX using the easychair.cls class file.
Proceedings will be published as EasyChair Proceedings.

If number and quality of the submissions warrant it, we plan to produce a
special issue of a recognized journal on the topic of the workshop.

Important Dates:
+ Submission of papers/abstracts:   October 12, 2015 (extended deadline)
+ Notification of acceptance:       October 26, 2015
+ Camera ready versions due:        November 9, 2015
+ Workshop:                         November 23, 2015

Program committee:
+ Boris Konev (Co-Chair)        University of Liverpool
+ Stephan Schulz (Co-Chair)     DHBW Stuttgart
+ Laurent Simon (Co-Chair)      University of Bordeaux
+ Christoph Benzmüller          Freie Universität Berlin
+ Armin Biere                   Johannes-Kepler Universität Linz
+ Jasmin Blanchette             INRIA/LORIA/Max-Planck-Institut für Informatik
+ Guillaume Burel               ENSIIE/CEDRIC
+ Simon Cruanes                 INRIA Paris-Rocquencourt
+ Tommi Junttila                Aalto University
+ Yevgeny Kazakov               Universität Ulm
+ Konstantin Korovin            University of Manchester
+ Albert Oliveras               Universitat Politècnica de Catalunya
+ Jens Otten                    Universität Potsdam
+ Andrew Reynolds               Ecole polytechnique fédérale de Lausanne
+ Peter Schneider-Kamp          University of Southern Denmark
+ Geoff Sutcliffe               University of Miami
+ Josef Urban                   Radboud University/Czech Technical University
+ Uwe Waldmann                  Max-Planck-Institut für Informatik

Previous Workshops:
+ Reunion Workshop (held in conjunction with LPAR'2000 on Reunion Island)
+ Second Workshop (with LPAR 2001 in Havana, Cuba)
+ Third Workshop (with LPAR 2002 in Tbilisi, Georgia)
+ Fourth Workshop (with LPAR 2003 in Almati, Kazakhstan)
+ Fifth Workshop (with LPAR 2004 in Montevideo, Uruguay)
+ Sixth Workshop (with LPAR 2006 in Phnom Penh, Cambodia)
+ Seventh Workshop (with LPAR 2008 in Doha, Qatar)
+ Eighth Workshop (with LPAR 2010 in Yogyakarta, Indonesia)
+ Ninth Workshop (with LPAR 2012 in Merida, Venezuela)
+ Tenth Workshop (with LPAR 2013 in Stellenbosch, South Africa)


Caml-list mailing list.  Subscription management and archives:
Beginner's list:
Bug reports:

Richard W.M. Jones | 6 Oct 15:43 2015

Finding "lost" references to OCaml heap values

I guess I have two questions:

(1) Is calling Gc.compact () guaranteed to call the finalizer of any
object which is no longer reachable, under all circumstances?  Or
would there be some case where it wouldn't be called?

(2) I have a large mixed OCaml / C program[a] where somehow calling
Gc.compact isn't calling the destructor of a (very) large object.
Manual code inspection has not revealed anything so far --
superficially it appears we are not holding any references to the
object.  Is there any method / library / tool that can inspect the
OCaml heap and find references to an object?



Richard Jones
Red Hat


Caml-list mailing list.  Subscription management and archives:
Beginner's list:
Bug reports:

Christian Lindig | 5 Oct 18:03 2015

Using OCamlbuild with C stubs

What is the recommended way to use OCamlbuild when implementing a few primitives in C?
I’ve seen several blog posts about this and I feel there are some struggles. 


This is quite involved and requires experience with customizing OCamlbuild using the mechanism.


This approach implements a minimal new parameterised tag to express that the C object code needs to be
linked into the final binary. I had trouble getting it to work when the project spans several directories.
But if it works, maybe it should be a built-in tag?


This strikes a middle ground.

Maybe the projects are so different that there is no one way. I believe one core problem is to express that an
object file or local C library needs to be linked into the binary. 

During experiments I came up with an approach that doesn’t require but seems like a

$ ocamlbuild -I src -I lib -lflag lib/libpath.a libpath.a main.byte

Building libpath.a is triggered by naming it as a target on the command line; likewise, linking it to the
binary main.byte is expressed using the linker flag “-lflag”. This works around the problem that a
built-in mechanism seems to be missing to express this dependency using tags.

Project layout:

./lib/libpath.clib 		# lists pathutil.o
./lib/pathutil.c 		# new primitive in C
./lib/pathutil.mli 		# interface

_tags file:

<**/main.byte>:           custom

You can find it as examples/06-simple-c in my clone of the ocamlbuild manual that Gabriel Scherer is
working on:

I understand that dependencies among C files need to be handled as well but would solve this problem outside
of Ocamlbuild.

— Christian


Caml-list mailing list.  Subscription management and archives:
Beginner's list:
Bug reports:
Jeremie Dimino | 5 Oct 15:40 2015

[ANN] Jane Street's ppx rewriters

I am pleased to announce the initial release of the Jane Street's ppx
rewirters. They are now all in opam, and the next release of Core will
be using them.

They are using a specific framework that we developed to ensure our
rewriters are robust against misuses of new syntaxes. However all
packages export regular ppx executables or ppx_deriving plugins, than
can be used the standard way with ocamlfind.

This is the list of ppx rewriters that we released so far:

- ppx_assert (replaces pa_test)
- ppx_bench
- ppx_bin_prot
- ppx_compare
- ppx_csv_conv
- ppx_custom_printf
- ppx_enumerate
- ppx_fail
- ppx_fields_conv
- ppx_here
- ppx_inline_test (replaces pa_ounit)
- ppx_pipebang
- ppx_sexp_conv
- ppx_sexp_value (replaces pa_structural_sexp)
- ppx_typerep_conv
- ppx_variants_conv
- ppx_xml_conv

In addition we are releasing a few libraries:

# ppx_core

This is our PPX standard library. Amongst other things it contains:

- Various open recursion classes to traverse the OCaml AST:
  Ast_traverse.{map,fold,fold_map,...}. This work extends the
  Ast_mapper.mapper record of the OCaml compiler libraries. However it
  uses names that are closer to the ones in parsetree.mli, so that is
  is easier to infer them by just knowing the parsetree. We found that
  was helpful when writing ppx related code.
- A framework for attributes and extension points. It deals with
  namespacing and make it easier to describe the expected payload.
  When used in combination with ppx_driver, it provides helpful error
  messages for users.
- Helpers for building and matching the OCaml AST. The building part
  is similar to the Ast_helper module of OCaml but with a different
  naming convention and no use of a global variable: a functor is provided
  to factorize the [~loc] argument.

# ppx_driver

This is what we use to handle all of our code rewriting. Instead of
running one process per code transformation, we crunch them all into
one executable. This has several advantages:

- probably speed, although this hasn't been benchmarked
- a simple way to see the transformed code: no need to build a complex
  command line, just run "./ppx"
- some helpers to debug code transformations

But more importantly, since the driver has knowledge of all
transformations and all supported attributes and extensions, it can:

- check that no attribute accidentally ends up being dead code
- give helpful error messages for unused attributes

For instance:

    # type t = int [ <at>  <at> derivin sexp]
    Attribute `derivin' was not used
    Hint: Did you mean deriving?

    # type t = int [ <at> deriving sexp]
    Attribute `deriving' was not used
    Hint: `deriving' is available for type declarations, type extensions
    and extension constructors but is used here in the context of a core type.
    Did you put it at the wrong level?"

    # type t = { x : int [ <at> default 42] } [ <at>  <at> deriving sexp_of];;
    Attribute `default' was not used

    # let%test ("name" [ <at> foo]) = f x = 42;;
    Attributes not allowed here

This is important to us as we don't want people to waste time because
of a misspelled/misplaced attribute. Also when developing rewriters,
we found that it was quite easy to accidentally drop attributes, and
sometimes it is hard to avoid. ppx_driver notifies the user when this

# ppx_type_conv

This is the base library for all our type-driven code generators. It
is similar to ppx_deriving, but with similar requirements as
ppx_driver. Unless used with ppx_driver, ppx_type_conv will just use

# ppx_optcomp

This is what we use for when we need conditional compilation. It's has
a cpp-like syntax, which is nice for this kind of things, and works at
the lexer level, which make it possible to use it in pattern matchings
for instance.

It is used by the lexer fronted of ppx_driver. So if used as a -pp
instead of -ppx, a ppx driver will have optcomp enabled.

Jeremie Dimino, for the Core team


Caml-list mailing list.  Subscription management and archives:
Beginner's list:
Bug reports:

Rodolphe Lepigre | 3 Oct 09:02 2015

GADT magic

Dear list,

I am using a GADT and some phantom types to implement an abstract syntax
tree for some functional programming language, say the λ-calculus.

My first type definition was something like:

type valu =
  | LVar of string
  | LAbs of valu -> term
and  term =
  | Valu of valu
  | Appl of term * term

This works fine, but it is annoying to work with because of the coercion
constructor "Valu". Then I decided to be to smarter and use some GADT and
phantom types:

type v
type t

type _ expr =
  | LVar : string              -> 'a expr
  | LAbs : (v expr -> 'b expr) -> 'a expr
  | Appl : 'a expr * 'b expr   ->  t expr

type term = t expr
type valu = v expr

This definition is much more convenient since the type "valu" is (kind of)
a subtype of the type "term". It is not a real subtype since I had to
define a function with the type:

val expr_to_term : type a. a expr -> term

This function is exactly the identity function, but for the type checker
to accept it I need to be quite explicit:

let expr_to_term : type a. a expr -> term = function
  | LVar(x)   -> LVar(x)
  | LAbs(f)   -> LAbs(f)
  | Appl(t,u) -> Appl(t,u)

Of course, a better and more efficient implementation for this function
is "Obj.magic", but this is not the question here. I was expecting the
following definition to work:

let expr_to_term : type a. a expr -> term = function
  | LVar(x)   -> LVar(x)
  | LAbs(f)   -> LAbs(f)
  | t         -> t

But it does not type check. This is weird because all remaining patterns
captured by the "t" have type "term"...

Is this normal behaviour? Is this a bug?

Rodolphe Lepigre
LAMA, Université Savoie Mont Blanc, FRANCE


Caml-list mailing list.  Subscription management and archives:
Beginner's list:
Bug reports:

Ezio Bartocci | 2 Oct 20:03 2015

CPS-Week 2016: Call for Papers

Technical Sponsors 
Platinum Sponsor 

Tue April 12: Scientific Keynote
    Rajeev Alur
    Zisman Family Professor, 
    Computer and Information Science, UPenn, USA
Wed April 13: Industrial Keynotes 
    Industry 4.0: Sabine Herlitschka
    CEO Infineon Austria 

    Internet of Things: Joe Salvo
    Dir. of CS and Arch., GE Global Research, USA 

    Smart Grid: Rada Rodriguez
    CEO Schneider Electric, Germany 

    Smart Mobility: Ken Butts,  
    Executive Engineer, Powertrain Control, Toyota, USA
Thu April 14: Scientific Keynote 
    Tomasso Poggio
    Eugene McDermott Professor, 
    Brain and Cognitive Sciences, CSAIL, MIT, USA
Important Dates
  • Workshops and Tutorial Proposals: Oct. 1st, 2015
  • Abstract Registration: Oct. 8th, 2015 (HSCC, ICCPS, IPSN)
  • Submission Deadline: Oct. 15th, 2015 (ICCPS, IPSN, RTAS)
  •                                        Oct. 23rd, 2015 (HSCC)
  • Notification Dates: vary by individual conferences
  • Workshop and Tutorial Day:  Apr. 11th, 2016
  • Main Conference:  Apr. 12th - Apr.14th, 2016
Call for Papers

Cyber-physical systems (CPS) are complex engineering systems that rely on the integration of physical, computation, and communication processes to function. Theories, algorithms, systems and methodologies developed for CPS are the foundations for applications like Internet of Things, industrial internet and automation, smart transportation, smart grids, smart cities, buildings and homes, data centers, health care and so on. Such systems must be operated safely, dependably, securely, efficiently and in real-time. Advances in this field will have great technical, economic and societal impacts in the near future. Since 2008, CPS Week is the premier forum for academic, industry, and governmental researchers to present latest research results and exchange ideas on all aspects of CPS. 
CPS Week 2016 will be held in the beautiful Hofburg Palace in Vienna, Austria. The event features four major co-located conferences: 
In additional to major conferences, CPS Week 2016 will host workshops, tutorials, poster and demo sessions and a competition. CPS Week conferences call for original research contributions. 

Please refer to Call for Papers from individual conferences for topics of interests and submission formats.

General co-Chairs:

Radu Grosu (TU Wien)
Thomas A. Henzinger (IST Austria)

Finance Chair:

Dejan Nickovic (AIT)

Industrial Liaison co-Chairs:

Peter Palensky (AIT and TU Delft)
Stefan Poledna (TTTech Austria)

Local Arrangement Chair:

Ezio Bartocci (TU Wien) 

Publication Chair:

Edmund Widl (AIT)

Publicity Chair:

Hermann Kopetz (TU Wien)

Registration co-Chairs:

Sergiy Bogomolov (IST Austria) 
Edmund Widl (AIT)

Web and Social Media Chair:

Ezio Bartocci (TU Wien) 

Workshop/Demo co-Chairs:

Christoph Kirsch (Uni Salzburg)
Ana Sokolova (Uni Salzburg)

Steering Committee


George J. Pappas (UPenn)

Committee Members:

Werner Damm (Univ. of Oldenburg)
Insup Lee (UPenn) 
Raj Rajkumar (CMU) 
Sanghyuk Son (DGIST and UVa) 
Jack Stankovic (UVa) 
Feng Zhao (Microsoft, China) 

Supported by






GRLMC | 2 Oct 18:27 2015

LATA 2016: 3rd call for papers

*To be removed from our mailing list, please respond to this message with UNSUBSCRIBE in the subject line*





LATA 2016


Prague, Czech Republic


March 14-18, 2016


Organized by:


Department of Theoretical Computer Science

Faculty of Information Technology

CzechTechnicalUniversity in Prague


Research Group on Mathematical Linguistics (GRLMC)

Rovira i Virgili University





LATA is a conference series on theoretical computer science and its applications. Following the tradition of the diverse PhD training events in the field developed at Rovira i VirgiliUniversity in Tarragona since 2002, LATA 2016 will reserve significant room for young scholars at the beginning of their career. It will aim at attracting contributions from classical theory fields as well as application areas.




LATA 2016 will take place in Prague, a city full of history and cultural attractions, and one of the political and economic cores of central Europe. The venue will be the campus of the CzechTechnicalUniversity in the Dejvice quarter.




Topics of either theoretical or applied interest include, but are not limited to:


algebraic language theory

algorithms for semi-structured data mining

algorithms on automata and words

automata and logic

automata for system analysis and programme verification

automata networks

automata, concurrency and Petri nets

automatic structures

cellular automata


combinatorics on words

computational complexity

data and image compression

descriptional complexity

digital libraries and document engineering

foundations of finite state technology

foundations of XML

fuzzy and rough languages

grammars (Chomsky hierarchy, contextual, unification, categorial, etc.)

grammatical inference and algorithmic learning

graphs and graph transformation

language varieties and semigroups

language-based cryptography

mathematical and logical foundations of programming methodologies

parallel and regulated rewriting



power series

string and combinatorial issues in bioinformatics

string processing algorithms

symbolic dynamics

term rewriting


trees, tree languages and tree automata

unconventional models of computation

weighted automata




LATA 2016 will consist of:


invited talks

invited tutorials

peer-reviewed contributions




Avrim Blum (CarnegieMellonUniversity), Reconstructing Preferences from Opaque Transactions


Martin Grohe (RWTHAachenUniversity), Connectivity Systems, Decompositions, and Tangles


Giovanni Pighizzini (University of Milan), Restricted Turing Machines and Language Recognition (tutorial)


Jean-François Raskin (Free University of Brussels), Non-zero Sum Games for Reactive Synthesis


Frank Wolter (University of Liverpool), Automata for Ontologies




Amihood Amir (Bar-IlanUniversity, Ramat Gan, Israel)

Dana Angluin (YaleUniversity, New Haven, USA)

Franz Baader (Technical University of Dresden, Germany)

Christel Baier (Technical University of Dresden, Germany)

Hans L. Bodlaender (UtrechtUniversity, The Netherlands)

Jean-Marc Champarnaud (University of Rouen, France)

Bruno Courcelle (LaBRI, Bordeaux, France)

Rod Downey (VictoriaUniversity of Wellington, New Zealand)

Frank Drewes (Umeå University, Sweden)

Ding-Zhu Du (University of Texas, Dallas, USA)

Javier Esparza (Technical University of Munich, Germany)

Michael Fellows (CharlesDarwinUniversity, Darwin, Australia)

Mohammad Taghi Hajiaghayi (University of Maryland, College Park, USA)

Yo-Sub Han (YonseiUniversity, Seoul, South Korea)

Markus Holzer (University of Giessen, Germany)

Juraj Hromkovič (ETH Zurich, Switzerland)

Oscar H. Ibarra (University of California, Santa Barbara, USA)

Costas S. Iliopoulos (King's College London, UK)

Jan Janoušek (CzechTechnicalUniversity in Prague, Czech Republic)

Galina Jirásková (SlovakAcademy of Sciences, Košice, Slovakia)

Ming-Yang Kao (Northwestern University, Evanston, USA)

Juhani Karhumäki (University of Turku, Finland)

Joost-Pieter Katoen (RWTH Aachen University, Germany)

Martin Kutrib (University of Giessen, Germany)

Zhiwu Li (Xidian University, Xi'an, China)

Andreas Malcher (University of Giessen, Germany)

Oded Maler (VERIMAG, Gières, France)

Carlos Martín-Vide (Rovira i Virgili University, Tarragona, Spain, chair)

Bořivoj Melichar (CzechTechnicalUniversity in Prague, Czech Republic)

Ugo Montanari (University of Pisa, Italy)

František Mráz (CharlesUniversity in Prague, Czech Republic)

Mitsunori Ogihara (University of Miami, Coral Gables, USA)

Alexander Okhotin (University of Turku, Finland)

Doron A. Peled (Bar-IlanUniversity, Ramat Gan, Israel)

Martin Plátek (CharlesUniversity in Prague, Czech Republic)

Alberto Policriti (University of Udine, Italy)

Daniel Reidenbach (University of Loughborough, UK)

Antonio Restivo (University of Palermo, Italy)

Kai Salomaa (Queen’s University, Kingston, Canada)

Davide Sangiorgi (University of Bologna, Italy)

Uli Sattler (University of Manchester, UK)

Frits Vaandrager (RadboudUniversity, Nijmegen, The Netherlands)

Pierre Wolper (University of Liège, Belgium)

Zhilin Wu (Chinese Academy of Sciences, Beijing, China)

Mengchu Zhou (New Jersey Institute of Technology, Newark, USA)




Adrian Horia Dediu (Tarragona)

Jan Janoušek (Prague, co-chair)

Carlos Martín-Vide (Tarragona, co-chair)

Radomír Polách (Prague)

Eliška Šestáková (Prague)

Jan Trávníček (Prague)

Bianca Truthe (Giessen)

Florentina Lilica Voicu (Tarragona)




Authors are invited to submit non-anonymized papers in English presenting original and unpublished research. Papers should not exceed 12 single-spaced pages (including eventual appendices, references, proofs, etc.) and should be prepared according to the standard format for Springer Verlag's LNCS series (see


Submissions have to be uploaded to:




A volume of proceedings published by Springer in the LNCS series will be available by the time of the conference.


A special issue of the journal Information and Computation (Elsevier, 2014 JCR impact factor: 0.830) will be later published containing peer-reviewed substantially extended versions of some of the papers contributed to the conference. Submissions to it will be by invitation.




The period for registration is open from August 28, 2015 to March 14, 2016. The registration form can be found at:




Paper submission: October 19, 2015 (23:59 CET)

Notification of paper acceptance or rejection: November 27, 2015

Final version of the paper for the LNCS proceedings: December 7, 2015

Early registration: December 7, 2015

Late registration: February 29, 2016

Submission to the journal special issue: June 18, 2016




florentinalilica.voicu (at)




LATA 2016

Research Group on Mathematical Linguistics (GRLMC)

Rovira i Virgili University

Av. Catalunya, 35

43002 Tarragona, Spain


Phone: +34 977 559 543

Fax: +34 977 558 386




České vysoké učení technické v Praze

Universitat Rovira i Virgili


Ashish Agarwal | 2 Oct 00:28 2015

Re: type synonym for polymorphic variant

On Thu, Oct 1, 2015 at 6:20 PM, Thomas Refis <thomas.refis <at>> wrote:
Note the you could also do "type t = [ | s ]"

Actually I had tried that, but it doesn't work.


2015-10-01 18:06 GMT-04:00 Ashish Agarwal <agarwal1975 <at>>:
> Embarrassing. I don't know why I thought I had to put brackets... Thanks!
> On Thu, Oct 1, 2015 at 5:47 PM, Haoyang Wang <hywang <at>> wrote:
>> > On Oct 1, 2015, at 2:41 PM, Ashish Agarwal <agarwal1975 <at>>
>> > wrote:
>> >
>> > type s = [`A | `B]
>> > type t = [s]
>> type t = s
>> --
>> Caml-list mailing list.  Subscription management and archives:
>> Beginner's list:
>> Bug reports: