Better support for mli/rei only modules

[ghost]

Jbuilder now supports them. However, given that we can't check that a module is a pure interfaces and that not respecting this rule could lead to hard to debug errors, the user is required to explicitly list such modules.

The syntax is as follow:

(library
 ((name foo)
  (modules_without_implementation (x y z))))

[kit-ty-kate]

(modules_with_implementation (x y z))))

Isn't it more (modules_without_implementation (x y z)))) ?

[ghost]

Indeed... I updated the description

[rgrinberg]

I noticed that this implementation accepts making the alias module "mli only" when (wrapped true) is set. Is that correct? If it is, what are the semantics of that?

[rgrinberg]

I guess modules without implementation cannot introduce cross module optimization, is that why we add it unconditionally? A bit unrelated but others have noted that this is would be desirable in situations where they prefer faster recompilation over better generated code.

[ghost]

It's to silence a warning from the compiler, for some reason it still looks for the cmx.

A bit unrelated but others have noted that this is would be desirable in situations where they refer faster recompilation over better generated code.

Indeed, we should add support for that at some point. Is -opaque itself enough BTW? Or do we need to hide the cmx files as well

[rgrinberg]

Sure, I've made a ticket for it #497

[ghost]

I noticed that this implementation accepts making the alias module "mli only" when (wrapped true) is set. Is that correct? If it is, what are the semantics of that?

Currerntly the scheme is as follow: for a library named foo:

• if the library has no module Foo, generate one and use it as alias module
• if the library has a module Foo, don't wrap this module and generate the alias module as Foo__

There is no point giving an implementation to Foo__ since the user is not supposed to know it even exist. Now that we support interface only modules, it just seems more natural to make it an interface only module. We might be able to do the same in the first case as well, though I'm not sure it will always work when the user does things such as let module M = Foo in ... or Make(Foo).

[rgrinberg]

Now that we support interface only modules, it just seems more natural to make it an interface only module

Yeah, I think that makes sense if it doesn't break anything.

Ok, looks good. Thanks for explaining.

[ghost]

BTW, I'm wondering if we even need to install foo__.cmi

[samoht]

This should be #489

[ghost]

Indeed, it's now fixed. Thanks