Le 30 nov. 05 à 13:19, Jacques Garrigue a écrit :

> Note that with native code you must be careful to compile without any
> .cmx around (only .cmi's), as this would induce dependencies on a
> specific version. This also means that you lose inlining (one major
> advantage of native code.)

I don't understand this. Careful to compile what without which cmx  
around ? And where do you lose inlining ?

I recently got into the same kind of situation and I couldn't solve  
it. So I'm seeking advice on how to solve the following the best way.  
I want to give the choice between three implementation of a library  
lib (which also calls C) in both byte and native code.

1. A debugging version compiled with -g, libdebug.cm(x)a.
2. A normal version, lib.cm(x)a
3. An unsafe version compiled with -unsafe and with some validation  
of input parameters removed, libunsafe.cm(x)a.

The input parameter validation code is centralized in a module Check.  
This module has two implementation : one with the actual checks, and  
the other with dumb checks equal to unit. Functions of the library  
are implemented with this idiom :

let f x = Check.arg x; ...

The idea is to compile the unsafe version with the dumb  
implementation of Check and that the optimizer will remove the calls  
to the validation functions.

My questions are,

1. Is it possible for all versions of this library to share the same  
cmi interfaces ? When I tried to do this, I got these inconsistent  
assumption errors.

2. For the unsafe version, will the calls to the Check functions be  
removed by the optimizer ? My understanding is that they will but  
only for native code compilation, i.e. libunsafe.cmxa. In  
libunsafe.cma we will still have the function call overhead.

Thanks for your help,

Daniel