User: Password:
|
|
Subscribe / Log in / New account

Attn: Development Editor, Latest OCaml Weekly News

From:  Alan Schmitt <alan.schmitt-AT-polytechnique.org>
To:  "lwn" <lwn-AT-lwn.net>, "cwn" <cwn-AT-lists.idyll.org>
Subject:  Attn: Development Editor, Latest OCaml Weekly News
Date:  Tue, 10 Dec 2013 14:04:15 +0100
Message-ID:  <m2r49k26y8.fsf@polytechnique.org>
Archive-link:  Article

Hello,

Here is the latest OCaml Weekly News, for the week of December 03 to 10, 2013.

1) Wojciech Meyer
2) Polymorphic recursion and GADTs
3) Other Caml News

========================================================================
1) Wojciech Meyer
Archive: <https://sympa.inria.fr/sympa/arc/caml-list/2013-12/msg000...>
------------------------------------------------------------------------
** Vitaly S. Lugovskiy gave some sad news:

It is with great sadness that I am writing to inform that Wojciech
Daniel Meyer, who was known in the OCaml community, passed away 18th
November 2013 at the age of 32.
      
========================================================================
2) Polymorphic recursion and GADTs
Archive: <https://sympa.inria.fr/sympa/arc/caml-list/2013-12/msg000...>
------------------------------------------------------------------------
** Lukasz Stafiniak asked:

I am at a loss as to the difference between ['a.] syntax and [type a.]
syntax of introducing polymorphic recursion. I will provide some examples.
(Bear with me, they are automatically generated.)
>>>
type _ term =
  | Lit : integer -> integer term
  | Plus : integer term * integer term -> integer term
  | IsZero : integer term -> boolean term
  | If : (*?'a.*)boolean term * 'a term * 'a term -> 'a term
and integer

and boolean

external plus : (integer -> integer -> integer) = "plus"
external is_zero : (integer -> boolean) = "is_zero"
external if_then : (boolean -> 'a -> 'a -> 'a) = "if_then"
let rec eval : 'a . ('a term -> 'a) =
  (function Lit i -> i | IsZero x -> is_zero (eval x)
    | Plus (x, y) -> plus (eval x) (eval y)
    | If (b, t, e) -> if_then (eval b) (eval t) (eval e))
<<<
The above produces:
Error: This pattern matches values of type boolean term
       but a pattern was expected which matches values of type integer term
       Type boolean is not compatible with type integer
but if we replace the corresponding line with:
>>>
...
let rec eval : type a . (a term -> a) =
...
<<<
then it compiles fine.

Now to a more complex example. According to my understanding (and
InvarGenT), the following code should type-check:
>>>
type _ place =
  | LocA : a place
  | LocB : b place
and a
and b

type (_, _) nearby =
  | Here : (*?'b.*)'b place * 'b place -> ('b, 'b) nearby
  | Transitive : (*?'a, 'b, 'c.*)('a, 'b) nearby * ('b, 'c) nearby ->
    ('a, 'c) nearby
type boolean

external is_nearby : (('a, 'b) nearby -> boolean) = "is_nearby"
type _ ex1 =
  | Ex1 : (*?'a, 'b.*)('b place * ('a, 'b) nearby) -> 'a ex1
external wander : ('a place -> 'a ex1) = "wander"
type (_, _) meet =
  | Same : (*?'b.*) ('b, 'b) meet
  | NotSame : (*?'a, 'b.*) ('a, 'b) meet
external compare : ('a place -> 'b place -> ('a, 'b) meet) = "compare"
let rec walk : type a b . (a place -> b place -> (a, b) nearby) =
  (fun x goal ->
    ((function Same -> Here (x, goal)
       | NotSame ->
           let Ex1 ((y, to_y)) = wander x in Transitive (to_y, walk y
goal)))
      (compare x goal))
<<<
Here we get
Error: This expression has type b place
       but an expression was expected of type a place
       Type b is not compatible with type a
And when we switch to the ['a.] syntax, we get
Error: This definition has type 'a. 'a place -> 'a place -> ('a, 'a) nearby
       which is less general than
         'a 'b. 'a place -> 'b place -> ('a, 'b) nearby

Thanks in advance for any thoughts.
If you are curious, the source code is:
<https://github.com/lukstafi/invargent/blob/master/example...>
<https://github.com/lukstafi/invargent/blob/master/example...>
      
** Gabriel Scherer replied:

TL;DR: you should use those "rigid variables" to annotate type variable
that will be refined in a GADT pattern matching.

The way GADT type variables can be refined with different types in each
branches is different and orthogonal to the type unification mechanism.
Variables ('a) use type unification on each branch, which fails with the
error you observe. Local type constructors (a), and only them, can be
refined in GADT clauses, so that type refinement works. The syntax
  let rec f : type a . a -> ... = fun x -> ...
as opposed to
  let rec f (type a) (x : a) ... = ...
combines the GADT-readiness of those weird variables with polymorphic
recursion -- which is orthogonal, but in practice they often come together.

For more technical details, see "Ambivalent types for type inference with
GADTs", by Jacques Garrigue and Didier Rémy, 2013:
<http://gallium.inria.fr/~remy/gadts/Garrigue-Remy:gadts@s...>
      
========================================================================
3) 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 <http://planet.ocaml.org/>.

Mirage 1.0: not just a hallucination!:
  <http://openmirage.org/blog/announcing-mirage10>

RWO tidbits: the runtime:
  <https://ocaml.janestreet.com/?q=node/119>
      
========================================================================
Old cwn
------------------------------------------------------------------------

If you happen to miss a CWN, you can send me a message
(alan.schmitt@polytechnique.org) 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
<http://lists.idyll.org/listinfo/caml-news-weekly/> .

========================================================================



(Log in to post comments)


Copyright © 2013, Eklektix, Inc.
Comments and public postings are copyrighted by their creators.
Linux is a registered trademark of Linus Torvalds