English version
Accueil     À propos     Téléchargement     Ressources     Contactez-nous    
Browse thread
[Caml-list] about Obj.magic
[ Home ] [ Index: by date | by threads ]
[ Search: ]

[ Message by date: previous | next ] [ Message in thread: previous | next ] [ Thread: previous | next ]
Date: -- (:)
From: Pierre Weis <pierre.weis@i...>
Subject: Re: [Caml-list] about Obj.magic
> Hi,Jacques,
> 
> Thanks for your help! You are right. I solved it by following your
> suggestion. The problem is exactly what you said: ty is abstarct. After
> I added the equation ty = ty1 -> ty2 in the signature where ty was
> defined, I got rid of 'Obj.magic'.
> 
> Now I am wondering why Ocaml compiler makes the type declaration
> abstract unless you specify like : 
>     type ty = ty1 -> ty2
> in the signature, since all the functions are concrete. I took it for
> granted that the type (ty) must be concrete. 

If you need it to be concrete export it as concrete, i.e. with a
definition.

> I always met some type problems in Ocaml. The common case is as follows:
> Suppose I define a module 'Test' (test.ml)
> ----------------------
> module Test : TEST =
>   struct
>      type ty =
>           | Int of int
> 	  | String of string
> 	  | Float of float
>   end;;
> ------------------------------
> and define the signature as :
> -----------------------
> module type TEST =
>   sig
>     type ty
>   end;;
> -----------------------

You exported ty as abstract again! If you want to use ty as concrete
export its definition as in

module type TEST =
   sig
     type ty =
        | Int of int
        | String of string
        | Float of float
   end;;

> Suppose that type ty is very common among all my modules and I want to
> reuse it as following:
> 
> let f x =
>   match x with
>   | Int _ -> 1
>   | String _ -> 2
>   | Float _ -> 3
> 
> where, I want x to has type ty.
> 
> In this case, the only method I can find is to open the module 'Test'.


Yes it's a good way to use the Module Test. Alternatively you can
qualify stuff from the module by prefixing identifiers with the name
of the module they belong to.

let f = function
  | Test.Int _ -> 1
  | Test.String _ -> 2
  | Test.Float _ -> 3

> Actually, 'open' is not a good way which I tried to avoid. Because I
> don't know what the expenses of 'open' is.

open cost nothing in terms of runtime execution: it is just a compiler
directive that avoid writing Test. all over the place, if Test is used
everywhere.

For more extensive discussion about ``open'' have a look at the
programming guide lines for Caml

http://pauillac.inria.fr/caml/pgl-eng.html

> Another reason is if I open a few modules, function overwrite will
> happen,

Not overwrite but masquerading, which far less complex and error prone.

> and it is difficult for me to find out the origins of all the
> imported functions.
>  Dengping

You should use emacs tags for that (assuming not every function in
your appli is named f or g) ...

Regards,

Pierre Weis

INRIA, Projet Cristal, Pierre.Weis@inria.fr, http://pauillac.inria.fr/~weis/


-------------------
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