Re: [Caml-list] Warnings opening modules (was: why is building ocaml hard?)

[Yotam Barnoy <yotambarnoy@gmail.com>]

The problem seems to stem from the fact that the same open statements
which we use to import code (and which are available in every
language) are also used as part of OCaml's super-flexible module
system. This makes it hard to come up with easy, simple shortcuts for
functionality available in other languages, because it needs to fit in
the far more complex general module language.

In haskell, I can just say 'import A (foo, bar, baz, t)' to limit
exactly what I want to import. This is because haskell has a
half-baked module system that isn't nearly as powerful as OCaml's,
which allows it to create syntax that doesn't need to go anywhere but
at the toplevel.

We need this functionality in OCaml, but the closest thing is to say
'include struct let foo = A.foo let bar = A.bar let baz = A.baz type t
= A.t end'

I'm not sure if there's a performance cost to doing things this way,
but it's also incredibly verbose and therefore nearly unusable in the
general case simply because it needs to fit into the general module
language.

Additionally, haskell handles module hierarchies gracefully (tying
them to the OS filesystem), while OCaml is stuck with a flat
hierarchy, needing modular tricks to get the same hierarchies that
other languages have naturally (via specialized syntax).

The generality of OCaml's module language is killing its usability for
the most common cases.

On Fri, Jul 15, 2016 at 12:13 PM, Hendrik Boom <hendrik@topoi.pooq.com> wrote:
> On Fri, Jul 15, 2016 at 10:52:38AM +0100, David Allsopp wrote:
>> Goswin von Brederlow wrote:
>>
>> I don't follow what you mean - what I propose changing is that [open Util]
>> would cause a warning and eventually, in some future version of OCaml, be
>> rejected by the compiler. The problem it would solve is that
>> ocamldep/whatever knows that open Foo always refers to a toplevel (or fully
>> qualified) module path.
>>
>> > A (for me) more common code would be:
>> >
>> >     open ReallyCoolLibraryPack
>> >     (* myriad more open statements *)
>> >
>> >     Util.foo bla baz
>> >     module Bla = Util.MAKE(M : FOOABLE)
>> >
>> > You still get the same dependency on ReallyCoolLibraryPack.Util,
>> > ReallyCoolLibraryPack.Util.MAKE, ReallyCoolLibraryPack.FOOABLE, ...
>> > without successive opens.
>>
>> Indeed, that's my preference, although I'm stupidly picky and actually
>> prefer to write:
>>
>> module Util = ReallyCoolLibraryPack.Util
>>
>> but that comes under my list of "strange habits which normal people don't
>> agree with" :o) I'm allergic to anything which involves a wildcard ([open
>> ReallyCoolLibraryPack] being rather too like writing [import
>> ReallyCoolLibraryPack.*;])
>
> And that's a real problem -- that fact that openning a module can fill
> the namespace with lots of stray identifiers, which the user does not
> control.
>
> It may reduce the amount of code you have to write.
>
> But it makes the code unstable in the long run, and it makes it hard to
> read.  The naive reader will encounter identifiers and have no idea
> where to look for their definitions.
>
> It's not just a problem with modules that define modules.  It'a a
> problem with modules that define anything.
>
> To alleviate this, either specify explicitly what names you are
> accepting definitions of when you open a module, or, after you open a
> module, mention the module name very time you use one if its defined
> names, as, Module.name instead of just name.
>
> And make the compiler check this.  Withiut a constraint like this, I
> find much OCaml code incomprehensible.
>
> Or is there some kind of code browsing tool that explicates all this?
>
> -- hendrik
>
> --
> Caml-list mailing list.  Subscription management and archives:
> https://sympa.inria.fr/sympa/arc/caml-list
> Beginner's list: http://groups.yahoo.com/group/ocaml_beginners
> Bug reports: http://caml.inria.fr/bin/caml-bugs