Version française
Home     About     Download     Resources     Contact us    
Browse thread
[Caml-list] extensible records again
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Jacques Garrigue <garrigue@k...>
Subject: Re: [Caml-list] extensible records again
From: skaller <skaller@users.sourceforge.net>

> At the moment you can do this:
> 
> type x = [`A | `B ]
> type y = [x | `C ]
> 
> so that y is a subtype (extension) of x.
> 
> You can even match:
> 
> match aY with
> | #x as xv -> xv
> | _ -> failwith "Not an x"
> 
> to reduce aY to an x.

[...]
Let me just add a pointer to the concrete description of how you can
do this with recursive types:
http://wwwfun.kurims.kyoto-u.ac.jp/~garrigue/papers/fose2000.html

It describes in detail the steps to build extensible recursive
datatypes.

> In Felix, I want to partition expressions, types,
> patterns, statements, and a few other kinds of terms
> into one or more classes and use some combinations
> of these: but all these terms are mutually recursive:
> statements can contain expressions and types and patterns,
> patterns have 'when' expressions, types may contain
> "typeof(expression)" as a type, and statements can
> be considered as expressions..
> 
> So I end up with a rather large number of parameters
> on each of the fine grained components I want to combine:
> something like:
> 
> type 'expr 'typ 'pat 'stat expr1 = ....
> ...
> type 'expr 'typ 'pat 'stat typ1 = ...
> ...

The mixin2.ml code on the above page gives an example of you can do
it using classes. Note that this solves only the problem for
functions, not for types.

Another approach, which could maybe solve the problem with type
parameters, would be to use recursive modules: define all your
sublanguages as functors, and close the recursion with a recursive
module definition. Recursive modules are a new feature in ocaml 3.07,
but I think they can help for such problems.
However, there is a difficulty, as all modules in a recursive
definition must have an explicit signature, and the language of module
types seems to be weaker than the language of modules.
The fact one has to duplicate all type definitions is bothering too.

> type x = [`A of +x | `B ]
> type y = [x | `C ]

might be encoded as

module type Xrec = sig type t end
module X0(Xrec : Xrec) =
  struct type t0 = Xrec.t type t = [`A of t0 | `B] end
module type Xsig = sig type t0 type t = [`A of t0 | `B] end
module rec X : (Xsig with type t0 = X.t) = X0(X)
module Y0(Xrec : Xrec) =
  struct
    module XY = X0(Xrec)
    type t0 = Xrec.t
    type t = [XY.t | `C]
  end
module type Ysig = ???
module rec Y : (Xsig with type t0 = Y.t) = Y0(Y)

Jacques Garrigue

-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners