Re: [Caml-list] destructive local opens

[Nils Becker <nils.becker@bioquant.uni-heidelberg.de>]

Sorry for the late comment.

The mentioned bug:

> let ox = V2.((dot v ox) * ox) in
> V2.(3 * ox + oy)

because V2 also has V2.ox sure is nasty. But the same would happen with
a local 'let open V2'.

let ox =
    let open V2 in
    (dot v ox) * ox in
V2.(3 * ox + oy)

For ease of reasoning I think it may be a good idea to make M.(...) and
M.!(...) behave in exactly the same way as let open and let open!
respectively, including error messages. This would probably forbid
distinguishing between infix operators and the rest.

(Admittedly, in the latter example one would be tempted to combine the
local opens here which would make things clearer)

> The reality is that M.() is inherently dangerous,

When one uses a (destructive) local open one trades the possibility of
ambiguity for conciseness. In a few cases the conciseness is really,
really important, so that this trade-off is worth it. (I'm thinking
about math.) The existence of let open! in the language says that there
is some consensus that ambiguity is sometimes acceptable.


>    The benefit is that I can understand what is happening by only
> looking at the
>    expression I'm reading. With your proposal I also need to go read
> the library
>    source to understand what is happening.

It's not that bad. Destructive opens mean one has to know the shadowing
module's signature. Only the values exported in the signature actually
shadow anything (I just tried it out) so one does _not_ need to know the
module source!

Right now, one cannot really use M.(...) to shadow without deactivating
warning 44. This is not ideal. With the syntax M.!(...) one would be
forced to declare shadowing intent and 44 could be switched on. Then

let ox = V2.!((dot v ox) * ox) in
V2.!(3 * ox + oy)

would still let the same bug happen but at least one was forced to write
an exclamation mark which should give a feeling of "be careful about
shadowing here!". Would this not be enough?


n.